app/test/test_cryptodev.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2015-2020 Intel Corporation
   3  * Copyright 2020 NXP
   4  */
   5
   6 #ifndef RTE_EXEC_ENV_WINDOWS
   7
   8 #include <time.h>
   9
  10 #include <rte_common.h>
  11 #include <rte_hexdump.h>
  12 #include <rte_mbuf.h>
  13 #include <rte_malloc.h>
  14 #include <rte_memcpy.h>
  15 #include <rte_pause.h>
  16 #include <rte_bus_vdev.h>
  17 #include <rte_ether.h>
  18
  19 #include <rte_crypto.h>
  20 #include <rte_cryptodev.h>
  21 #include <rte_ip.h>
  22 #include <rte_string_fns.h>
  23 #include <rte_tcp.h>
  24 #include <rte_udp.h>
  25
  26 #ifdef RTE_CRYPTO_SCHEDULER
  27 #include <rte_cryptodev_scheduler.h>
  28 #include <rte_cryptodev_scheduler_operations.h>
  29 #endif
  30
  31 #include <rte_lcore.h>
  32
  33 #include "test.h"
  34 #include "test_cryptodev.h"
  35
  36 #include "test_cryptodev_blockcipher.h"
  37 #include "test_cryptodev_aes_test_vectors.h"
  38 #include "test_cryptodev_des_test_vectors.h"
  39 #include "test_cryptodev_hash_test_vectors.h"
  40 #include "test_cryptodev_kasumi_test_vectors.h"
  41 #include "test_cryptodev_kasumi_hash_test_vectors.h"
  42 #include "test_cryptodev_snow3g_test_vectors.h"
  43 #include "test_cryptodev_snow3g_hash_test_vectors.h"
  44 #include "test_cryptodev_zuc_test_vectors.h"
  45 #include "test_cryptodev_aead_test_vectors.h"
  46 #include "test_cryptodev_hmac_test_vectors.h"
  47 #include "test_cryptodev_mixed_test_vectors.h"
  48 #ifdef RTE_LIB_SECURITY
  49 #include "test_cryptodev_security_ipsec.h"
  50 #include "test_cryptodev_security_ipsec_test_vectors.h"
  51 #include "test_cryptodev_security_pdcp_test_vectors.h"
  52 #include "test_cryptodev_security_pdcp_sdap_test_vectors.h"
  53 #include "test_cryptodev_security_pdcp_test_func.h"
  54 #include "test_cryptodev_security_docsis_test_vectors.h"
  55
  56 #define SDAP_DISABLED   0
  57 #define SDAP_ENABLED    1
  58 #endif
  59
  60 #define VDEV_ARGS_SIZE 100
  61 #define MAX_NB_SESSIONS 4
  62
  63 #define MAX_DRV_SERVICE_CTX_SIZE 256
  64
  65 #define MAX_RAW_DEQUEUE_COUNT   65535
  66
  67 #define IN_PLACE 0
  68 #define OUT_OF_PLACE 1
  69
  70 static int gbl_driver_id;
  71
  72 static enum rte_security_session_action_type gbl_action_type =
  73         RTE_SECURITY_ACTION_TYPE_NONE;
  74
  75 enum cryptodev_api_test_type global_api_test_type = CRYPTODEV_API_TEST;
  76
  77 struct crypto_unittest_params {
  78         struct rte_crypto_sym_xform cipher_xform;
  79         struct rte_crypto_sym_xform auth_xform;
  80         struct rte_crypto_sym_xform aead_xform;
  81 #ifdef RTE_LIB_SECURITY
  82         struct rte_security_docsis_xform docsis_xform;
  83 #endif
  84
  85         union {
  86                 struct rte_cryptodev_sym_session *sess;
  87 #ifdef RTE_LIB_SECURITY
  88                 struct rte_security_session *sec_session;
  89 #endif
  90         };
  91 #ifdef RTE_LIB_SECURITY
  92         enum rte_security_session_action_type type;
  93 #endif
  94         struct rte_crypto_op *op;
  95
  96         struct rte_mbuf *obuf, *ibuf;
  97
  98         uint8_t *digest;
  99 };
 100
 101 #define ALIGN_POW2_ROUNDUP(num, align) \
 102         (((num) + (align) - 1) & ~((align) - 1))
 103
 104 #define ADD_STATIC_TESTSUITE(index, parent_ts, child_ts, num_child_ts)  \
 105         for (j = 0; j < num_child_ts; index++, j++)                     \
 106                 parent_ts.unit_test_suites[index] = child_ts[j]
 107
 108 #define ADD_BLOCKCIPHER_TESTSUITE(index, parent_ts, blk_types, num_blk_types)   \
 109         for (j = 0; j < num_blk_types; index++, j++)                            \
 110                 parent_ts.unit_test_suites[index] =                             \
 111                                 build_blockcipher_test_suite(blk_types[j])
 112
 113 #define FREE_BLOCKCIPHER_TESTSUITE(index, parent_ts, num_blk_types)             \
 114         for (j = index; j < index + num_blk_types; j++)                         \
 115                 free_blockcipher_test_suite(parent_ts.unit_test_suites[j])
 116
 117 /*
 118  * Forward declarations.
 119  */
 120 static int
 121 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
 122                 struct crypto_unittest_params *ut_params, uint8_t *cipher_key,
 123                 uint8_t *hmac_key);
 124
 125 static int
 126 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
 127                 struct crypto_unittest_params *ut_params,
 128                 struct crypto_testsuite_params *ts_param,
 129                 const uint8_t *cipher,
 130                 const uint8_t *digest,
 131                 const uint8_t *iv);
 132
 133 static int
 134 security_proto_supported(enum rte_security_session_action_type action,
 135         enum rte_security_session_protocol proto);
 136
 137 static int
 138 dev_configure_and_start(uint64_t ff_disable);
 139
 140 static struct rte_mbuf *
 141 setup_test_string(struct rte_mempool *mpool,
 142                 const char *string, size_t len, uint8_t blocksize)
 143 {
 144         struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
 145         size_t t_len = len - (blocksize ? (len % blocksize) : 0);
 146
 147         if (m) {
 148                 char *dst;
 149
 150                 memset(m->buf_addr, 0, m->buf_len);
 151                 dst = rte_pktmbuf_append(m, t_len);
 152                 if (!dst) {
 153                         rte_pktmbuf_free(m);
 154                         return NULL;
 155                 }
 156                 if (string != NULL)
 157                         rte_memcpy(dst, string, t_len);
 158                 else
 159                         memset(dst, 0, t_len);
 160         }
 161
 162         return m;
 163 }
 164
 165 /* Get number of bytes in X bits (rounding up) */
 166 static uint32_t
 167 ceil_byte_length(uint32_t num_bits)
 168 {
 169         if (num_bits % 8)
 170                 return ((num_bits >> 3) + 1);
 171         else
 172                 return (num_bits >> 3);
 173 }
 174
 175 static void
 176 post_process_raw_dp_op(void *user_data, uint32_t index __rte_unused,
 177                 uint8_t is_op_success)
 178 {
 179         struct rte_crypto_op *op = user_data;
 180         op->status = is_op_success ? RTE_CRYPTO_OP_STATUS_SUCCESS :
 181                         RTE_CRYPTO_OP_STATUS_ERROR;
 182 }
 183
 184 static struct crypto_testsuite_params testsuite_params = { NULL };
 185 struct crypto_testsuite_params *p_testsuite_params = &testsuite_params;
 186 static struct crypto_unittest_params unittest_params;
 187
 188 void
 189 process_sym_raw_dp_op(uint8_t dev_id, uint16_t qp_id,
 190                 struct rte_crypto_op *op, uint8_t is_cipher, uint8_t is_auth,
 191                 uint8_t len_in_bits, uint8_t cipher_iv_len)
 192 {
 193         struct rte_crypto_sym_op *sop = op->sym;
 194         struct rte_crypto_op *ret_op = NULL;
 195         struct rte_crypto_vec data_vec[UINT8_MAX], dest_data_vec[UINT8_MAX];
 196         struct rte_crypto_va_iova_ptr cipher_iv, digest, aad_auth_iv;
 197         union rte_crypto_sym_ofs ofs;
 198         struct rte_crypto_sym_vec vec;
 199         struct rte_crypto_sgl sgl, dest_sgl;
 200         uint32_t max_len;
 201         union rte_cryptodev_session_ctx sess;
 202         uint64_t auth_end_iova;
 203         uint32_t count = 0;
 204         struct rte_crypto_raw_dp_ctx *ctx;
 205         uint32_t cipher_offset = 0, cipher_len = 0, auth_offset = 0,
 206                         auth_len = 0;
 207         int32_t n;
 208         uint32_t n_success;
 209         int ctx_service_size;
 210         int32_t status = 0;
 211         int enqueue_status, dequeue_status;
 212         struct crypto_unittest_params *ut_params = &unittest_params;
 213         int is_sgl = sop->m_src->nb_segs > 1;
 214         int is_oop = 0;
 215
 216         ctx_service_size = rte_cryptodev_get_raw_dp_ctx_size(dev_id);
 217         if (ctx_service_size < 0) {
 218                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 219                 return;
 220         }
 221
 222         ctx = malloc(ctx_service_size);
 223         if (!ctx) {
 224                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 225                 return;
 226         }
 227
 228         /* Both are enums, setting crypto_sess will suit any session type */
 229         sess.crypto_sess = op->sym->session;
 230
 231         if (rte_cryptodev_configure_raw_dp_ctx(dev_id, qp_id, ctx,
 232                         op->sess_type, sess, 0) < 0) {
 233                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 234                 goto exit;
 235         }
 236
 237         cipher_iv.iova = 0;
 238         cipher_iv.va = NULL;
 239         aad_auth_iv.iova = 0;
 240         aad_auth_iv.va = NULL;
 241         digest.iova = 0;
 242         digest.va = NULL;
 243         sgl.vec = data_vec;
 244         vec.num = 1;
 245         vec.src_sgl = &sgl;
 246         vec.iv = &cipher_iv;
 247         vec.digest = &digest;
 248         vec.aad = &aad_auth_iv;
 249         vec.status = &status;
 250
 251         ofs.raw = 0;
 252
 253         if ((sop->m_dst != NULL) && (sop->m_dst != sop->m_src))
 254                 is_oop = 1;
 255
 256         if (is_cipher && is_auth) {
 257                 cipher_offset = sop->cipher.data.offset;
 258                 cipher_len = sop->cipher.data.length;
 259                 auth_offset = sop->auth.data.offset;
 260                 auth_len = sop->auth.data.length;
 261                 max_len = RTE_MAX(cipher_offset + cipher_len,
 262                                 auth_offset + auth_len);
 263                 if (len_in_bits) {
 264                         max_len = max_len >> 3;
 265                         cipher_offset = cipher_offset >> 3;
 266                         auth_offset = auth_offset >> 3;
 267                         cipher_len = cipher_len >> 3;
 268                         auth_len = auth_len >> 3;
 269                 }
 270                 ofs.ofs.cipher.head = cipher_offset;
 271                 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
 272                 ofs.ofs.auth.head = auth_offset;
 273                 ofs.ofs.auth.tail = max_len - auth_offset - auth_len;
 274                 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 275                 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
 276                 aad_auth_iv.va = rte_crypto_op_ctod_offset(
 277                                 op, void *, IV_OFFSET + cipher_iv_len);
 278                 aad_auth_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET +
 279                                 cipher_iv_len);
 280                 digest.va = (void *)sop->auth.digest.data;
 281                 digest.iova = sop->auth.digest.phys_addr;
 282
 283                 if (is_sgl) {
 284                         uint32_t remaining_off = auth_offset + auth_len;
 285                         struct rte_mbuf *sgl_buf = sop->m_src;
 286                         if (is_oop)
 287                                 sgl_buf = sop->m_dst;
 288
 289                         while (remaining_off >= rte_pktmbuf_data_len(sgl_buf)
 290                                         && sgl_buf->next != NULL) {
 291                                 remaining_off -= rte_pktmbuf_data_len(sgl_buf);
 292                                 sgl_buf = sgl_buf->next;
 293                         }
 294
 295                         auth_end_iova = (uint64_t)rte_pktmbuf_iova_offset(
 296                                 sgl_buf, remaining_off);
 297                 } else {
 298                         auth_end_iova = rte_pktmbuf_iova(op->sym->m_src) +
 299                                                          auth_offset + auth_len;
 300                 }
 301                 /* Then check if digest-encrypted conditions are met */
 302                 if ((auth_offset + auth_len < cipher_offset + cipher_len) &&
 303                                 (digest.iova == auth_end_iova) && is_sgl)
 304                         max_len = RTE_MAX(max_len,
 305                                 auth_offset + auth_len +
 306                                 ut_params->auth_xform.auth.digest_length);
 307
 308         } else if (is_cipher) {
 309                 cipher_offset = sop->cipher.data.offset;
 310                 cipher_len = sop->cipher.data.length;
 311                 max_len = cipher_len + cipher_offset;
 312                 if (len_in_bits) {
 313                         max_len = max_len >> 3;
 314                         cipher_offset = cipher_offset >> 3;
 315                         cipher_len = cipher_len >> 3;
 316                 }
 317                 ofs.ofs.cipher.head = cipher_offset;
 318                 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
 319                 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 320                 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
 321
 322         } else if (is_auth) {
 323                 auth_offset = sop->auth.data.offset;
 324                 auth_len = sop->auth.data.length;
 325                 max_len = auth_len + auth_offset;
 326                 if (len_in_bits) {
 327                         max_len = max_len >> 3;
 328                         auth_offset = auth_offset >> 3;
 329                         auth_len = auth_len >> 3;
 330                 }
 331                 ofs.ofs.auth.head = auth_offset;
 332                 ofs.ofs.auth.tail = max_len - auth_offset - auth_len;
 333                 aad_auth_iv.va = rte_crypto_op_ctod_offset(
 334                                 op, void *, IV_OFFSET + cipher_iv_len);
 335                 aad_auth_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET +
 336                                 cipher_iv_len);
 337                 digest.va = (void *)sop->auth.digest.data;
 338                 digest.iova = sop->auth.digest.phys_addr;
 339
 340         } else { /* aead */
 341                 cipher_offset = sop->aead.data.offset;
 342                 cipher_len = sop->aead.data.length;
 343                 max_len = cipher_len + cipher_offset;
 344                 if (len_in_bits) {
 345                         max_len = max_len >> 3;
 346                         cipher_offset = cipher_offset >> 3;
 347                         cipher_len = cipher_len >> 3;
 348                 }
 349                 ofs.ofs.cipher.head = cipher_offset;
 350                 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
 351                 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 352                 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
 353                 aad_auth_iv.va = (void *)sop->aead.aad.data;
 354                 aad_auth_iv.iova = sop->aead.aad.phys_addr;
 355                 digest.va = (void *)sop->aead.digest.data;
 356                 digest.iova = sop->aead.digest.phys_addr;
 357         }
 358
 359         n = rte_crypto_mbuf_to_vec(sop->m_src, 0, max_len,
 360                         data_vec, RTE_DIM(data_vec));
 361         if (n < 0 || n > sop->m_src->nb_segs) {
 362                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 363                 goto exit;
 364         }
 365
 366         sgl.num = n;
 367         /* Out of place */
 368         if (is_oop) {
 369                 dest_sgl.vec = dest_data_vec;
 370                 vec.dest_sgl = &dest_sgl;
 371                 n = rte_crypto_mbuf_to_vec(sop->m_dst, 0, max_len,
 372                                 dest_data_vec, RTE_DIM(dest_data_vec));
 373                 if (n < 0 || n > sop->m_dst->nb_segs) {
 374                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 375                         goto exit;
 376                 }
 377                 dest_sgl.num = n;
 378         } else
 379                 vec.dest_sgl = NULL;
 380
 381         if (rte_cryptodev_raw_enqueue_burst(ctx, &vec, ofs, (void **)&op,
 382                         &enqueue_status) < 1) {
 383                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 384                 goto exit;
 385         }
 386
 387         if (enqueue_status == 0) {
 388                 status = rte_cryptodev_raw_enqueue_done(ctx, 1);
 389                 if (status < 0) {
 390                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 391                         goto exit;
 392                 }
 393         } else if (enqueue_status < 0) {
 394                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 395                 goto exit;
 396         }
 397
 398         n = n_success = 0;
 399         while (count++ < MAX_RAW_DEQUEUE_COUNT && n == 0) {
 400                 n = rte_cryptodev_raw_dequeue_burst(ctx,
 401                         NULL, 1, post_process_raw_dp_op,
 402                                 (void **)&ret_op, 0, &n_success,
 403                                 &dequeue_status);
 404                 if (dequeue_status < 0) {
 405                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 406                         goto exit;
 407                 }
 408                 if (n == 0)
 409                         rte_pause();
 410         }
 411
 412         if (n == 1 && dequeue_status == 0) {
 413                 if (rte_cryptodev_raw_dequeue_done(ctx, 1) < 0) {
 414                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 415                         goto exit;
 416                 }
 417         }
 418
 419         op->status = (count == MAX_RAW_DEQUEUE_COUNT + 1 || ret_op != op ||
 420                         ret_op->status == RTE_CRYPTO_OP_STATUS_ERROR ||
 421                         n_success < 1) ? RTE_CRYPTO_OP_STATUS_ERROR :
 422                                         RTE_CRYPTO_OP_STATUS_SUCCESS;
 423
 424 exit:
 425         free(ctx);
 426 }
 427
 428 static void
 429 process_cpu_aead_op(uint8_t dev_id, struct rte_crypto_op *op)
 430 {
 431         int32_t n, st;
 432         struct rte_crypto_sym_op *sop;
 433         union rte_crypto_sym_ofs ofs;
 434         struct rte_crypto_sgl sgl;
 435         struct rte_crypto_sym_vec symvec;
 436         struct rte_crypto_va_iova_ptr iv_ptr, aad_ptr, digest_ptr;
 437         struct rte_crypto_vec vec[UINT8_MAX];
 438
 439         sop = op->sym;
 440
 441         n = rte_crypto_mbuf_to_vec(sop->m_src, sop->aead.data.offset,
 442                 sop->aead.data.length, vec, RTE_DIM(vec));
 443
 444         if (n < 0 || n != sop->m_src->nb_segs) {
 445                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 446                 return;
 447         }
 448
 449         sgl.vec = vec;
 450         sgl.num = n;
 451         symvec.src_sgl = &sgl;
 452         symvec.iv = &iv_ptr;
 453         symvec.digest = &digest_ptr;
 454         symvec.aad = &aad_ptr;
 455         symvec.status = &st;
 456         symvec.num = 1;
 457
 458         /* for CPU crypto the IOVA address is not required */
 459         iv_ptr.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 460         digest_ptr.va = (void *)sop->aead.digest.data;
 461         aad_ptr.va = (void *)sop->aead.aad.data;
 462
 463         ofs.raw = 0;
 464
 465         n = rte_cryptodev_sym_cpu_crypto_process(dev_id, sop->session, ofs,
 466                 &symvec);
 467
 468         if (n != 1)
 469                 op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
 470         else
 471                 op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
 472 }
 473
 474 static void
 475 process_cpu_crypt_auth_op(uint8_t dev_id, struct rte_crypto_op *op)
 476 {
 477         int32_t n, st;
 478         struct rte_crypto_sym_op *sop;
 479         union rte_crypto_sym_ofs ofs;
 480         struct rte_crypto_sgl sgl;
 481         struct rte_crypto_sym_vec symvec;
 482         struct rte_crypto_va_iova_ptr iv_ptr, digest_ptr;
 483         struct rte_crypto_vec vec[UINT8_MAX];
 484
 485         sop = op->sym;
 486
 487         n = rte_crypto_mbuf_to_vec(sop->m_src, sop->auth.data.offset,
 488                 sop->auth.data.length, vec, RTE_DIM(vec));
 489
 490         if (n < 0 || n != sop->m_src->nb_segs) {
 491                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 492                 return;
 493         }
 494
 495         sgl.vec = vec;
 496         sgl.num = n;
 497         symvec.src_sgl = &sgl;
 498         symvec.iv = &iv_ptr;
 499         symvec.digest = &digest_ptr;
 500         symvec.status = &st;
 501         symvec.num = 1;
 502
 503         iv_ptr.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 504         digest_ptr.va = (void *)sop->auth.digest.data;
 505
 506         ofs.raw = 0;
 507         ofs.ofs.cipher.head = sop->cipher.data.offset - sop->auth.data.offset;
 508         ofs.ofs.cipher.tail = (sop->auth.data.offset + sop->auth.data.length) -
 509                 (sop->cipher.data.offset + sop->cipher.data.length);
 510
 511         n = rte_cryptodev_sym_cpu_crypto_process(dev_id, sop->session, ofs,
 512                 &symvec);
 513
 514         if (n != 1)
 515                 op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
 516         else
 517                 op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
 518 }
 519
 520 static struct rte_crypto_op *
 521 process_crypto_request(uint8_t dev_id, struct rte_crypto_op *op)
 522 {
 523
 524         RTE_VERIFY(gbl_action_type != RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO);
 525
 526         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
 527                 RTE_LOG(ERR, USER1, "Error sending packet for encryption\n");
 528                 return NULL;
 529         }
 530
 531         op = NULL;
 532
 533         while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0)
 534                 rte_pause();
 535
 536         if (op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
 537                 RTE_LOG(DEBUG, USER1, "Operation status %d\n", op->status);
 538                 return NULL;
 539         }
 540
 541         return op;
 542 }
 543
 544 static int
 545 testsuite_setup(void)
 546 {
 547         struct crypto_testsuite_params *ts_params = &testsuite_params;
 548         struct rte_cryptodev_info info;
 549         uint32_t i = 0, nb_devs, dev_id;
 550         uint16_t qp_id;
 551
 552         memset(ts_params, 0, sizeof(*ts_params));
 553
 554         ts_params->mbuf_pool = rte_mempool_lookup("CRYPTO_MBUFPOOL");
 555         if (ts_params->mbuf_pool == NULL) {
 556                 /* Not already created so create */
 557                 ts_params->mbuf_pool = rte_pktmbuf_pool_create(
 558                                 "CRYPTO_MBUFPOOL",
 559                                 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
 560                                 rte_socket_id());
 561                 if (ts_params->mbuf_pool == NULL) {
 562                         RTE_LOG(ERR, USER1, "Can't create CRYPTO_MBUFPOOL\n");
 563                         return TEST_FAILED;
 564                 }
 565         }
 566
 567         ts_params->large_mbuf_pool = rte_mempool_lookup(
 568                         "CRYPTO_LARGE_MBUFPOOL");
 569         if (ts_params->large_mbuf_pool == NULL) {
 570                 /* Not already created so create */
 571                 ts_params->large_mbuf_pool = rte_pktmbuf_pool_create(
 572                                 "CRYPTO_LARGE_MBUFPOOL",
 573                                 1, 0, 0, UINT16_MAX,
 574                                 rte_socket_id());
 575                 if (ts_params->large_mbuf_pool == NULL) {
 576                         RTE_LOG(ERR, USER1,
 577                                 "Can't create CRYPTO_LARGE_MBUFPOOL\n");
 578                         return TEST_FAILED;
 579                 }
 580         }
 581
 582         ts_params->op_mpool = rte_crypto_op_pool_create(
 583                         "MBUF_CRYPTO_SYM_OP_POOL",
 584                         RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 585                         NUM_MBUFS, MBUF_CACHE_SIZE,
 586                         DEFAULT_NUM_XFORMS *
 587                         sizeof(struct rte_crypto_sym_xform) +
 588                         MAXIMUM_IV_LENGTH,
 589                         rte_socket_id());
 590         if (ts_params->op_mpool == NULL) {
 591                 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
 592                 return TEST_FAILED;
 593         }
 594
 595         nb_devs = rte_cryptodev_count();
 596         if (nb_devs < 1) {
 597                 RTE_LOG(WARNING, USER1, "No crypto devices found?\n");
 598                 return TEST_SKIPPED;
 599         }
 600
 601         if (rte_cryptodev_device_count_by_driver(gbl_driver_id) < 1) {
 602                 RTE_LOG(WARNING, USER1, "No %s devices found?\n",
 603                                 rte_cryptodev_driver_name_get(gbl_driver_id));
 604                 return TEST_SKIPPED;
 605         }
 606
 607         /* Create list of valid crypto devs */
 608         for (i = 0; i < nb_devs; i++) {
 609                 rte_cryptodev_info_get(i, &info);
 610                 if (info.driver_id == gbl_driver_id)
 611                         ts_params->valid_devs[ts_params->valid_dev_count++] = i;
 612         }
 613
 614         if (ts_params->valid_dev_count < 1)
 615                 return TEST_FAILED;
 616
 617         /* Set up all the qps on the first of the valid devices found */
 618
 619         dev_id = ts_params->valid_devs[0];
 620
 621         rte_cryptodev_info_get(dev_id, &info);
 622
 623         ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
 624         ts_params->conf.socket_id = SOCKET_ID_ANY;
 625         ts_params->conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY;
 626
 627         unsigned int session_size =
 628                 rte_cryptodev_sym_get_private_session_size(dev_id);
 629
 630 #ifdef RTE_LIB_SECURITY
 631         unsigned int security_session_size = rte_security_session_get_size(
 632                         rte_cryptodev_get_sec_ctx(dev_id));
 633
 634         if (session_size < security_session_size)
 635                 session_size = security_session_size;
 636 #endif
 637         /*
 638          * Create mempool with maximum number of sessions.
 639          */
 640         if (info.sym.max_nb_sessions != 0 &&
 641                         info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
 642                 RTE_LOG(ERR, USER1, "Device does not support "
 643                                 "at least %u sessions\n",
 644                                 MAX_NB_SESSIONS);
 645                 return TEST_FAILED;
 646         }
 647
 648         ts_params->session_mpool = rte_cryptodev_sym_session_pool_create(
 649                         "test_sess_mp", MAX_NB_SESSIONS, 0, 0, 0,
 650                         SOCKET_ID_ANY);
 651         TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
 652                         "session mempool allocation failed");
 653
 654         ts_params->session_priv_mpool = rte_mempool_create(
 655                         "test_sess_mp_priv",
 656                         MAX_NB_SESSIONS,
 657                         session_size,
 658                         0, 0, NULL, NULL, NULL,
 659                         NULL, SOCKET_ID_ANY,
 660                         0);
 661         TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
 662                         "session mempool allocation failed");
 663
 664
 665
 666         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id,
 667                         &ts_params->conf),
 668                         "Failed to configure cryptodev %u with %u qps",
 669                         dev_id, ts_params->conf.nb_queue_pairs);
 670
 671         ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
 672         ts_params->qp_conf.mp_session = ts_params->session_mpool;
 673         ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
 674
 675         for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) {
 676                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 677                         dev_id, qp_id, &ts_params->qp_conf,
 678                         rte_cryptodev_socket_id(dev_id)),
 679                         "Failed to setup queue pair %u on cryptodev %u",
 680                         qp_id, dev_id);
 681         }
 682
 683         return TEST_SUCCESS;
 684 }
 685
 686 static void
 687 testsuite_teardown(void)
 688 {
 689         struct crypto_testsuite_params *ts_params = &testsuite_params;
 690         int res;
 691
 692         if (ts_params->mbuf_pool != NULL) {
 693                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
 694                 rte_mempool_avail_count(ts_params->mbuf_pool));
 695         }
 696
 697         if (ts_params->op_mpool != NULL) {
 698                 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n",
 699                 rte_mempool_avail_count(ts_params->op_mpool));
 700         }
 701
 702         /* Free session mempools */
 703         if (ts_params->session_priv_mpool != NULL) {
 704                 rte_mempool_free(ts_params->session_priv_mpool);
 705                 ts_params->session_priv_mpool = NULL;
 706         }
 707
 708         if (ts_params->session_mpool != NULL) {
 709                 rte_mempool_free(ts_params->session_mpool);
 710                 ts_params->session_mpool = NULL;
 711         }
 712
 713         res = rte_cryptodev_close(ts_params->valid_devs[0]);
 714         if (res)
 715                 RTE_LOG(ERR, USER1, "Crypto device close error %d\n", res);
 716 }
 717
 718 static int
 719 check_capabilities_supported(enum rte_crypto_sym_xform_type type,
 720                 const int *algs, uint16_t num_algs)
 721 {
 722         uint8_t dev_id = testsuite_params.valid_devs[0];
 723         bool some_alg_supported = FALSE;
 724         uint16_t i;
 725
 726         for (i = 0; i < num_algs && !some_alg_supported; i++) {
 727                 struct rte_cryptodev_sym_capability_idx alg = {
 728                         type, {algs[i]}
 729                 };
 730                 if (rte_cryptodev_sym_capability_get(dev_id,
 731                                 &alg) != NULL)
 732                         some_alg_supported = TRUE;
 733         }
 734         if (!some_alg_supported)
 735                 return TEST_SKIPPED;
 736
 737         return 0;
 738 }
 739
 740 int
 741 check_cipher_capabilities_supported(const enum rte_crypto_cipher_algorithm *ciphers,
 742                 uint16_t num_ciphers)
 743 {
 744         return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_CIPHER,
 745                         (const int *) ciphers, num_ciphers);
 746 }
 747
 748 int
 749 check_auth_capabilities_supported(const enum rte_crypto_auth_algorithm *auths,
 750                 uint16_t num_auths)
 751 {
 752         return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_AUTH,
 753                         (const int *) auths, num_auths);
 754 }
 755
 756 int
 757 check_aead_capabilities_supported(const enum rte_crypto_aead_algorithm *aeads,
 758                 uint16_t num_aeads)
 759 {
 760         return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_AEAD,
 761                         (const int *) aeads, num_aeads);
 762 }
 763
 764 static int
 765 null_testsuite_setup(void)
 766 {
 767         struct crypto_testsuite_params *ts_params = &testsuite_params;
 768         uint8_t dev_id = ts_params->valid_devs[0];
 769         struct rte_cryptodev_info dev_info;
 770         const enum rte_crypto_cipher_algorithm ciphers[] = {
 771                 RTE_CRYPTO_CIPHER_NULL
 772         };
 773         const enum rte_crypto_auth_algorithm auths[] = {
 774                 RTE_CRYPTO_AUTH_NULL
 775         };
 776
 777         rte_cryptodev_info_get(dev_id, &dev_info);
 778
 779         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
 780                 RTE_LOG(INFO, USER1, "Feature flag requirements for NULL "
 781                                 "testsuite not met\n");
 782                 return TEST_SKIPPED;
 783         }
 784
 785         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
 786                         && check_auth_capabilities_supported(auths,
 787                         RTE_DIM(auths)) != 0) {
 788                 RTE_LOG(INFO, USER1, "Capability requirements for NULL "
 789                                 "testsuite not met\n");
 790                 return TEST_SKIPPED;
 791         }
 792
 793         return 0;
 794 }
 795
 796 static int
 797 crypto_gen_testsuite_setup(void)
 798 {
 799         struct crypto_testsuite_params *ts_params = &testsuite_params;
 800         uint8_t dev_id = ts_params->valid_devs[0];
 801         struct rte_cryptodev_info dev_info;
 802
 803         rte_cryptodev_info_get(dev_id, &dev_info);
 804
 805         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
 806                 RTE_LOG(INFO, USER1, "Feature flag requirements for Crypto Gen "
 807                                 "testsuite not met\n");
 808                 return TEST_SKIPPED;
 809         }
 810
 811         return 0;
 812 }
 813
 814 #ifdef RTE_LIB_SECURITY
 815 static int
 816 ipsec_proto_testsuite_setup(void)
 817 {
 818         struct crypto_testsuite_params *ts_params = &testsuite_params;
 819         struct crypto_unittest_params *ut_params = &unittest_params;
 820         struct rte_cryptodev_info dev_info;
 821         int ret = 0;
 822
 823         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 824
 825         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SECURITY)) {
 826                 RTE_LOG(INFO, USER1, "Feature flag requirements for IPsec Proto "
 827                                 "testsuite not met\n");
 828                 return TEST_SKIPPED;
 829         }
 830
 831         /* Reconfigure to enable security */
 832         ret = dev_configure_and_start(0);
 833         if (ret != TEST_SUCCESS)
 834                 return ret;
 835
 836         /* Set action type */
 837         ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
 838
 839         if (security_proto_supported(
 840                         RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
 841                         RTE_SECURITY_PROTOCOL_IPSEC) < 0) {
 842                 RTE_LOG(INFO, USER1, "Capability requirements for IPsec Proto "
 843                                 "test not met\n");
 844                 ret = TEST_SKIPPED;
 845         }
 846
 847         test_ipsec_alg_list_populate();
 848         test_ipsec_ah_alg_list_populate();
 849
 850         /*
 851          * Stop the device. Device would be started again by individual test
 852          * case setup routine.
 853          */
 854         rte_cryptodev_stop(ts_params->valid_devs[0]);
 855
 856         return ret;
 857 }
 858
 859 static int
 860 pdcp_proto_testsuite_setup(void)
 861 {
 862         struct crypto_testsuite_params *ts_params = &testsuite_params;
 863         uint8_t dev_id = ts_params->valid_devs[0];
 864         struct rte_cryptodev_info dev_info;
 865         const enum rte_crypto_cipher_algorithm ciphers[] = {
 866                 RTE_CRYPTO_CIPHER_NULL,
 867                 RTE_CRYPTO_CIPHER_AES_CTR,
 868                 RTE_CRYPTO_CIPHER_ZUC_EEA3,
 869                 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
 870         };
 871         const enum rte_crypto_auth_algorithm auths[] = {
 872                 RTE_CRYPTO_AUTH_NULL,
 873                 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
 874                 RTE_CRYPTO_AUTH_AES_CMAC,
 875                 RTE_CRYPTO_AUTH_ZUC_EIA3
 876         };
 877
 878         rte_cryptodev_info_get(dev_id, &dev_info);
 879
 880         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 881                         !(dev_info.feature_flags &
 882                         RTE_CRYPTODEV_FF_SECURITY)) {
 883                 RTE_LOG(INFO, USER1, "Feature flag requirements for PDCP Proto "
 884                                 "testsuite not met\n");
 885                 return TEST_SKIPPED;
 886         }
 887
 888         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
 889                         && check_auth_capabilities_supported(auths,
 890                         RTE_DIM(auths)) != 0) {
 891                 RTE_LOG(INFO, USER1, "Capability requirements for PDCP Proto "
 892                                 "testsuite not met\n");
 893                 return TEST_SKIPPED;
 894         }
 895
 896         return 0;
 897 }
 898
 899 static int
 900 docsis_proto_testsuite_setup(void)
 901 {
 902         struct crypto_testsuite_params *ts_params = &testsuite_params;
 903         uint8_t dev_id = ts_params->valid_devs[0];
 904         struct rte_cryptodev_info dev_info;
 905         const enum rte_crypto_cipher_algorithm ciphers[] = {
 906                 RTE_CRYPTO_CIPHER_AES_DOCSISBPI
 907         };
 908
 909         rte_cryptodev_info_get(dev_id, &dev_info);
 910
 911         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 912                         !(dev_info.feature_flags &
 913                         RTE_CRYPTODEV_FF_SECURITY)) {
 914                 RTE_LOG(INFO, USER1, "Feature flag requirements for DOCSIS "
 915                                 "Proto testsuite not met\n");
 916                 return TEST_SKIPPED;
 917         }
 918
 919         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0) {
 920                 RTE_LOG(INFO, USER1, "Capability requirements for DOCSIS Proto "
 921                                 "testsuite not met\n");
 922                 return TEST_SKIPPED;
 923         }
 924
 925         return 0;
 926 }
 927 #endif
 928
 929 static int
 930 aes_ccm_auth_testsuite_setup(void)
 931 {
 932         struct crypto_testsuite_params *ts_params = &testsuite_params;
 933         uint8_t dev_id = ts_params->valid_devs[0];
 934         struct rte_cryptodev_info dev_info;
 935         const enum rte_crypto_aead_algorithm aeads[] = {
 936                 RTE_CRYPTO_AEAD_AES_CCM
 937         };
 938
 939         rte_cryptodev_info_get(dev_id, &dev_info);
 940
 941         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 942                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
 943                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
 944                 RTE_LOG(INFO, USER1, "Feature flag requirements for AES CCM "
 945                                 "testsuite not met\n");
 946                 return TEST_SKIPPED;
 947         }
 948
 949         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
 950                 RTE_LOG(INFO, USER1, "Capability requirements for AES CCM "
 951                                 "testsuite not met\n");
 952                 return TEST_SKIPPED;
 953         }
 954
 955         return 0;
 956 }
 957
 958 static int
 959 aes_gcm_auth_testsuite_setup(void)
 960 {
 961         struct crypto_testsuite_params *ts_params = &testsuite_params;
 962         uint8_t dev_id = ts_params->valid_devs[0];
 963         struct rte_cryptodev_info dev_info;
 964         const enum rte_crypto_aead_algorithm aeads[] = {
 965                 RTE_CRYPTO_AEAD_AES_GCM
 966         };
 967
 968         rte_cryptodev_info_get(dev_id, &dev_info);
 969
 970         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
 971                 RTE_LOG(INFO, USER1, "Feature flag requirements for AES GCM "
 972                                 "testsuite not met\n");
 973                 return TEST_SKIPPED;
 974         }
 975
 976         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
 977                 RTE_LOG(INFO, USER1, "Capability requirements for AES GCM "
 978                                 "testsuite not met\n");
 979                 return TEST_SKIPPED;
 980         }
 981
 982         return 0;
 983 }
 984
 985 static int
 986 aes_gmac_auth_testsuite_setup(void)
 987 {
 988         struct crypto_testsuite_params *ts_params = &testsuite_params;
 989         uint8_t dev_id = ts_params->valid_devs[0];
 990         struct rte_cryptodev_info dev_info;
 991         const enum rte_crypto_auth_algorithm auths[] = {
 992                 RTE_CRYPTO_AUTH_AES_GMAC
 993         };
 994
 995         rte_cryptodev_info_get(dev_id, &dev_info);
 996
 997         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 998                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
 999                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1000                 RTE_LOG(INFO, USER1, "Feature flag requirements for AES GMAC "
1001                                 "testsuite not met\n");
1002                 return TEST_SKIPPED;
1003         }
1004
1005         if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
1006                 RTE_LOG(INFO, USER1, "Capability requirements for AES GMAC "
1007                                 "testsuite not met\n");
1008                 return TEST_SKIPPED;
1009         }
1010
1011         return 0;
1012 }
1013
1014 static int
1015 chacha20_poly1305_testsuite_setup(void)
1016 {
1017         struct crypto_testsuite_params *ts_params = &testsuite_params;
1018         uint8_t dev_id = ts_params->valid_devs[0];
1019         struct rte_cryptodev_info dev_info;
1020         const enum rte_crypto_aead_algorithm aeads[] = {
1021                 RTE_CRYPTO_AEAD_CHACHA20_POLY1305
1022         };
1023
1024         rte_cryptodev_info_get(dev_id, &dev_info);
1025
1026         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1027                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1028                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1029                 RTE_LOG(INFO, USER1, "Feature flag requirements for "
1030                                 "Chacha20-Poly1305 testsuite not met\n");
1031                 return TEST_SKIPPED;
1032         }
1033
1034         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
1035                 RTE_LOG(INFO, USER1, "Capability requirements for "
1036                                 "Chacha20-Poly1305 testsuite not met\n");
1037                 return TEST_SKIPPED;
1038         }
1039
1040         return 0;
1041 }
1042
1043 static int
1044 snow3g_testsuite_setup(void)
1045 {
1046         struct crypto_testsuite_params *ts_params = &testsuite_params;
1047         uint8_t dev_id = ts_params->valid_devs[0];
1048         struct rte_cryptodev_info dev_info;
1049         const enum rte_crypto_cipher_algorithm ciphers[] = {
1050                 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
1051
1052         };
1053         const enum rte_crypto_auth_algorithm auths[] = {
1054                 RTE_CRYPTO_AUTH_SNOW3G_UIA2
1055         };
1056
1057         rte_cryptodev_info_get(dev_id, &dev_info);
1058
1059         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1060                 RTE_LOG(INFO, USER1, "Feature flag requirements for Snow3G "
1061                                 "testsuite not met\n");
1062                 return TEST_SKIPPED;
1063         }
1064
1065         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1066                         && check_auth_capabilities_supported(auths,
1067                         RTE_DIM(auths)) != 0) {
1068                 RTE_LOG(INFO, USER1, "Capability requirements for Snow3G "
1069                                 "testsuite not met\n");
1070                 return TEST_SKIPPED;
1071         }
1072
1073         return 0;
1074 }
1075
1076 static int
1077 zuc_testsuite_setup(void)
1078 {
1079         struct crypto_testsuite_params *ts_params = &testsuite_params;
1080         uint8_t dev_id = ts_params->valid_devs[0];
1081         struct rte_cryptodev_info dev_info;
1082         const enum rte_crypto_cipher_algorithm ciphers[] = {
1083                 RTE_CRYPTO_CIPHER_ZUC_EEA3
1084         };
1085         const enum rte_crypto_auth_algorithm auths[] = {
1086                 RTE_CRYPTO_AUTH_ZUC_EIA3
1087         };
1088
1089         rte_cryptodev_info_get(dev_id, &dev_info);
1090
1091         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1092                 RTE_LOG(INFO, USER1, "Feature flag requirements for ZUC "
1093                                 "testsuite not met\n");
1094                 return TEST_SKIPPED;
1095         }
1096
1097         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1098                         && check_auth_capabilities_supported(auths,
1099                         RTE_DIM(auths)) != 0) {
1100                 RTE_LOG(INFO, USER1, "Capability requirements for ZUC "
1101                                 "testsuite not met\n");
1102                 return TEST_SKIPPED;
1103         }
1104
1105         return 0;
1106 }
1107
1108 static int
1109 hmac_md5_auth_testsuite_setup(void)
1110 {
1111         struct crypto_testsuite_params *ts_params = &testsuite_params;
1112         uint8_t dev_id = ts_params->valid_devs[0];
1113         struct rte_cryptodev_info dev_info;
1114         const enum rte_crypto_auth_algorithm auths[] = {
1115                 RTE_CRYPTO_AUTH_MD5_HMAC
1116         };
1117
1118         rte_cryptodev_info_get(dev_id, &dev_info);
1119
1120         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1121                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1122                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1123                 RTE_LOG(INFO, USER1, "Feature flag requirements for HMAC MD5 "
1124                                 "Auth testsuite not met\n");
1125                 return TEST_SKIPPED;
1126         }
1127
1128         if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
1129                 RTE_LOG(INFO, USER1, "Capability requirements for HMAC MD5 "
1130                                 "testsuite not met\n");
1131                 return TEST_SKIPPED;
1132         }
1133
1134         return 0;
1135 }
1136
1137 static int
1138 kasumi_testsuite_setup(void)
1139 {
1140         struct crypto_testsuite_params *ts_params = &testsuite_params;
1141         uint8_t dev_id = ts_params->valid_devs[0];
1142         struct rte_cryptodev_info dev_info;
1143         const enum rte_crypto_cipher_algorithm ciphers[] = {
1144                 RTE_CRYPTO_CIPHER_KASUMI_F8
1145         };
1146         const enum rte_crypto_auth_algorithm auths[] = {
1147                 RTE_CRYPTO_AUTH_KASUMI_F9
1148         };
1149
1150         rte_cryptodev_info_get(dev_id, &dev_info);
1151
1152         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1153                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1154                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1155                 RTE_LOG(INFO, USER1, "Feature flag requirements for Kasumi "
1156                                 "testsuite not met\n");
1157                 return TEST_SKIPPED;
1158         }
1159
1160         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1161                         && check_auth_capabilities_supported(auths,
1162                         RTE_DIM(auths)) != 0) {
1163                 RTE_LOG(INFO, USER1, "Capability requirements for Kasumi "
1164                                 "testsuite not met\n");
1165                 return TEST_SKIPPED;
1166         }
1167
1168         return 0;
1169 }
1170
1171 static int
1172 negative_aes_gcm_testsuite_setup(void)
1173 {
1174         struct crypto_testsuite_params *ts_params = &testsuite_params;
1175         uint8_t dev_id = ts_params->valid_devs[0];
1176         struct rte_cryptodev_info dev_info;
1177         const enum rte_crypto_aead_algorithm aeads[] = {
1178                 RTE_CRYPTO_AEAD_AES_GCM
1179         };
1180
1181         rte_cryptodev_info_get(dev_id, &dev_info);
1182
1183         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1184                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1185                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1186                 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1187                                 "AES GCM testsuite not met\n");
1188                 return TEST_SKIPPED;
1189         }
1190
1191         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
1192                 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1193                                 "AES GCM testsuite not met\n");
1194                 return TEST_SKIPPED;
1195         }
1196
1197         return 0;
1198 }
1199
1200 static int
1201 negative_aes_gmac_testsuite_setup(void)
1202 {
1203         struct crypto_testsuite_params *ts_params = &testsuite_params;
1204         uint8_t dev_id = ts_params->valid_devs[0];
1205         struct rte_cryptodev_info dev_info;
1206         const enum rte_crypto_auth_algorithm auths[] = {
1207                 RTE_CRYPTO_AUTH_AES_GMAC
1208         };
1209
1210         rte_cryptodev_info_get(dev_id, &dev_info);
1211
1212         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1213                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1214                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1215                 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1216                                 "AES GMAC testsuite not met\n");
1217                 return TEST_SKIPPED;
1218         }
1219
1220         if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
1221                 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1222                                 "AES GMAC testsuite not met\n");
1223                 return TEST_SKIPPED;
1224         }
1225
1226         return 0;
1227 }
1228
1229 static int
1230 mixed_cipher_hash_testsuite_setup(void)
1231 {
1232         struct crypto_testsuite_params *ts_params = &testsuite_params;
1233         uint8_t dev_id = ts_params->valid_devs[0];
1234         struct rte_cryptodev_info dev_info;
1235         uint64_t feat_flags;
1236         const enum rte_crypto_cipher_algorithm ciphers[] = {
1237                 RTE_CRYPTO_CIPHER_NULL,
1238                 RTE_CRYPTO_CIPHER_AES_CTR,
1239                 RTE_CRYPTO_CIPHER_ZUC_EEA3,
1240                 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
1241         };
1242         const enum rte_crypto_auth_algorithm auths[] = {
1243                 RTE_CRYPTO_AUTH_NULL,
1244                 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
1245                 RTE_CRYPTO_AUTH_AES_CMAC,
1246                 RTE_CRYPTO_AUTH_ZUC_EIA3
1247         };
1248
1249         rte_cryptodev_info_get(dev_id, &dev_info);
1250         feat_flags = dev_info.feature_flags;
1251
1252         if (!(feat_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1253                         (global_api_test_type == CRYPTODEV_RAW_API_TEST)) {
1254                 RTE_LOG(INFO, USER1, "Feature flag requirements for Mixed "
1255                                 "Cipher Hash testsuite not met\n");
1256                 return TEST_SKIPPED;
1257         }
1258
1259         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1260                         && check_auth_capabilities_supported(auths,
1261                         RTE_DIM(auths)) != 0) {
1262                 RTE_LOG(INFO, USER1, "Capability requirements for Mixed "
1263                                 "Cipher Hash testsuite not met\n");
1264                 return TEST_SKIPPED;
1265         }
1266
1267         return 0;
1268 }
1269
1270 static int
1271 esn_testsuite_setup(void)
1272 {
1273         struct crypto_testsuite_params *ts_params = &testsuite_params;
1274         uint8_t dev_id = ts_params->valid_devs[0];
1275         struct rte_cryptodev_info dev_info;
1276         const enum rte_crypto_cipher_algorithm ciphers[] = {
1277                 RTE_CRYPTO_CIPHER_AES_CBC
1278         };
1279         const enum rte_crypto_auth_algorithm auths[] = {
1280                 RTE_CRYPTO_AUTH_SHA1_HMAC
1281         };
1282
1283         rte_cryptodev_info_get(dev_id, &dev_info);
1284
1285         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1286                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1287                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1288                 RTE_LOG(INFO, USER1, "Feature flag requirements for ESN "
1289                                 "testsuite not met\n");
1290                 return TEST_SKIPPED;
1291         }
1292
1293         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1294                         && check_auth_capabilities_supported(auths,
1295                         RTE_DIM(auths)) != 0) {
1296                 RTE_LOG(INFO, USER1, "Capability requirements for ESN "
1297                                 "testsuite not met\n");
1298                 return TEST_SKIPPED;
1299         }
1300
1301         return 0;
1302 }
1303
1304 static int
1305 multi_session_testsuite_setup(void)
1306 {
1307         struct crypto_testsuite_params *ts_params = &testsuite_params;
1308         uint8_t dev_id = ts_params->valid_devs[0];
1309         struct rte_cryptodev_info dev_info;
1310         const enum rte_crypto_cipher_algorithm ciphers[] = {
1311                 RTE_CRYPTO_CIPHER_AES_CBC
1312         };
1313         const enum rte_crypto_auth_algorithm auths[] = {
1314                 RTE_CRYPTO_AUTH_SHA512_HMAC
1315         };
1316
1317         rte_cryptodev_info_get(dev_id, &dev_info);
1318
1319         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1320                 RTE_LOG(INFO, USER1, "Feature flag requirements for Multi "
1321                                 "Session testsuite not met\n");
1322                 return TEST_SKIPPED;
1323         }
1324
1325         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1326                         && check_auth_capabilities_supported(auths,
1327                         RTE_DIM(auths)) != 0) {
1328                 RTE_LOG(INFO, USER1, "Capability requirements for Multi "
1329                                 "Session testsuite not met\n");
1330                 return TEST_SKIPPED;
1331         }
1332
1333         return 0;
1334 }
1335
1336 static int
1337 negative_hmac_sha1_testsuite_setup(void)
1338 {
1339         struct crypto_testsuite_params *ts_params = &testsuite_params;
1340         uint8_t dev_id = ts_params->valid_devs[0];
1341         struct rte_cryptodev_info dev_info;
1342         const enum rte_crypto_cipher_algorithm ciphers[] = {
1343                 RTE_CRYPTO_CIPHER_AES_CBC
1344         };
1345         const enum rte_crypto_auth_algorithm auths[] = {
1346                 RTE_CRYPTO_AUTH_SHA1_HMAC
1347         };
1348
1349         rte_cryptodev_info_get(dev_id, &dev_info);
1350
1351         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1352                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1353                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1354                 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1355                                 "HMAC SHA1 testsuite not met\n");
1356                 return TEST_SKIPPED;
1357         }
1358
1359         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1360                         && check_auth_capabilities_supported(auths,
1361                         RTE_DIM(auths)) != 0) {
1362                 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1363                                 "HMAC SHA1 testsuite not met\n");
1364                 return TEST_SKIPPED;
1365         }
1366
1367         return 0;
1368 }
1369
1370 static int
1371 dev_configure_and_start(uint64_t ff_disable)
1372 {
1373         struct crypto_testsuite_params *ts_params = &testsuite_params;
1374         struct crypto_unittest_params *ut_params = &unittest_params;
1375
1376         uint16_t qp_id;
1377
1378         /* Clear unit test parameters before running test */
1379         memset(ut_params, 0, sizeof(*ut_params));
1380
1381         /* Reconfigure device to default parameters */
1382         ts_params->conf.socket_id = SOCKET_ID_ANY;
1383         ts_params->conf.ff_disable = ff_disable;
1384         ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
1385         ts_params->qp_conf.mp_session = ts_params->session_mpool;
1386         ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
1387
1388         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1389                         &ts_params->conf),
1390                         "Failed to configure cryptodev %u",
1391                         ts_params->valid_devs[0]);
1392
1393         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
1394                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1395                         ts_params->valid_devs[0], qp_id,
1396                         &ts_params->qp_conf,
1397                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1398                         "Failed to setup queue pair %u on cryptodev %u",
1399                         qp_id, ts_params->valid_devs[0]);
1400         }
1401
1402
1403         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
1404
1405         /* Start the device */
1406         TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
1407                         "Failed to start cryptodev %u",
1408                         ts_params->valid_devs[0]);
1409
1410         return TEST_SUCCESS;
1411 }
1412
1413 int
1414 ut_setup(void)
1415 {
1416         /* Configure and start the device with security feature disabled */
1417         return dev_configure_and_start(RTE_CRYPTODEV_FF_SECURITY);
1418 }
1419
1420 static int
1421 ut_setup_security(void)
1422 {
1423         /* Configure and start the device with no features disabled */
1424         return dev_configure_and_start(0);
1425 }
1426
1427 void
1428 ut_teardown(void)
1429 {
1430         struct crypto_testsuite_params *ts_params = &testsuite_params;
1431         struct crypto_unittest_params *ut_params = &unittest_params;
1432
1433         /* free crypto session structure */
1434 #ifdef RTE_LIB_SECURITY
1435         if (ut_params->type == RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL) {
1436                 if (ut_params->sec_session) {
1437                         rte_security_session_destroy(rte_cryptodev_get_sec_ctx
1438                                                 (ts_params->valid_devs[0]),
1439                                                 ut_params->sec_session);
1440                         ut_params->sec_session = NULL;
1441                 }
1442         } else
1443 #endif
1444         {
1445                 if (ut_params->sess) {
1446                         rte_cryptodev_sym_session_clear(
1447                                         ts_params->valid_devs[0],
1448                                         ut_params->sess);
1449                         rte_cryptodev_sym_session_free(ut_params->sess);
1450                         ut_params->sess = NULL;
1451                 }
1452         }
1453
1454         /* free crypto operation structure */
1455         if (ut_params->op)
1456                 rte_crypto_op_free(ut_params->op);
1457
1458         /*
1459          * free mbuf - both obuf and ibuf are usually the same,
1460          * so check if they point at the same address is necessary,
1461          * to avoid freeing the mbuf twice.
1462          */
1463         if (ut_params->obuf) {
1464                 rte_pktmbuf_free(ut_params->obuf);
1465                 if (ut_params->ibuf == ut_params->obuf)
1466                         ut_params->ibuf = 0;
1467                 ut_params->obuf = 0;
1468         }
1469         if (ut_params->ibuf) {
1470                 rte_pktmbuf_free(ut_params->ibuf);
1471                 ut_params->ibuf = 0;
1472         }
1473
1474         if (ts_params->mbuf_pool != NULL)
1475                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
1476                         rte_mempool_avail_count(ts_params->mbuf_pool));
1477
1478         /* Stop the device */
1479         rte_cryptodev_stop(ts_params->valid_devs[0]);
1480 }
1481
1482 static int
1483 test_device_configure_invalid_dev_id(void)
1484 {
1485         struct crypto_testsuite_params *ts_params = &testsuite_params;
1486         uint16_t dev_id, num_devs = 0;
1487
1488         TEST_ASSERT((num_devs = rte_cryptodev_count()) >= 1,
1489                         "Need at least %d devices for test", 1);
1490
1491         /* valid dev_id values */
1492         dev_id = ts_params->valid_devs[0];
1493
1494         /* Stop the device in case it's started so it can be configured */
1495         rte_cryptodev_stop(dev_id);
1496
1497         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf),
1498                         "Failed test for rte_cryptodev_configure: "
1499                         "invalid dev_num %u", dev_id);
1500
1501         /* invalid dev_id values */
1502         dev_id = num_devs;
1503
1504         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
1505                         "Failed test for rte_cryptodev_configure: "
1506                         "invalid dev_num %u", dev_id);
1507
1508         dev_id = 0xff;
1509
1510         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
1511                         "Failed test for rte_cryptodev_configure:"
1512                         "invalid dev_num %u", dev_id);
1513
1514         return TEST_SUCCESS;
1515 }
1516
1517 static int
1518 test_device_configure_invalid_queue_pair_ids(void)
1519 {
1520         struct crypto_testsuite_params *ts_params = &testsuite_params;
1521         uint16_t orig_nb_qps = ts_params->conf.nb_queue_pairs;
1522
1523         /* Stop the device in case it's started so it can be configured */
1524         rte_cryptodev_stop(ts_params->valid_devs[0]);
1525
1526         /* valid - max value queue pairs */
1527         ts_params->conf.nb_queue_pairs = orig_nb_qps;
1528
1529         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1530                         &ts_params->conf),
1531                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
1532                         ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
1533
1534         /* valid - one queue pairs */
1535         ts_params->conf.nb_queue_pairs = 1;
1536
1537         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1538                         &ts_params->conf),
1539                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
1540                         ts_params->valid_devs[0],
1541                         ts_params->conf.nb_queue_pairs);
1542
1543
1544         /* invalid - zero queue pairs */
1545         ts_params->conf.nb_queue_pairs = 0;
1546
1547         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1548                         &ts_params->conf),
1549                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1550                         " invalid qps: %u",
1551                         ts_params->valid_devs[0],
1552                         ts_params->conf.nb_queue_pairs);
1553
1554
1555         /* invalid - max value supported by field queue pairs */
1556         ts_params->conf.nb_queue_pairs = UINT16_MAX;
1557
1558         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1559                         &ts_params->conf),
1560                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1561                         " invalid qps: %u",
1562                         ts_params->valid_devs[0],
1563                         ts_params->conf.nb_queue_pairs);
1564
1565
1566         /* invalid - max value + 1 queue pairs */
1567         ts_params->conf.nb_queue_pairs = orig_nb_qps + 1;
1568
1569         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1570                         &ts_params->conf),
1571                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1572                         " invalid qps: %u",
1573                         ts_params->valid_devs[0],
1574                         ts_params->conf.nb_queue_pairs);
1575
1576         /* revert to original testsuite value */
1577         ts_params->conf.nb_queue_pairs = orig_nb_qps;
1578
1579         return TEST_SUCCESS;
1580 }
1581
1582 static int
1583 test_queue_pair_descriptor_setup(void)
1584 {
1585         struct crypto_testsuite_params *ts_params = &testsuite_params;
1586         struct rte_cryptodev_qp_conf qp_conf = {
1587                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
1588         };
1589         uint16_t qp_id;
1590
1591         /* Stop the device in case it's started so it can be configured */
1592         rte_cryptodev_stop(ts_params->valid_devs[0]);
1593
1594         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1595                         &ts_params->conf),
1596                         "Failed to configure cryptodev %u",
1597                         ts_params->valid_devs[0]);
1598
1599         /*
1600          * Test various ring sizes on this device. memzones can't be
1601          * freed so are re-used if ring is released and re-created.
1602          */
1603         qp_conf.nb_descriptors = MIN_NUM_OPS_INFLIGHT; /* min size*/
1604         qp_conf.mp_session = ts_params->session_mpool;
1605         qp_conf.mp_session_private = ts_params->session_priv_mpool;
1606
1607         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1608                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1609                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1610                                 rte_cryptodev_socket_id(
1611                                                 ts_params->valid_devs[0])),
1612                                 "Failed test for "
1613                                 "rte_cryptodev_queue_pair_setup: num_inflights "
1614                                 "%u on qp %u on cryptodev %u",
1615                                 qp_conf.nb_descriptors, qp_id,
1616                                 ts_params->valid_devs[0]);
1617         }
1618
1619         qp_conf.nb_descriptors = (uint32_t)(MAX_NUM_OPS_INFLIGHT / 2);
1620
1621         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1622                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1623                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1624                                 rte_cryptodev_socket_id(
1625                                                 ts_params->valid_devs[0])),
1626                                 "Failed test for"
1627                                 " rte_cryptodev_queue_pair_setup: num_inflights"
1628                                 " %u on qp %u on cryptodev %u",
1629                                 qp_conf.nb_descriptors, qp_id,
1630                                 ts_params->valid_devs[0]);
1631         }
1632
1633         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; /* valid */
1634
1635         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1636                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1637                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1638                                 rte_cryptodev_socket_id(
1639                                                 ts_params->valid_devs[0])),
1640                                 "Failed test for "
1641                                 "rte_cryptodev_queue_pair_setup: num_inflights"
1642                                 " %u on qp %u on cryptodev %u",
1643                                 qp_conf.nb_descriptors, qp_id,
1644                                 ts_params->valid_devs[0]);
1645         }
1646
1647         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
1648
1649         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1650                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1651                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1652                                 rte_cryptodev_socket_id(
1653                                                 ts_params->valid_devs[0])),
1654                                 "Failed test for"
1655                                 " rte_cryptodev_queue_pair_setup:"
1656                                 "num_inflights %u on qp %u on cryptodev %u",
1657                                 qp_conf.nb_descriptors, qp_id,
1658                                 ts_params->valid_devs[0]);
1659         }
1660
1661         /* test invalid queue pair id */
1662         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;      /*valid */
1663
1664         qp_id = ts_params->conf.nb_queue_pairs;         /*invalid */
1665
1666         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
1667                         ts_params->valid_devs[0],
1668                         qp_id, &qp_conf,
1669                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1670                         "Failed test for rte_cryptodev_queue_pair_setup:"
1671                         "invalid qp %u on cryptodev %u",
1672                         qp_id, ts_params->valid_devs[0]);
1673
1674         qp_id = 0xffff; /*invalid*/
1675
1676         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
1677                         ts_params->valid_devs[0],
1678                         qp_id, &qp_conf,
1679                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1680                         "Failed test for rte_cryptodev_queue_pair_setup:"
1681                         "invalid qp %u on cryptodev %u",
1682                         qp_id, ts_params->valid_devs[0]);
1683
1684         return TEST_SUCCESS;
1685 }
1686
1687 /* ***** Plaintext data for tests ***** */
1688
1689 const char catch_22_quote_1[] =
1690                 "There was only one catch and that was Catch-22, which "
1691                 "specified that a concern for one's safety in the face of "
1692                 "dangers that were real and immediate was the process of a "
1693                 "rational mind. Orr was crazy and could be grounded. All he "
1694                 "had to do was ask; and as soon as he did, he would no longer "
1695                 "be crazy and would have to fly more missions. Orr would be "
1696                 "crazy to fly more missions and sane if he didn't, but if he "
1697                 "was sane he had to fly them. If he flew them he was crazy "
1698                 "and didn't have to; but if he didn't want to he was sane and "
1699                 "had to. Yossarian was moved very deeply by the absolute "
1700                 "simplicity of this clause of Catch-22 and let out a "
1701                 "respectful whistle. \"That's some catch, that Catch-22\", he "
1702                 "observed. \"It's the best there is,\" Doc Daneeka agreed.";
1703
1704 const char catch_22_quote[] =
1705                 "What a lousy earth! He wondered how many people were "
1706                 "destitute that same night even in his own prosperous country, "
1707                 "how many homes were shanties, how many husbands were drunk "
1708                 "and wives socked, and how many children were bullied, abused, "
1709                 "or abandoned. How many families hungered for food they could "
1710                 "not afford to buy? How many hearts were broken? How many "
1711                 "suicides would take place that same night, how many people "
1712                 "would go insane? How many cockroaches and landlords would "
1713                 "triumph? How many winners were losers, successes failures, "
1714                 "and rich men poor men? How many wise guys were stupid? How "
1715                 "many happy endings were unhappy endings? How many honest men "
1716                 "were liars, brave men cowards, loyal men traitors, how many "
1717                 "sainted men were corrupt, how many people in positions of "
1718                 "trust had sold their souls to bodyguards, how many had never "
1719                 "had souls? How many straight-and-narrow paths were crooked "
1720                 "paths? How many best families were worst families and how "
1721                 "many good people were bad people? When you added them all up "
1722                 "and then subtracted, you might be left with only the children, "
1723                 "and perhaps with Albert Einstein and an old violinist or "
1724                 "sculptor somewhere.";
1725
1726 #define QUOTE_480_BYTES         (480)
1727 #define QUOTE_512_BYTES         (512)
1728 #define QUOTE_768_BYTES         (768)
1729 #define QUOTE_1024_BYTES        (1024)
1730
1731
1732
1733 /* ***** SHA1 Hash Tests ***** */
1734
1735 #define HMAC_KEY_LENGTH_SHA1    (DIGEST_BYTE_LENGTH_SHA1)
1736
1737 static uint8_t hmac_sha1_key[] = {
1738         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
1739         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
1740         0xDE, 0xF4, 0xDE, 0xAD };
1741
1742 /* ***** SHA224 Hash Tests ***** */
1743
1744 #define HMAC_KEY_LENGTH_SHA224  (DIGEST_BYTE_LENGTH_SHA224)
1745
1746
1747 /* ***** AES-CBC Cipher Tests ***** */
1748
1749 #define CIPHER_KEY_LENGTH_AES_CBC       (16)
1750 #define CIPHER_IV_LENGTH_AES_CBC        (CIPHER_KEY_LENGTH_AES_CBC)
1751
1752 static uint8_t aes_cbc_key[] = {
1753         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
1754         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A };
1755
1756 static uint8_t aes_cbc_iv[] = {
1757         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1758         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
1759
1760
1761 /* ***** AES-CBC / HMAC-SHA1 Hash Tests ***** */
1762
1763 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_ciphertext[] = {
1764         0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31,
1765         0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76,
1766         0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E,
1767         0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A,
1768         0x3F, 0x6B, 0x5D, 0xDF, 0x52, 0x85, 0x5F, 0x8E,
1769         0x42, 0x3C, 0xFB, 0xE9, 0x1A, 0x24, 0xD6, 0x08,
1770         0xDD, 0xFD, 0x16, 0xFB, 0xE9, 0x55, 0xEF, 0xF0,
1771         0xA0, 0x8D, 0x13, 0xAB, 0x81, 0xC6, 0x90, 0x01,
1772         0xB5, 0x18, 0x84, 0xB3, 0xF6, 0xE6, 0x11, 0x57,
1773         0xD6, 0x71, 0xC6, 0x3C, 0x3F, 0x2F, 0x33, 0xEE,
1774         0x24, 0x42, 0x6E, 0xAC, 0x0B, 0xCA, 0xEC, 0xF9,
1775         0x84, 0xF8, 0x22, 0xAA, 0x60, 0xF0, 0x32, 0xA9,
1776         0x75, 0x75, 0x3B, 0xCB, 0x70, 0x21, 0x0A, 0x8D,
1777         0x0F, 0xE0, 0xC4, 0x78, 0x2B, 0xF8, 0x97, 0xE3,
1778         0xE4, 0x26, 0x4B, 0x29, 0xDA, 0x88, 0xCD, 0x46,
1779         0xEC, 0xAA, 0xF9, 0x7F, 0xF1, 0x15, 0xEA, 0xC3,
1780         0x87, 0xE6, 0x31, 0xF2, 0xCF, 0xDE, 0x4D, 0x80,
1781         0x70, 0x91, 0x7E, 0x0C, 0xF7, 0x26, 0x3A, 0x92,
1782         0x4F, 0x18, 0x83, 0xC0, 0x8F, 0x59, 0x01, 0xA5,
1783         0x88, 0xD1, 0xDB, 0x26, 0x71, 0x27, 0x16, 0xF5,
1784         0xEE, 0x10, 0x82, 0xAC, 0x68, 0x26, 0x9B, 0xE2,
1785         0x6D, 0xD8, 0x9A, 0x80, 0xDF, 0x04, 0x31, 0xD5,
1786         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1787         0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
1788         0x73, 0x02, 0x42, 0xC9, 0x23, 0x18, 0x8E, 0xB4,
1789         0x6F, 0xB4, 0xA3, 0x54, 0x6E, 0x88, 0x3B, 0x62,
1790         0x7C, 0x02, 0x8D, 0x4C, 0x9F, 0xC8, 0x45, 0xF4,
1791         0xC9, 0xDE, 0x4F, 0xEB, 0x22, 0x83, 0x1B, 0xE4,
1792         0x49, 0x37, 0xE4, 0xAD, 0xE7, 0xCD, 0x21, 0x54,
1793         0xBC, 0x1C, 0xC2, 0x04, 0x97, 0xB4, 0x10, 0x61,
1794         0xF0, 0xE4, 0xEF, 0x27, 0x63, 0x3A, 0xDA, 0x91,
1795         0x41, 0x25, 0x62, 0x1C, 0x5C, 0xB6, 0x38, 0x4A,
1796         0x88, 0x71, 0x59, 0x5A, 0x8D, 0xA0, 0x09, 0xAF,
1797         0x72, 0x94, 0xD7, 0x79, 0x5C, 0x60, 0x7C, 0x8F,
1798         0x4C, 0xF5, 0xD9, 0xA1, 0x39, 0x6D, 0x81, 0x28,
1799         0xEF, 0x13, 0x28, 0xDF, 0xF5, 0x3E, 0xF7, 0x8E,
1800         0x09, 0x9C, 0x78, 0x18, 0x79, 0xB8, 0x68, 0xD7,
1801         0xA8, 0x29, 0x62, 0xAD, 0xDE, 0xE1, 0x61, 0x76,
1802         0x1B, 0x05, 0x16, 0xCD, 0xBF, 0x02, 0x8E, 0xA6,
1803         0x43, 0x6E, 0x92, 0x55, 0x4F, 0x60, 0x9C, 0x03,
1804         0xB8, 0x4F, 0xA3, 0x02, 0xAC, 0xA8, 0xA7, 0x0C,
1805         0x1E, 0xB5, 0x6B, 0xF8, 0xC8, 0x4D, 0xDE, 0xD2,
1806         0xB0, 0x29, 0x6E, 0x40, 0xE6, 0xD6, 0xC9, 0xE6,
1807         0xB9, 0x0F, 0xB6, 0x63, 0xF5, 0xAA, 0x2B, 0x96,
1808         0xA7, 0x16, 0xAC, 0x4E, 0x0A, 0x33, 0x1C, 0xA6,
1809         0xE6, 0xBD, 0x8A, 0xCF, 0x40, 0xA9, 0xB2, 0xFA,
1810         0x63, 0x27, 0xFD, 0x9B, 0xD9, 0xFC, 0xD5, 0x87,
1811         0x8D, 0x4C, 0xB6, 0xA4, 0xCB, 0xE7, 0x74, 0x55,
1812         0xF4, 0xFB, 0x41, 0x25, 0xB5, 0x4B, 0x0A, 0x1B,
1813         0xB1, 0xD6, 0xB7, 0xD9, 0x47, 0x2A, 0xC3, 0x98,
1814         0x6A, 0xC4, 0x03, 0x73, 0x1F, 0x93, 0x6E, 0x53,
1815         0x19, 0x25, 0x64, 0x15, 0x83, 0xF9, 0x73, 0x2A,
1816         0x74, 0xB4, 0x93, 0x69, 0xC4, 0x72, 0xFC, 0x26,
1817         0xA2, 0x9F, 0x43, 0x45, 0xDD, 0xB9, 0xEF, 0x36,
1818         0xC8, 0x3A, 0xCD, 0x99, 0x9B, 0x54, 0x1A, 0x36,
1819         0xC1, 0x59, 0xF8, 0x98, 0xA8, 0xCC, 0x28, 0x0D,
1820         0x73, 0x4C, 0xEE, 0x98, 0xCB, 0x7C, 0x58, 0x7E,
1821         0x20, 0x75, 0x1E, 0xB7, 0xC9, 0xF8, 0xF2, 0x0E,
1822         0x63, 0x9E, 0x05, 0x78, 0x1A, 0xB6, 0xA8, 0x7A,
1823         0xF9, 0x98, 0x6A, 0xA6, 0x46, 0x84, 0x2E, 0xF6,
1824         0x4B, 0xDC, 0x9B, 0x8F, 0x9B, 0x8F, 0xEE, 0xB4,
1825         0xAA, 0x3F, 0xEE, 0xC0, 0x37, 0x27, 0x76, 0xC7,
1826         0x95, 0xBB, 0x26, 0x74, 0x69, 0x12, 0x7F, 0xF1,
1827         0xBB, 0xFF, 0xAE, 0xB5, 0x99, 0x6E, 0xCB, 0x0C
1828 };
1829
1830 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest[] = {
1831         0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60,
1832         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1833         0x18, 0x8c, 0x1d, 0x32
1834 };
1835
1836
1837 /* Multisession Vector context Test */
1838 /*Begin Session 0 */
1839 static uint8_t ms_aes_cbc_key0[] = {
1840         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1841         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1842 };
1843
1844 static uint8_t ms_aes_cbc_iv0[] = {
1845         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1846         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1847 };
1848
1849 static const uint8_t ms_aes_cbc_cipher0[] = {
1850                 0x3C, 0xE4, 0xEE, 0x42, 0xB6, 0x9B, 0xC3, 0x38,
1851                 0x5F, 0xAD, 0x54, 0xDC, 0xA8, 0x32, 0x81, 0xDC,
1852                 0x7A, 0x6F, 0x85, 0x58, 0x07, 0x35, 0xED, 0xEB,
1853                 0xAD, 0x79, 0x79, 0x96, 0xD3, 0x0E, 0xA6, 0xD9,
1854                 0xAA, 0x86, 0xA4, 0x8F, 0xB5, 0xD6, 0x6E, 0x6D,
1855                 0x0C, 0x91, 0x2F, 0xC4, 0x67, 0x98, 0x0E, 0xC4,
1856                 0x8D, 0x83, 0x68, 0x69, 0xC4, 0xD3, 0x94, 0x34,
1857                 0xC4, 0x5D, 0x60, 0x55, 0x22, 0x87, 0x8F, 0x6F,
1858                 0x17, 0x8E, 0x75, 0xE4, 0x02, 0xF5, 0x1B, 0x99,
1859                 0xC8, 0x39, 0xA9, 0xAB, 0x23, 0x91, 0x12, 0xED,
1860                 0x08, 0xE7, 0xD9, 0x25, 0x89, 0x24, 0x4F, 0x8D,
1861                 0x68, 0xF3, 0x10, 0x39, 0x0A, 0xEE, 0x45, 0x24,
1862                 0xDF, 0x7A, 0x9D, 0x00, 0x25, 0xE5, 0x35, 0x71,
1863                 0x4E, 0x40, 0x59, 0x6F, 0x0A, 0x13, 0xB3, 0x72,
1864                 0x1D, 0x98, 0x63, 0x94, 0x89, 0xA5, 0x39, 0x8E,
1865                 0xD3, 0x9C, 0x8A, 0x7F, 0x71, 0x2F, 0xC7, 0xCD,
1866                 0x81, 0x05, 0xDC, 0xC0, 0x8D, 0xCE, 0x6D, 0x18,
1867                 0x30, 0xC4, 0x72, 0x51, 0xF0, 0x27, 0xC8, 0xF6,
1868                 0x60, 0x5B, 0x7C, 0xB2, 0xE3, 0x49, 0x0C, 0x29,
1869                 0xC6, 0x9F, 0x39, 0x57, 0x80, 0x55, 0x24, 0x2C,
1870                 0x9B, 0x0F, 0x5A, 0xB3, 0x89, 0x55, 0x31, 0x96,
1871                 0x0D, 0xCD, 0xF6, 0x51, 0x03, 0x2D, 0x89, 0x26,
1872                 0x74, 0x44, 0xD6, 0xE8, 0xDC, 0xEA, 0x44, 0x55,
1873                 0x64, 0x71, 0x9C, 0x9F, 0x5D, 0xBA, 0x39, 0x46,
1874                 0xA8, 0x17, 0xA1, 0x9C, 0x52, 0x9D, 0xBC, 0x6B,
1875                 0x4A, 0x98, 0xE6, 0xEA, 0x33, 0xEC, 0x58, 0xB4,
1876                 0x43, 0xF0, 0x32, 0x45, 0xA4, 0xC1, 0x55, 0xB7,
1877                 0x5D, 0xB5, 0x59, 0xB2, 0xE3, 0x96, 0xFF, 0xA5,
1878                 0xAF, 0xE1, 0x86, 0x1B, 0x42, 0xE6, 0x3B, 0xA0,
1879                 0x90, 0x4A, 0xE8, 0x8C, 0x21, 0x7F, 0x36, 0x1E,
1880                 0x5B, 0x65, 0x25, 0xD1, 0xC1, 0x5A, 0xCA, 0x3D,
1881                 0x10, 0xED, 0x2D, 0x79, 0xD0, 0x0F, 0x58, 0x44,
1882                 0x69, 0x81, 0xF5, 0xD4, 0xC9, 0x0F, 0x90, 0x76,
1883                 0x1F, 0x54, 0xD2, 0xD5, 0x97, 0xCE, 0x2C, 0xE3,
1884                 0xEF, 0xF4, 0xB7, 0xC6, 0x3A, 0x87, 0x7F, 0x83,
1885                 0x2A, 0xAF, 0xCD, 0x90, 0x12, 0xA7, 0x7D, 0x85,
1886                 0x1D, 0x62, 0xD3, 0x85, 0x25, 0x05, 0xDB, 0x45,
1887                 0x92, 0xA3, 0xF6, 0xA2, 0xA8, 0x41, 0xE4, 0x25,
1888                 0x86, 0x87, 0x67, 0x24, 0xEC, 0x89, 0x23, 0x2A,
1889                 0x9B, 0x20, 0x4D, 0x93, 0xEE, 0xE2, 0x2E, 0xC1,
1890                 0x0B, 0x15, 0x33, 0xCF, 0x00, 0xD1, 0x1A, 0xDA,
1891                 0x93, 0xFD, 0x28, 0x21, 0x5B, 0xCF, 0xD1, 0xF3,
1892                 0x5A, 0x81, 0xBA, 0x82, 0x5E, 0x2F, 0x61, 0xB4,
1893                 0x05, 0x71, 0xB5, 0xF4, 0x39, 0x3C, 0x1F, 0x60,
1894                 0x00, 0x7A, 0xC4, 0xF8, 0x35, 0x20, 0x6C, 0x3A,
1895                 0xCC, 0x03, 0x8F, 0x7B, 0xA2, 0xB6, 0x65, 0x8A,
1896                 0xB6, 0x5F, 0xFD, 0x25, 0xD3, 0x5F, 0x92, 0xF9,
1897                 0xAE, 0x17, 0x9B, 0x5E, 0x6E, 0x9A, 0xE4, 0x55,
1898                 0x10, 0x25, 0x07, 0xA4, 0xAF, 0x21, 0x69, 0x13,
1899                 0xD8, 0xFA, 0x31, 0xED, 0xF7, 0xA7, 0xA7, 0x3B,
1900                 0xB8, 0x96, 0x8E, 0x10, 0x86, 0x74, 0xD8, 0xB1,
1901                 0x34, 0x9E, 0x9B, 0x6A, 0x26, 0xA8, 0xD4, 0xD0,
1902                 0xB5, 0xF6, 0xDE, 0xE7, 0xCA, 0x06, 0xDC, 0xA3,
1903                 0x6F, 0xEE, 0x6B, 0x1E, 0xB5, 0x30, 0x99, 0x23,
1904                 0xF9, 0x76, 0xF0, 0xA0, 0xCF, 0x3B, 0x94, 0x7B,
1905                 0x19, 0x8D, 0xA5, 0x0C, 0x18, 0xA6, 0x1D, 0x07,
1906                 0x89, 0xBE, 0x5B, 0x61, 0xE5, 0xF1, 0x42, 0xDB,
1907                 0xD4, 0x2E, 0x02, 0x1F, 0xCE, 0xEF, 0x92, 0xB1,
1908                 0x1B, 0x56, 0x50, 0xF2, 0x16, 0xE5, 0xE7, 0x4F,
1909                 0xFD, 0xBB, 0x3E, 0xD2, 0xFC, 0x3C, 0xC6, 0x0F,
1910                 0xF9, 0x12, 0x4E, 0xCB, 0x1E, 0x0C, 0x15, 0x84,
1911                 0x2A, 0x14, 0x8A, 0x02, 0xE4, 0x7E, 0x95, 0x5B,
1912                 0x86, 0xDB, 0x9B, 0x62, 0x5B, 0x19, 0xD2, 0x17,
1913                 0xFA, 0x13, 0xBB, 0x6B, 0x3F, 0x45, 0x9F, 0xBF
1914 };
1915
1916
1917 static  uint8_t ms_hmac_key0[] = {
1918                 0xFF, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1919                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1920                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1921                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1922                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1923                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1924                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1925                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1926 };
1927
1928 static const uint8_t ms_hmac_digest0[] = {
1929                 0x43, 0x52, 0xED, 0x34, 0xAB, 0x36, 0xB2, 0x51,
1930                 0xFB, 0xA3, 0xA6, 0x7C, 0x38, 0xFC, 0x42, 0x8F,
1931                 0x57, 0x64, 0xAB, 0x81, 0xA7, 0x89, 0xB7, 0x6C,
1932                 0xA0, 0xDC, 0xB9, 0x4D, 0xC4, 0x30, 0xF9, 0xD4,
1933                 0x10, 0x82, 0x55, 0xD0, 0xAB, 0x32, 0xFB, 0x56,
1934                 0x0D, 0xE4, 0x68, 0x3D, 0x76, 0xD0, 0x7B, 0xE4,
1935                 0xA6, 0x2C, 0x34, 0x9E, 0x8C, 0x41, 0xF8, 0x23,
1936                 0x28, 0x1B, 0x3A, 0x90, 0x26, 0x34, 0x47, 0x90
1937                 };
1938
1939 /* End Session 0 */
1940 /* Begin session 1 */
1941
1942 static  uint8_t ms_aes_cbc_key1[] = {
1943                 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1944                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1945 };
1946
1947 static  uint8_t ms_aes_cbc_iv1[] = {
1948         0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1949         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1950 };
1951
1952 static const uint8_t ms_aes_cbc_cipher1[] = {
1953                 0x5A, 0x7A, 0x67, 0x5D, 0xB8, 0xE1, 0xDC, 0x71,
1954                 0x39, 0xA8, 0x74, 0x93, 0x9C, 0x4C, 0xFE, 0x23,
1955                 0x61, 0xCD, 0xA4, 0xB3, 0xD9, 0xCE, 0x99, 0x09,
1956                 0x2A, 0x23, 0xF3, 0x29, 0xBF, 0x4C, 0xB4, 0x6A,
1957                 0x1B, 0x6B, 0x73, 0x4D, 0x48, 0x0C, 0xCF, 0x6C,
1958                 0x5E, 0x34, 0x9E, 0x7F, 0xBC, 0x8F, 0xCC, 0x8F,
1959                 0x75, 0x1D, 0x3D, 0x77, 0x10, 0x76, 0xC8, 0xB9,
1960                 0x99, 0x6F, 0xD6, 0x56, 0x75, 0xA9, 0xB2, 0x66,
1961                 0xC2, 0x24, 0x2B, 0x9C, 0xFE, 0x40, 0x8E, 0x43,
1962                 0x20, 0x97, 0x1B, 0xFA, 0xD0, 0xCF, 0x04, 0xAB,
1963                 0xBB, 0xF6, 0x5D, 0xF5, 0xA0, 0x19, 0x7C, 0x23,
1964                 0x5D, 0x80, 0x8C, 0x49, 0xF6, 0x76, 0x88, 0x29,
1965                 0x27, 0x4C, 0x59, 0x2B, 0x43, 0xA6, 0xB2, 0x26,
1966                 0x27, 0x78, 0xBE, 0x1B, 0xE1, 0x4F, 0x5A, 0x1F,
1967                 0xFC, 0x68, 0x08, 0xE7, 0xC4, 0xD1, 0x34, 0x68,
1968                 0xB7, 0x13, 0x14, 0x41, 0x62, 0x6B, 0x1F, 0x77,
1969                 0x0C, 0x68, 0x1D, 0x0D, 0xED, 0x89, 0xAA, 0xD8,
1970                 0x97, 0x02, 0xBA, 0x5E, 0xD4, 0x84, 0x25, 0x97,
1971                 0x03, 0xA5, 0xA6, 0x13, 0x66, 0x02, 0xF4, 0xC3,
1972                 0xF3, 0xD3, 0xCC, 0x95, 0xC3, 0x87, 0x46, 0x90,
1973                 0x1F, 0x6E, 0x14, 0xA8, 0x00, 0xF2, 0x6F, 0xD5,
1974                 0xA1, 0xAD, 0xD5, 0x40, 0xA2, 0x0F, 0x32, 0x7E,
1975                 0x99, 0xA3, 0xF5, 0x53, 0xC3, 0x26, 0xA1, 0x45,
1976                 0x01, 0x88, 0x57, 0x84, 0x3E, 0x7B, 0x4E, 0x0B,
1977                 0x3C, 0xB5, 0x3E, 0x9E, 0xE9, 0x78, 0x77, 0xC5,
1978                 0xC0, 0x89, 0xA8, 0xF8, 0xF1, 0xA5, 0x2D, 0x5D,
1979                 0xF9, 0xC6, 0xFB, 0xCB, 0x05, 0x23, 0xBD, 0x6E,
1980                 0x5E, 0x14, 0xC6, 0x57, 0x73, 0xCF, 0x98, 0xBD,
1981                 0x10, 0x8B, 0x18, 0xA6, 0x01, 0x5B, 0x13, 0xAE,
1982                 0x8E, 0xDE, 0x1F, 0xB5, 0xB7, 0x40, 0x6C, 0xC1,
1983                 0x1E, 0xA1, 0x19, 0x20, 0x9E, 0x95, 0xE0, 0x2F,
1984                 0x1C, 0xF5, 0xD9, 0xD0, 0x2B, 0x1E, 0x82, 0x25,
1985                 0x62, 0xB4, 0xEB, 0xA1, 0x1F, 0xCE, 0x44, 0xA1,
1986                 0xCB, 0x92, 0x01, 0x6B, 0xE4, 0x26, 0x23, 0xE3,
1987                 0xC5, 0x67, 0x35, 0x55, 0xDA, 0xE5, 0x27, 0xEE,
1988                 0x8D, 0x12, 0x84, 0xB7, 0xBA, 0xA7, 0x1C, 0xD6,
1989                 0x32, 0x3F, 0x67, 0xED, 0xFB, 0x5B, 0x8B, 0x52,
1990                 0x46, 0x8C, 0xF9, 0x69, 0xCD, 0xAE, 0x79, 0xAA,
1991                 0x37, 0x78, 0x49, 0xEB, 0xC6, 0x8E, 0x76, 0x63,
1992                 0x84, 0xFF, 0x9D, 0x22, 0x99, 0x51, 0xB7, 0x5E,
1993                 0x83, 0x4C, 0x8B, 0xDF, 0x5A, 0x07, 0xCC, 0xBA,
1994                 0x42, 0xA5, 0x98, 0xB6, 0x47, 0x0E, 0x66, 0xEB,
1995                 0x23, 0x0E, 0xBA, 0x44, 0xA8, 0xAA, 0x20, 0x71,
1996                 0x79, 0x9C, 0x77, 0x5F, 0xF5, 0xFE, 0xEC, 0xEF,
1997                 0xC6, 0x64, 0x3D, 0x84, 0xD0, 0x2B, 0xA7, 0x0A,
1998                 0xC3, 0x72, 0x5B, 0x9C, 0xFA, 0xA8, 0x87, 0x95,
1999                 0x94, 0x11, 0x38, 0xA7, 0x1E, 0x58, 0xE3, 0x73,
2000                 0xC6, 0xC9, 0xD1, 0x7B, 0x92, 0xDB, 0x0F, 0x49,
2001                 0x74, 0xC2, 0xA2, 0x0E, 0x35, 0x57, 0xAC, 0xDB,
2002                 0x9A, 0x1C, 0xCF, 0x5A, 0x32, 0x3E, 0x26, 0x9B,
2003                 0xEC, 0xB3, 0xEF, 0x9C, 0xFE, 0xBE, 0x52, 0xAC,
2004                 0xB1, 0x29, 0xDD, 0xFD, 0x07, 0xE2, 0xEE, 0xED,
2005                 0xE4, 0x46, 0x37, 0xFE, 0xD1, 0xDC, 0xCD, 0x02,
2006                 0xF9, 0x31, 0xB0, 0xFB, 0x36, 0xB7, 0x34, 0xA4,
2007                 0x76, 0xE8, 0x57, 0xBF, 0x99, 0x92, 0xC7, 0xAF,
2008                 0x98, 0x10, 0xE2, 0x70, 0xCA, 0xC9, 0x2B, 0x82,
2009                 0x06, 0x96, 0x88, 0x0D, 0xB3, 0xAC, 0x9E, 0x6D,
2010                 0x43, 0xBC, 0x5B, 0x31, 0xCF, 0x65, 0x8D, 0xA6,
2011                 0xC7, 0xFE, 0x73, 0xE1, 0x54, 0xF7, 0x10, 0xF9,
2012                 0x86, 0xF7, 0xDF, 0xA1, 0xA1, 0xD8, 0xAE, 0x35,
2013                 0xB3, 0x90, 0xDC, 0x6F, 0x43, 0x7A, 0x8B, 0xE0,
2014                 0xFE, 0x8F, 0x33, 0x4D, 0x29, 0x6C, 0x45, 0x53,
2015                 0x73, 0xDD, 0x21, 0x0B, 0x85, 0x30, 0xB5, 0xA5,
2016                 0xF3, 0x5D, 0xEC, 0x79, 0x61, 0x9D, 0x9E, 0xB3
2017
2018 };
2019
2020 static uint8_t ms_hmac_key1[] = {
2021                 0xFE, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
2022                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
2023                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
2024                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
2025                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
2026                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
2027                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
2028                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
2029 };
2030
2031 static const uint8_t ms_hmac_digest1[] = {
2032                 0xCE, 0x6E, 0x5F, 0x77, 0x96, 0x9A, 0xB1, 0x69,
2033                 0x2D, 0x5E, 0xF3, 0x2F, 0x32, 0x10, 0xCB, 0x50,
2034                 0x0E, 0x09, 0x56, 0x25, 0x07, 0x34, 0xC9, 0x20,
2035                 0xEC, 0x13, 0x43, 0x23, 0x5C, 0x08, 0x8B, 0xCD,
2036                 0xDC, 0x86, 0x8C, 0xEE, 0x0A, 0x95, 0x2E, 0xB9,
2037                 0x8C, 0x7B, 0x02, 0x7A, 0xD4, 0xE1, 0x49, 0xB4,
2038                 0x45, 0xB5, 0x52, 0x37, 0xC6, 0xFF, 0xFE, 0xAA,
2039                 0x0A, 0x87, 0xB8, 0x51, 0xF9, 0x2A, 0x01, 0x8F
2040 };
2041 /* End Session 1  */
2042 /* Begin Session 2 */
2043 static  uint8_t ms_aes_cbc_key2[] = {
2044                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
2045                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
2046 };
2047
2048 static  uint8_t ms_aes_cbc_iv2[] = {
2049                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
2050                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
2051 };
2052
2053 static const uint8_t ms_aes_cbc_cipher2[] = {
2054                 0xBB, 0x3C, 0x68, 0x25, 0xFD, 0xB6, 0xA2, 0x91,
2055                 0x20, 0x56, 0xF6, 0x30, 0x35, 0xFC, 0x9E, 0x97,
2056                 0xF2, 0x90, 0xFC, 0x7E, 0x3E, 0x0A, 0x75, 0xC8,
2057                 0x4C, 0xF2, 0x2D, 0xAC, 0xD3, 0x93, 0xF0, 0xC5,
2058                 0x14, 0x88, 0x8A, 0x23, 0xC2, 0x59, 0x9A, 0x98,
2059                 0x4B, 0xD5, 0x2C, 0xDA, 0x43, 0xA9, 0x34, 0x69,
2060                 0x7C, 0x6D, 0xDB, 0xDC, 0xCB, 0xC0, 0xA0, 0x09,
2061                 0xA7, 0x86, 0x16, 0x4B, 0xBF, 0xA8, 0xB6, 0xCF,
2062                 0x7F, 0x74, 0x1F, 0x22, 0xF0, 0xF6, 0xBB, 0x44,
2063                 0x8B, 0x4C, 0x9E, 0x23, 0xF8, 0x9F, 0xFC, 0x5B,
2064                 0x9E, 0x9C, 0x2A, 0x79, 0x30, 0x8F, 0xBF, 0xA9,
2065                 0x68, 0xA1, 0x20, 0x71, 0x7C, 0x77, 0x22, 0x34,
2066                 0x07, 0xCD, 0xC6, 0xF6, 0x50, 0x0A, 0x08, 0x99,
2067                 0x17, 0x98, 0xE3, 0x93, 0x8A, 0xB0, 0xEE, 0xDF,
2068                 0xC2, 0xBA, 0x3B, 0x44, 0x73, 0xDF, 0xDD, 0xDC,
2069                 0x14, 0x4D, 0x3B, 0xBB, 0x5E, 0x58, 0xC1, 0x26,
2070                 0xA7, 0xAE, 0x47, 0xF3, 0x24, 0x6D, 0x4F, 0xD3,
2071                 0x6E, 0x3E, 0x33, 0xE6, 0x7F, 0xCA, 0x50, 0xAF,
2072                 0x5D, 0x3D, 0xA0, 0xDD, 0xC9, 0xF3, 0x30, 0xD3,
2073                 0x6E, 0x8B, 0x2E, 0x12, 0x24, 0x34, 0xF0, 0xD3,
2074                 0xC7, 0x8D, 0x23, 0x29, 0xAA, 0x05, 0xE1, 0xFA,
2075                 0x2E, 0xF6, 0x8D, 0x37, 0x86, 0xC0, 0x6D, 0x13,
2076                 0x2D, 0x98, 0xF3, 0x52, 0x39, 0x22, 0xCE, 0x38,
2077                 0xC2, 0x1A, 0x72, 0xED, 0xFB, 0xCC, 0xE4, 0x71,
2078                 0x5A, 0x0C, 0x0D, 0x09, 0xF8, 0xE8, 0x1B, 0xBC,
2079                 0x53, 0xC8, 0xD8, 0x8F, 0xE5, 0x98, 0x5A, 0xB1,
2080                 0x06, 0xA6, 0x5B, 0xE6, 0xA2, 0x88, 0x21, 0x9E,
2081                 0x36, 0xC0, 0x34, 0xF9, 0xFB, 0x3B, 0x0A, 0x22,
2082                 0x00, 0x00, 0x39, 0x48, 0x8D, 0x23, 0x74, 0x62,
2083                 0x72, 0x91, 0xE6, 0x36, 0xAA, 0x77, 0x9C, 0x72,
2084                 0x9D, 0xA8, 0xC3, 0xA9, 0xD5, 0x44, 0x72, 0xA6,
2085                 0xB9, 0x28, 0x8F, 0x64, 0x4C, 0x8A, 0x64, 0xE6,
2086                 0x4E, 0xFA, 0xEF, 0x87, 0xDE, 0x7B, 0x22, 0x44,
2087                 0xB0, 0xDF, 0x2E, 0x5F, 0x0B, 0xA5, 0xF2, 0x24,
2088                 0x07, 0x5C, 0x2D, 0x39, 0xB7, 0x3D, 0x8A, 0xE5,
2089                 0x0E, 0x9D, 0x4E, 0x50, 0xED, 0x03, 0x99, 0x8E,
2090                 0xF0, 0x06, 0x55, 0x4E, 0xA2, 0x24, 0xE7, 0x17,
2091                 0x46, 0xDF, 0x6C, 0xCD, 0xC6, 0x44, 0xE8, 0xF9,
2092                 0xB9, 0x1B, 0x36, 0xF6, 0x7F, 0x10, 0xA4, 0x7D,
2093                 0x90, 0xBD, 0xE4, 0xAA, 0xD6, 0x9E, 0x18, 0x9D,
2094                 0x22, 0x35, 0xD6, 0x55, 0x54, 0xAA, 0xF7, 0x22,
2095                 0xA3, 0x3E, 0xEF, 0xC8, 0xA2, 0x34, 0x8D, 0xA9,
2096                 0x37, 0x63, 0xA6, 0xC3, 0x57, 0xCB, 0x0C, 0x49,
2097                 0x7D, 0x02, 0xBE, 0xAA, 0x13, 0x75, 0xB7, 0x4E,
2098                 0x52, 0x62, 0xA5, 0xC2, 0x33, 0xC7, 0x6C, 0x1B,
2099                 0xF6, 0x34, 0xF6, 0x09, 0xA5, 0x0C, 0xC7, 0xA2,
2100                 0x61, 0x48, 0x62, 0x7D, 0x17, 0x15, 0xE3, 0x95,
2101                 0xC8, 0x63, 0xD2, 0xA4, 0x43, 0xA9, 0x49, 0x07,
2102                 0xB2, 0x3B, 0x2B, 0x62, 0x7D, 0xCB, 0x51, 0xB3,
2103                 0x25, 0x33, 0x47, 0x0E, 0x14, 0x67, 0xDC, 0x6A,
2104                 0x9B, 0x51, 0xAC, 0x9D, 0x8F, 0xA2, 0x2B, 0x57,
2105                 0x8C, 0x5C, 0x5F, 0x76, 0x23, 0x92, 0x0F, 0x84,
2106                 0x46, 0x0E, 0x40, 0x85, 0x38, 0x60, 0xFA, 0x61,
2107                 0x20, 0xC5, 0xE3, 0xF1, 0x70, 0xAC, 0x1B, 0xBF,
2108                 0xC4, 0x2B, 0xC5, 0x67, 0xD1, 0x43, 0xC5, 0x17,
2109                 0x74, 0x71, 0x69, 0x6F, 0x82, 0x89, 0x19, 0x8A,
2110                 0x70, 0x43, 0x92, 0x01, 0xC4, 0x63, 0x7E, 0xB1,
2111                 0x59, 0x4E, 0xCD, 0xEA, 0x93, 0xA4, 0x52, 0x53,
2112                 0x9B, 0x61, 0x5B, 0xD2, 0x3E, 0x19, 0x39, 0xB7,
2113                 0x32, 0xEA, 0x8E, 0xF8, 0x1D, 0x76, 0x5C, 0xB2,
2114                 0x73, 0x2D, 0x91, 0xC0, 0x18, 0xED, 0x25, 0x2A,
2115                 0x53, 0x64, 0xF0, 0x92, 0x31, 0x55, 0x21, 0xA8,
2116                 0x24, 0xA9, 0xD1, 0x02, 0xF6, 0x6C, 0x2B, 0x70,
2117                 0xA9, 0x59, 0xC1, 0xD6, 0xC3, 0x57, 0x5B, 0x92
2118 };
2119
2120 static  uint8_t ms_hmac_key2[] = {
2121                 0xFC, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
2122                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
2123                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
2124                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
2125                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
2126                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
2127                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
2128                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
2129 };
2130
2131 static const uint8_t ms_hmac_digest2[] = {
2132                 0xA5, 0x0F, 0x9C, 0xFB, 0x08, 0x62, 0x59, 0xFF,
2133                 0x80, 0x2F, 0xEB, 0x4B, 0xE1, 0x46, 0x21, 0xD6,
2134                 0x02, 0x98, 0xF2, 0x8E, 0xF4, 0xEC, 0xD4, 0x77,
2135                 0x86, 0x4C, 0x31, 0x28, 0xC8, 0x25, 0x80, 0x27,
2136                 0x3A, 0x72, 0x5D, 0x6A, 0x56, 0x8A, 0xD3, 0x82,
2137                 0xB0, 0xEC, 0x31, 0x6D, 0x8B, 0x6B, 0xB4, 0x24,
2138                 0xE7, 0x62, 0xC1, 0x52, 0xBC, 0x14, 0x1B, 0x8E,
2139                 0xEC, 0x9A, 0xF1, 0x47, 0x80, 0xD2, 0xB0, 0x59
2140 };
2141
2142 /* End Session 2 */
2143
2144
2145 static int
2146 test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
2147 {
2148         struct crypto_testsuite_params *ts_params = &testsuite_params;
2149         struct crypto_unittest_params *ut_params = &unittest_params;
2150         int status;
2151
2152         /* Verify the capabilities */
2153         struct rte_cryptodev_sym_capability_idx cap_idx;
2154         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2155         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
2156         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2157                         &cap_idx) == NULL)
2158                 return TEST_SKIPPED;
2159         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2160         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
2161         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2162                         &cap_idx) == NULL)
2163                 return TEST_SKIPPED;
2164
2165         /* Generate test mbuf data and space for digest */
2166         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
2167                         catch_22_quote, QUOTE_512_BYTES, 0);
2168
2169         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2170                         DIGEST_BYTE_LENGTH_SHA1);
2171         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
2172
2173         /* Setup Cipher Parameters */
2174         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2175         ut_params->cipher_xform.next = &ut_params->auth_xform;
2176
2177         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
2178         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2179         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
2180         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
2181         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2182         ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
2183
2184         /* Setup HMAC Parameters */
2185         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2186
2187         ut_params->auth_xform.next = NULL;
2188
2189         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2190         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
2191         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1;
2192         ut_params->auth_xform.auth.key.data = hmac_sha1_key;
2193         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
2194
2195         ut_params->sess = rte_cryptodev_sym_session_create(
2196                         ts_params->session_mpool);
2197         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2198
2199         /* Create crypto session*/
2200         status = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
2201                         ut_params->sess, &ut_params->cipher_xform,
2202                         ts_params->session_priv_mpool);
2203
2204         if (status == -ENOTSUP)
2205                 return TEST_SKIPPED;
2206
2207         TEST_ASSERT_EQUAL(status, 0, "Session init failed");
2208
2209         /* Generate crypto op data structure */
2210         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2211                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2212         TEST_ASSERT_NOT_NULL(ut_params->op,
2213                         "Failed to allocate symmetric crypto operation struct");
2214
2215         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2216
2217         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2218
2219         /* set crypto operation source mbuf */
2220         sym_op->m_src = ut_params->ibuf;
2221
2222         /* Set crypto operation authentication parameters */
2223         sym_op->auth.digest.data = ut_params->digest;
2224         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2225                         ut_params->ibuf, QUOTE_512_BYTES);
2226
2227         sym_op->auth.data.offset = 0;
2228         sym_op->auth.data.length = QUOTE_512_BYTES;
2229
2230         /* Copy IV at the end of the crypto operation */
2231         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2232                         aes_cbc_iv, CIPHER_IV_LENGTH_AES_CBC);
2233
2234         /* Set crypto operation cipher parameters */
2235         sym_op->cipher.data.offset = 0;
2236         sym_op->cipher.data.length = QUOTE_512_BYTES;
2237
2238         /* Process crypto operation */
2239         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2240                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
2241                         ut_params->op);
2242         else
2243                 TEST_ASSERT_NOT_NULL(
2244                         process_crypto_request(ts_params->valid_devs[0],
2245                                 ut_params->op),
2246                                 "failed to process sym crypto op");
2247
2248         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2249                         "crypto op processing failed");
2250
2251         /* Validate obuf */
2252         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
2253                         uint8_t *);
2254
2255         TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext,
2256                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
2257                         QUOTE_512_BYTES,
2258                         "ciphertext data not as expected");
2259
2260         uint8_t *digest = ciphertext + QUOTE_512_BYTES;
2261
2262         TEST_ASSERT_BUFFERS_ARE_EQUAL(digest,
2263                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
2264                         gbl_driver_id == rte_cryptodev_driver_id_get(
2265                                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) ?
2266                                         TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
2267                                         DIGEST_BYTE_LENGTH_SHA1,
2268                         "Generated digest data not as expected");
2269
2270         return TEST_SUCCESS;
2271 }
2272
2273 /* ***** AES-CBC / HMAC-SHA512 Hash Tests ***** */
2274
2275 #define HMAC_KEY_LENGTH_SHA512  (DIGEST_BYTE_LENGTH_SHA512)
2276
2277 static uint8_t hmac_sha512_key[] = {
2278         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
2279         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
2280         0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
2281         0x9a, 0xaf, 0x88, 0x1b, 0xb6, 0x8f, 0xf8, 0x60,
2282         0xa2, 0x5a, 0x7f, 0x3f, 0xf4, 0x72, 0x70, 0xf1,
2283         0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
2284         0x47, 0x3a, 0x75, 0x61, 0x5C, 0xa2, 0x10, 0x76,
2285         0x9a, 0xaf, 0x77, 0x5b, 0xb6, 0x7f, 0xf7, 0x60 };
2286
2287 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest[] = {
2288         0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8,
2289         0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48,
2290         0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8,
2291         0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70,
2292         0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8,
2293         0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E,
2294         0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D,
2295         0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A };
2296
2297
2298
2299 static int
2300 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
2301                 struct crypto_unittest_params *ut_params,
2302                 uint8_t *cipher_key,
2303                 uint8_t *hmac_key);
2304
2305 static int
2306 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
2307                 struct crypto_unittest_params *ut_params,
2308                 struct crypto_testsuite_params *ts_params,
2309                 const uint8_t *cipher,
2310                 const uint8_t *digest,
2311                 const uint8_t *iv);
2312
2313
2314 static int
2315 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
2316                 struct crypto_unittest_params *ut_params,
2317                 uint8_t *cipher_key,
2318                 uint8_t *hmac_key)
2319 {
2320
2321         /* Setup Cipher Parameters */
2322         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2323         ut_params->cipher_xform.next = NULL;
2324
2325         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
2326         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
2327         ut_params->cipher_xform.cipher.key.data = cipher_key;
2328         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
2329         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2330         ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
2331
2332         /* Setup HMAC Parameters */
2333         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2334         ut_params->auth_xform.next = &ut_params->cipher_xform;
2335
2336         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
2337         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC;
2338         ut_params->auth_xform.auth.key.data = hmac_key;
2339         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512;
2340         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512;
2341
2342         return TEST_SUCCESS;
2343 }
2344
2345
2346 static int
2347 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
2348                 struct crypto_unittest_params *ut_params,
2349                 struct crypto_testsuite_params *ts_params,
2350                 const uint8_t *cipher,
2351                 const uint8_t *digest,
2352                 const uint8_t *iv)
2353 {
2354         /* Generate test mbuf data and digest */
2355         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
2356                         (const char *)
2357                         cipher,
2358                         QUOTE_512_BYTES, 0);
2359
2360         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2361                         DIGEST_BYTE_LENGTH_SHA512);
2362         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
2363
2364         rte_memcpy(ut_params->digest,
2365                         digest,
2366                         DIGEST_BYTE_LENGTH_SHA512);
2367
2368         /* Generate Crypto op data structure */
2369         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2370                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2371         TEST_ASSERT_NOT_NULL(ut_params->op,
2372                         "Failed to allocate symmetric crypto operation struct");
2373
2374         rte_crypto_op_attach_sym_session(ut_params->op, sess);
2375
2376         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2377
2378         /* set crypto operation source mbuf */
2379         sym_op->m_src = ut_params->ibuf;
2380
2381         sym_op->auth.digest.data = ut_params->digest;
2382         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2383                         ut_params->ibuf, QUOTE_512_BYTES);
2384
2385         sym_op->auth.data.offset = 0;
2386         sym_op->auth.data.length = QUOTE_512_BYTES;
2387
2388         /* Copy IV at the end of the crypto operation */
2389         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2390                         iv, CIPHER_IV_LENGTH_AES_CBC);
2391
2392         sym_op->cipher.data.offset = 0;
2393         sym_op->cipher.data.length = QUOTE_512_BYTES;
2394
2395         /* Process crypto operation */
2396         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2397                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
2398                         ut_params->op);
2399         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
2400                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
2401                                 ut_params->op, 1, 1, 0, 0);
2402         else
2403                 TEST_ASSERT_NOT_NULL(
2404                                 process_crypto_request(ts_params->valid_devs[0],
2405                                         ut_params->op),
2406                                         "failed to process sym crypto op");
2407
2408         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2409                         "crypto op processing failed");
2410
2411         ut_params->obuf = ut_params->op->sym->m_src;
2412
2413         /* Validate obuf */
2414         TEST_ASSERT_BUFFERS_ARE_EQUAL(
2415                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *),
2416                         catch_22_quote,
2417                         QUOTE_512_BYTES,
2418                         "Plaintext data not as expected");
2419
2420         /* Validate obuf */
2421         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2422                         "Digest verification failed");
2423
2424         return TEST_SUCCESS;
2425 }
2426
2427 /* ***** SNOW 3G Tests ***** */
2428 static int
2429 create_wireless_algo_hash_session(uint8_t dev_id,
2430         const uint8_t *key, const uint8_t key_len,
2431         const uint8_t iv_len, const uint8_t auth_len,
2432         enum rte_crypto_auth_operation op,
2433         enum rte_crypto_auth_algorithm algo)
2434 {
2435         uint8_t hash_key[key_len];
2436         int status;
2437
2438         struct crypto_testsuite_params *ts_params = &testsuite_params;
2439         struct crypto_unittest_params *ut_params = &unittest_params;
2440
2441         memcpy(hash_key, key, key_len);
2442
2443         debug_hexdump(stdout, "key:", key, key_len);
2444
2445         /* Setup Authentication Parameters */
2446         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2447         ut_params->auth_xform.next = NULL;
2448
2449         ut_params->auth_xform.auth.op = op;
2450         ut_params->auth_xform.auth.algo = algo;
2451         ut_params->auth_xform.auth.key.length = key_len;
2452         ut_params->auth_xform.auth.key.data = hash_key;
2453         ut_params->auth_xform.auth.digest_length = auth_len;
2454         ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
2455         ut_params->auth_xform.auth.iv.length = iv_len;
2456         ut_params->sess = rte_cryptodev_sym_session_create(
2457                         ts_params->session_mpool);
2458
2459         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2460                         &ut_params->auth_xform,
2461                         ts_params->session_priv_mpool);
2462         if (status == -ENOTSUP)
2463                 return TEST_SKIPPED;
2464
2465         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2466         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2467         return 0;
2468 }
2469
2470 static int
2471 create_wireless_algo_cipher_session(uint8_t dev_id,
2472                         enum rte_crypto_cipher_operation op,
2473                         enum rte_crypto_cipher_algorithm algo,
2474                         const uint8_t *key, const uint8_t key_len,
2475                         uint8_t iv_len)
2476 {
2477         uint8_t cipher_key[key_len];
2478         int status;
2479         struct crypto_testsuite_params *ts_params = &testsuite_params;
2480         struct crypto_unittest_params *ut_params = &unittest_params;
2481
2482         memcpy(cipher_key, key, key_len);
2483
2484         /* Setup Cipher Parameters */
2485         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2486         ut_params->cipher_xform.next = NULL;
2487
2488         ut_params->cipher_xform.cipher.algo = algo;
2489         ut_params->cipher_xform.cipher.op = op;
2490         ut_params->cipher_xform.cipher.key.data = cipher_key;
2491         ut_params->cipher_xform.cipher.key.length = key_len;
2492         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2493         ut_params->cipher_xform.cipher.iv.length = iv_len;
2494
2495         debug_hexdump(stdout, "key:", key, key_len);
2496
2497         /* Create Crypto session */
2498         ut_params->sess = rte_cryptodev_sym_session_create(
2499                         ts_params->session_mpool);
2500
2501         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2502                         &ut_params->cipher_xform,
2503                         ts_params->session_priv_mpool);
2504         if (status == -ENOTSUP)
2505                 return TEST_SKIPPED;
2506
2507         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2508         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2509         return 0;
2510 }
2511
2512 static int
2513 create_wireless_algo_cipher_operation(const uint8_t *iv, uint8_t iv_len,
2514                         unsigned int cipher_len,
2515                         unsigned int cipher_offset)
2516 {
2517         struct crypto_testsuite_params *ts_params = &testsuite_params;
2518         struct crypto_unittest_params *ut_params = &unittest_params;
2519
2520         /* Generate Crypto op data structure */
2521         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2522                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2523         TEST_ASSERT_NOT_NULL(ut_params->op,
2524                                 "Failed to allocate pktmbuf offload");
2525
2526         /* Set crypto operation data parameters */
2527         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2528
2529         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2530
2531         /* set crypto operation source mbuf */
2532         sym_op->m_src = ut_params->ibuf;
2533
2534         /* iv */
2535         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2536                         iv, iv_len);
2537         sym_op->cipher.data.length = cipher_len;
2538         sym_op->cipher.data.offset = cipher_offset;
2539         return 0;
2540 }
2541
2542 static int
2543 create_wireless_algo_cipher_operation_oop(const uint8_t *iv, uint8_t iv_len,
2544                         unsigned int cipher_len,
2545                         unsigned int cipher_offset)
2546 {
2547         struct crypto_testsuite_params *ts_params = &testsuite_params;
2548         struct crypto_unittest_params *ut_params = &unittest_params;
2549
2550         /* Generate Crypto op data structure */
2551         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2552                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2553         TEST_ASSERT_NOT_NULL(ut_params->op,
2554                                 "Failed to allocate pktmbuf offload");
2555
2556         /* Set crypto operation data parameters */
2557         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2558
2559         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2560
2561         /* set crypto operation source mbuf */
2562         sym_op->m_src = ut_params->ibuf;
2563         sym_op->m_dst = ut_params->obuf;
2564
2565         /* iv */
2566         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2567                         iv, iv_len);
2568         sym_op->cipher.data.length = cipher_len;
2569         sym_op->cipher.data.offset = cipher_offset;
2570         return 0;
2571 }
2572
2573 static int
2574 create_wireless_algo_cipher_auth_session(uint8_t dev_id,
2575                 enum rte_crypto_cipher_operation cipher_op,
2576                 enum rte_crypto_auth_operation auth_op,
2577                 enum rte_crypto_auth_algorithm auth_algo,
2578                 enum rte_crypto_cipher_algorithm cipher_algo,
2579                 const uint8_t *key, uint8_t key_len,
2580                 uint8_t auth_iv_len, uint8_t auth_len,
2581                 uint8_t cipher_iv_len)
2582
2583 {
2584         uint8_t cipher_auth_key[key_len];
2585         int status;
2586
2587         struct crypto_testsuite_params *ts_params = &testsuite_params;
2588         struct crypto_unittest_params *ut_params = &unittest_params;
2589
2590         memcpy(cipher_auth_key, key, key_len);
2591
2592         /* Setup Authentication Parameters */
2593         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2594         ut_params->auth_xform.next = NULL;
2595
2596         ut_params->auth_xform.auth.op = auth_op;
2597         ut_params->auth_xform.auth.algo = auth_algo;
2598         ut_params->auth_xform.auth.key.length = key_len;
2599         /* Hash key = cipher key */
2600         ut_params->auth_xform.auth.key.data = cipher_auth_key;
2601         ut_params->auth_xform.auth.digest_length = auth_len;
2602         /* Auth IV will be after cipher IV */
2603         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2604         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2605
2606         /* Setup Cipher Parameters */
2607         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2608         ut_params->cipher_xform.next = &ut_params->auth_xform;
2609
2610         ut_params->cipher_xform.cipher.algo = cipher_algo;
2611         ut_params->cipher_xform.cipher.op = cipher_op;
2612         ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2613         ut_params->cipher_xform.cipher.key.length = key_len;
2614         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2615         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2616
2617         debug_hexdump(stdout, "key:", key, key_len);
2618
2619         /* Create Crypto session*/
2620         ut_params->sess = rte_cryptodev_sym_session_create(
2621                         ts_params->session_mpool);
2622         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2623
2624         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2625                         &ut_params->cipher_xform,
2626                         ts_params->session_priv_mpool);
2627         if (status == -ENOTSUP)
2628                 return TEST_SKIPPED;
2629
2630         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2631         return 0;
2632 }
2633
2634 static int
2635 create_wireless_cipher_auth_session(uint8_t dev_id,
2636                 enum rte_crypto_cipher_operation cipher_op,
2637                 enum rte_crypto_auth_operation auth_op,
2638                 enum rte_crypto_auth_algorithm auth_algo,
2639                 enum rte_crypto_cipher_algorithm cipher_algo,
2640                 const struct wireless_test_data *tdata)
2641 {
2642         const uint8_t key_len = tdata->key.len;
2643         uint8_t cipher_auth_key[key_len];
2644         int status;
2645
2646         struct crypto_testsuite_params *ts_params = &testsuite_params;
2647         struct crypto_unittest_params *ut_params = &unittest_params;
2648         const uint8_t *key = tdata->key.data;
2649         const uint8_t auth_len = tdata->digest.len;
2650         uint8_t cipher_iv_len = tdata->cipher_iv.len;
2651         uint8_t auth_iv_len = tdata->auth_iv.len;
2652
2653         memcpy(cipher_auth_key, key, key_len);
2654
2655         /* Setup Authentication Parameters */
2656         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2657         ut_params->auth_xform.next = NULL;
2658
2659         ut_params->auth_xform.auth.op = auth_op;
2660         ut_params->auth_xform.auth.algo = auth_algo;
2661         ut_params->auth_xform.auth.key.length = key_len;
2662         /* Hash key = cipher key */
2663         ut_params->auth_xform.auth.key.data = cipher_auth_key;
2664         ut_params->auth_xform.auth.digest_length = auth_len;
2665         /* Auth IV will be after cipher IV */
2666         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2667         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2668
2669         /* Setup Cipher Parameters */
2670         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2671         ut_params->cipher_xform.next = &ut_params->auth_xform;
2672
2673         ut_params->cipher_xform.cipher.algo = cipher_algo;
2674         ut_params->cipher_xform.cipher.op = cipher_op;
2675         ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2676         ut_params->cipher_xform.cipher.key.length = key_len;
2677         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2678         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2679
2680
2681         debug_hexdump(stdout, "key:", key, key_len);
2682
2683         /* Create Crypto session*/
2684         ut_params->sess = rte_cryptodev_sym_session_create(
2685                         ts_params->session_mpool);
2686
2687         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2688                         &ut_params->cipher_xform,
2689                         ts_params->session_priv_mpool);
2690         if (status == -ENOTSUP)
2691                 return TEST_SKIPPED;
2692
2693         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2694         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2695         return 0;
2696 }
2697
2698 static int
2699 create_zuc_cipher_auth_encrypt_generate_session(uint8_t dev_id,
2700                 const struct wireless_test_data *tdata)
2701 {
2702         return create_wireless_cipher_auth_session(dev_id,
2703                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2704                 RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_ZUC_EIA3,
2705                 RTE_CRYPTO_CIPHER_ZUC_EEA3, tdata);
2706 }
2707
2708 static int
2709 create_wireless_algo_auth_cipher_session(uint8_t dev_id,
2710                 enum rte_crypto_cipher_operation cipher_op,
2711                 enum rte_crypto_auth_operation auth_op,
2712                 enum rte_crypto_auth_algorithm auth_algo,
2713                 enum rte_crypto_cipher_algorithm cipher_algo,
2714                 const uint8_t *key, const uint8_t key_len,
2715                 uint8_t auth_iv_len, uint8_t auth_len,
2716                 uint8_t cipher_iv_len)
2717 {
2718         uint8_t auth_cipher_key[key_len];
2719         int status;
2720         struct crypto_testsuite_params *ts_params = &testsuite_params;
2721         struct crypto_unittest_params *ut_params = &unittest_params;
2722
2723         memcpy(auth_cipher_key, key, key_len);
2724
2725         /* Setup Authentication Parameters */
2726         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2727         ut_params->auth_xform.auth.op = auth_op;
2728         ut_params->auth_xform.next = &ut_params->cipher_xform;
2729         ut_params->auth_xform.auth.algo = auth_algo;
2730         ut_params->auth_xform.auth.key.length = key_len;
2731         ut_params->auth_xform.auth.key.data = auth_cipher_key;
2732         ut_params->auth_xform.auth.digest_length = auth_len;
2733         /* Auth IV will be after cipher IV */
2734         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2735         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2736
2737         /* Setup Cipher Parameters */
2738         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2739         ut_params->cipher_xform.next = NULL;
2740         ut_params->cipher_xform.cipher.algo = cipher_algo;
2741         ut_params->cipher_xform.cipher.op = cipher_op;
2742         ut_params->cipher_xform.cipher.key.data = auth_cipher_key;
2743         ut_params->cipher_xform.cipher.key.length = key_len;
2744         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2745         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2746
2747         debug_hexdump(stdout, "key:", key, key_len);
2748
2749         /* Create Crypto session*/
2750         ut_params->sess = rte_cryptodev_sym_session_create(
2751                         ts_params->session_mpool);
2752         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2753
2754         if (cipher_op == RTE_CRYPTO_CIPHER_OP_DECRYPT) {
2755                 ut_params->auth_xform.next = NULL;
2756                 ut_params->cipher_xform.next = &ut_params->auth_xform;
2757                 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2758                                 &ut_params->cipher_xform,
2759                                 ts_params->session_priv_mpool);
2760
2761         } else
2762                 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2763                                 &ut_params->auth_xform,
2764                                 ts_params->session_priv_mpool);
2765
2766         if (status == -ENOTSUP)
2767                 return TEST_SKIPPED;
2768
2769         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2770
2771         return 0;
2772 }
2773
2774 static int
2775 create_wireless_algo_hash_operation(const uint8_t *auth_tag,
2776                 unsigned int auth_tag_len,
2777                 const uint8_t *iv, unsigned int iv_len,
2778                 unsigned int data_pad_len,
2779                 enum rte_crypto_auth_operation op,
2780                 unsigned int auth_len, unsigned int auth_offset)
2781 {
2782         struct crypto_testsuite_params *ts_params = &testsuite_params;
2783
2784         struct crypto_unittest_params *ut_params = &unittest_params;
2785
2786         /* Generate Crypto op data structure */
2787         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2788                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2789         TEST_ASSERT_NOT_NULL(ut_params->op,
2790                 "Failed to allocate pktmbuf offload");
2791
2792         /* Set crypto operation data parameters */
2793         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2794
2795         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2796
2797         /* set crypto operation source mbuf */
2798         sym_op->m_src = ut_params->ibuf;
2799
2800         /* iv */
2801         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2802                         iv, iv_len);
2803         /* digest */
2804         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2805                                         ut_params->ibuf, auth_tag_len);
2806
2807         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2808                                 "no room to append auth tag");
2809         ut_params->digest = sym_op->auth.digest.data;
2810         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2811                         ut_params->ibuf, data_pad_len);
2812         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2813                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2814         else
2815                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2816
2817         debug_hexdump(stdout, "digest:",
2818                 sym_op->auth.digest.data,
2819                 auth_tag_len);
2820
2821         sym_op->auth.data.length = auth_len;
2822         sym_op->auth.data.offset = auth_offset;
2823
2824         return 0;
2825 }
2826
2827 static int
2828 create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata,
2829         enum rte_crypto_auth_operation op)
2830 {
2831         struct crypto_testsuite_params *ts_params = &testsuite_params;
2832         struct crypto_unittest_params *ut_params = &unittest_params;
2833
2834         const uint8_t *auth_tag = tdata->digest.data;
2835         const unsigned int auth_tag_len = tdata->digest.len;
2836         unsigned int plaintext_len = ceil_byte_length(tdata->plaintext.len);
2837         unsigned int data_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2838
2839         const uint8_t *cipher_iv = tdata->cipher_iv.data;
2840         const uint8_t cipher_iv_len = tdata->cipher_iv.len;
2841         const uint8_t *auth_iv = tdata->auth_iv.data;
2842         const uint8_t auth_iv_len = tdata->auth_iv.len;
2843         const unsigned int cipher_len = tdata->validCipherLenInBits.len;
2844         const unsigned int auth_len = tdata->validAuthLenInBits.len;
2845
2846         /* Generate Crypto op data structure */
2847         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2848                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2849         TEST_ASSERT_NOT_NULL(ut_params->op,
2850                         "Failed to allocate pktmbuf offload");
2851         /* Set crypto operation data parameters */
2852         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2853
2854         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2855
2856         /* set crypto operation source mbuf */
2857         sym_op->m_src = ut_params->ibuf;
2858
2859         /* digest */
2860         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2861                         ut_params->ibuf, auth_tag_len);
2862
2863         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2864                         "no room to append auth tag");
2865         ut_params->digest = sym_op->auth.digest.data;
2866         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2867                         ut_params->ibuf, data_pad_len);
2868         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2869                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2870         else
2871                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2872
2873         debug_hexdump(stdout, "digest:",
2874                 sym_op->auth.digest.data,
2875                 auth_tag_len);
2876
2877         /* Copy cipher and auth IVs at the end of the crypto operation */
2878         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2879                                                 IV_OFFSET);
2880         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2881         iv_ptr += cipher_iv_len;
2882         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2883
2884         sym_op->cipher.data.length = cipher_len;
2885         sym_op->cipher.data.offset = 0;
2886         sym_op->auth.data.length = auth_len;
2887         sym_op->auth.data.offset = 0;
2888
2889         return 0;
2890 }
2891
2892 static int
2893 create_zuc_cipher_hash_generate_operation(
2894                 const struct wireless_test_data *tdata)
2895 {
2896         return create_wireless_cipher_hash_operation(tdata,
2897                 RTE_CRYPTO_AUTH_OP_GENERATE);
2898 }
2899
2900 static int
2901 create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
2902                 const unsigned auth_tag_len,
2903                 const uint8_t *auth_iv, uint8_t auth_iv_len,
2904                 unsigned data_pad_len,
2905                 enum rte_crypto_auth_operation op,
2906                 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2907                 const unsigned cipher_len, const unsigned cipher_offset,
2908                 const unsigned auth_len, const unsigned auth_offset)
2909 {
2910         struct crypto_testsuite_params *ts_params = &testsuite_params;
2911         struct crypto_unittest_params *ut_params = &unittest_params;
2912
2913         enum rte_crypto_cipher_algorithm cipher_algo =
2914                         ut_params->cipher_xform.cipher.algo;
2915         enum rte_crypto_auth_algorithm auth_algo =
2916                         ut_params->auth_xform.auth.algo;
2917
2918         /* Generate Crypto op data structure */
2919         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2920                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2921         TEST_ASSERT_NOT_NULL(ut_params->op,
2922                         "Failed to allocate pktmbuf offload");
2923         /* Set crypto operation data parameters */
2924         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2925
2926         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2927
2928         /* set crypto operation source mbuf */
2929         sym_op->m_src = ut_params->ibuf;
2930
2931         /* digest */
2932         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2933                         ut_params->ibuf, auth_tag_len);
2934
2935         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2936                         "no room to append auth tag");
2937         ut_params->digest = sym_op->auth.digest.data;
2938
2939         if (rte_pktmbuf_is_contiguous(ut_params->ibuf)) {
2940                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2941                                 ut_params->ibuf, data_pad_len);
2942         } else {
2943                 struct rte_mbuf *m = ut_params->ibuf;
2944                 unsigned int offset = data_pad_len;
2945
2946                 while (offset > m->data_len && m->next != NULL) {
2947                         offset -= m->data_len;
2948                         m = m->next;
2949                 }
2950                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2951                         m, offset);
2952         }
2953
2954         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2955                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2956         else
2957                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2958
2959         debug_hexdump(stdout, "digest:",
2960                 sym_op->auth.digest.data,
2961                 auth_tag_len);
2962
2963         /* Copy cipher and auth IVs at the end of the crypto operation */
2964         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2965                                                 IV_OFFSET);
2966         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2967         iv_ptr += cipher_iv_len;
2968         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2969
2970         if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
2971                 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
2972                 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
2973                 sym_op->cipher.data.length = cipher_len;
2974                 sym_op->cipher.data.offset = cipher_offset;
2975         } else {
2976                 sym_op->cipher.data.length = cipher_len >> 3;
2977                 sym_op->cipher.data.offset = cipher_offset >> 3;
2978         }
2979
2980         if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
2981                 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
2982                 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
2983                 sym_op->auth.data.length = auth_len;
2984                 sym_op->auth.data.offset = auth_offset;
2985         } else {
2986                 sym_op->auth.data.length = auth_len >> 3;
2987                 sym_op->auth.data.offset = auth_offset >> 3;
2988         }
2989
2990         return 0;
2991 }
2992
2993 static int
2994 create_wireless_algo_auth_cipher_operation(
2995                 const uint8_t *auth_tag, unsigned int auth_tag_len,
2996                 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2997                 const uint8_t *auth_iv, uint8_t auth_iv_len,
2998                 unsigned int data_pad_len,
2999                 unsigned int cipher_len, unsigned int cipher_offset,
3000                 unsigned int auth_len, unsigned int auth_offset,
3001                 uint8_t op_mode, uint8_t do_sgl, uint8_t verify)
3002 {
3003         struct crypto_testsuite_params *ts_params = &testsuite_params;
3004         struct crypto_unittest_params *ut_params = &unittest_params;
3005
3006         enum rte_crypto_cipher_algorithm cipher_algo =
3007                         ut_params->cipher_xform.cipher.algo;
3008         enum rte_crypto_auth_algorithm auth_algo =
3009                         ut_params->auth_xform.auth.algo;
3010
3011         /* Generate Crypto op data structure */
3012         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
3013                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
3014         TEST_ASSERT_NOT_NULL(ut_params->op,
3015                         "Failed to allocate pktmbuf offload");
3016
3017         /* Set crypto operation data parameters */
3018         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
3019
3020         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
3021
3022         /* set crypto operation mbufs */
3023         sym_op->m_src = ut_params->ibuf;
3024         if (op_mode == OUT_OF_PLACE)
3025                 sym_op->m_dst = ut_params->obuf;
3026
3027         /* digest */
3028         if (!do_sgl) {
3029                 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(
3030                         (op_mode == IN_PLACE ?
3031                                 ut_params->ibuf : ut_params->obuf),
3032                         uint8_t *, data_pad_len);
3033                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
3034                         (op_mode == IN_PLACE ?
3035                                 ut_params->ibuf : ut_params->obuf),
3036                         data_pad_len);
3037                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
3038         } else {
3039                 uint16_t remaining_off = (auth_offset >> 3) + (auth_len >> 3);
3040                 struct rte_mbuf *sgl_buf = (op_mode == IN_PLACE ?
3041                                 sym_op->m_src : sym_op->m_dst);
3042                 while (remaining_off >= rte_pktmbuf_data_len(sgl_buf)) {
3043                         remaining_off -= rte_pktmbuf_data_len(sgl_buf);
3044                         sgl_buf = sgl_buf->next;
3045                 }
3046                 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(sgl_buf,
3047                                 uint8_t *, remaining_off);
3048                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(sgl_buf,
3049                                 remaining_off);
3050                 memset(sym_op->auth.digest.data, 0, remaining_off);
3051                 while (sgl_buf->next != NULL) {
3052                         memset(rte_pktmbuf_mtod(sgl_buf, uint8_t *),
3053                                 0, rte_pktmbuf_data_len(sgl_buf));
3054                         sgl_buf = sgl_buf->next;
3055                 }
3056         }
3057
3058         /* Copy digest for the verification */
3059         if (verify)
3060                 memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
3061
3062         /* Copy cipher and auth IVs at the end of the crypto operation */
3063         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(
3064                         ut_params->op, uint8_t *, IV_OFFSET);
3065
3066         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
3067         iv_ptr += cipher_iv_len;
3068         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
3069
3070         /* Only copy over the offset data needed from src to dst in OOP,
3071          * if the auth and cipher offsets are not aligned
3072          */
3073         if (op_mode == OUT_OF_PLACE) {
3074                 if (cipher_offset > auth_offset)
3075                         rte_memcpy(
3076                                 rte_pktmbuf_mtod_offset(
3077                                         sym_op->m_dst,
3078                                         uint8_t *, auth_offset >> 3),
3079                                 rte_pktmbuf_mtod_offset(
3080                                         sym_op->m_src,
3081                                         uint8_t *, auth_offset >> 3),
3082                                 ((cipher_offset >> 3) - (auth_offset >> 3)));
3083         }
3084
3085         if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
3086                 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
3087                 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
3088                 sym_op->cipher.data.length = cipher_len;
3089                 sym_op->cipher.data.offset = cipher_offset;
3090         } else {
3091                 sym_op->cipher.data.length = cipher_len >> 3;
3092                 sym_op->cipher.data.offset = cipher_offset >> 3;
3093         }
3094
3095         if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
3096                 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
3097                 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
3098                 sym_op->auth.data.length = auth_len;
3099                 sym_op->auth.data.offset = auth_offset;
3100         } else {
3101                 sym_op->auth.data.length = auth_len >> 3;
3102                 sym_op->auth.data.offset = auth_offset >> 3;
3103         }
3104
3105         return 0;
3106 }
3107
3108 static int
3109 test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
3110 {
3111         struct crypto_testsuite_params *ts_params = &testsuite_params;
3112         struct crypto_unittest_params *ut_params = &unittest_params;
3113
3114         int retval;
3115         unsigned plaintext_pad_len;
3116         unsigned plaintext_len;
3117         uint8_t *plaintext;
3118         struct rte_cryptodev_info dev_info;
3119
3120         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3121         uint64_t feat_flags = dev_info.feature_flags;
3122
3123         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
3124                         ((tdata->validAuthLenInBits.len % 8) != 0)) {
3125                 printf("Device doesn't support NON-Byte Aligned Data.\n");
3126                 return TEST_SKIPPED;
3127         }
3128
3129         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3130                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3131                 printf("Device doesn't support RAW data-path APIs.\n");
3132                 return TEST_SKIPPED;
3133         }
3134
3135         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3136                 return TEST_SKIPPED;
3137
3138         /* Verify the capabilities */
3139         struct rte_cryptodev_sym_capability_idx cap_idx;
3140         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3141         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
3142         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3143                         &cap_idx) == NULL)
3144                 return TEST_SKIPPED;
3145
3146         /* Create SNOW 3G session */
3147         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3148                         tdata->key.data, tdata->key.len,
3149                         tdata->auth_iv.len, tdata->digest.len,
3150                         RTE_CRYPTO_AUTH_OP_GENERATE,
3151                         RTE_CRYPTO_AUTH_SNOW3G_UIA2);
3152         if (retval < 0)
3153                 return retval;
3154
3155         /* alloc mbuf and set payload */
3156         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3157
3158         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3159         rte_pktmbuf_tailroom(ut_params->ibuf));
3160
3161         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3162         /* Append data which is padded to a multiple of */
3163         /* the algorithms block size */
3164         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3165         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3166                                 plaintext_pad_len);
3167         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3168
3169         /* Create SNOW 3G operation */
3170         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
3171                         tdata->auth_iv.data, tdata->auth_iv.len,
3172                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3173                         tdata->validAuthLenInBits.len,
3174                         0);
3175         if (retval < 0)
3176                 return retval;
3177
3178         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3179                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3180                                 ut_params->op, 0, 1, 1, 0);
3181         else
3182                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3183                                 ut_params->op);
3184         ut_params->obuf = ut_params->op->sym->m_src;
3185         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3186         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3187                         + plaintext_pad_len;
3188
3189         /* Validate obuf */
3190         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3191         ut_params->digest,
3192         tdata->digest.data,
3193         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
3194         "SNOW 3G Generated auth tag not as expected");
3195
3196         return 0;
3197 }
3198
3199 static int
3200 test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
3201 {
3202         struct crypto_testsuite_params *ts_params = &testsuite_params;
3203         struct crypto_unittest_params *ut_params = &unittest_params;
3204
3205         int retval;
3206         unsigned plaintext_pad_len;
3207         unsigned plaintext_len;
3208         uint8_t *plaintext;
3209         struct rte_cryptodev_info dev_info;
3210
3211         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3212         uint64_t feat_flags = dev_info.feature_flags;
3213
3214         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
3215                         ((tdata->validAuthLenInBits.len % 8) != 0)) {
3216                 printf("Device doesn't support NON-Byte Aligned Data.\n");
3217                 return TEST_SKIPPED;
3218         }
3219
3220         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3221                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3222                 printf("Device doesn't support RAW data-path APIs.\n");
3223                 return TEST_SKIPPED;
3224         }
3225
3226         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3227                 return TEST_SKIPPED;
3228
3229         /* Verify the capabilities */
3230         struct rte_cryptodev_sym_capability_idx cap_idx;
3231         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3232         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
3233         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3234                         &cap_idx) == NULL)
3235                 return TEST_SKIPPED;
3236
3237         /* Create SNOW 3G session */
3238         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3239                                 tdata->key.data, tdata->key.len,
3240                                 tdata->auth_iv.len, tdata->digest.len,
3241                                 RTE_CRYPTO_AUTH_OP_VERIFY,
3242                                 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
3243         if (retval < 0)
3244                 return retval;
3245         /* alloc mbuf and set payload */
3246         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3247
3248         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3249         rte_pktmbuf_tailroom(ut_params->ibuf));
3250
3251         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3252         /* Append data which is padded to a multiple of */
3253         /* the algorithms block size */
3254         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3255         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3256                                 plaintext_pad_len);
3257         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3258
3259         /* Create SNOW 3G operation */
3260         retval = create_wireless_algo_hash_operation(tdata->digest.data,
3261                         tdata->digest.len,
3262                         tdata->auth_iv.data, tdata->auth_iv.len,
3263                         plaintext_pad_len,
3264                         RTE_CRYPTO_AUTH_OP_VERIFY,
3265                         tdata->validAuthLenInBits.len,
3266                         0);
3267         if (retval < 0)
3268                 return retval;
3269
3270         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3271                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3272                                 ut_params->op, 0, 1, 1, 0);
3273         else
3274                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3275                                 ut_params->op);
3276         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3277         ut_params->obuf = ut_params->op->sym->m_src;
3278         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3279                                 + plaintext_pad_len;
3280
3281         /* Validate obuf */
3282         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
3283                 return 0;
3284         else
3285                 return -1;
3286
3287         return 0;
3288 }
3289
3290 static int
3291 test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
3292 {
3293         struct crypto_testsuite_params *ts_params = &testsuite_params;
3294         struct crypto_unittest_params *ut_params = &unittest_params;
3295
3296         int retval;
3297         unsigned plaintext_pad_len;
3298         unsigned plaintext_len;
3299         uint8_t *plaintext;
3300         struct rte_cryptodev_info dev_info;
3301
3302         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3303         uint64_t feat_flags = dev_info.feature_flags;
3304
3305         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3306                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3307                 printf("Device doesn't support RAW data-path APIs.\n");
3308                 return TEST_SKIPPED;
3309         }
3310
3311         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3312                 return TEST_SKIPPED;
3313
3314         /* Verify the capabilities */
3315         struct rte_cryptodev_sym_capability_idx cap_idx;
3316         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3317         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
3318         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3319                         &cap_idx) == NULL)
3320                 return TEST_SKIPPED;
3321
3322         /* Create KASUMI session */
3323         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3324                         tdata->key.data, tdata->key.len,
3325                         0, tdata->digest.len,
3326                         RTE_CRYPTO_AUTH_OP_GENERATE,
3327                         RTE_CRYPTO_AUTH_KASUMI_F9);
3328         if (retval < 0)
3329                 return retval;
3330
3331         /* alloc mbuf and set payload */
3332         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3333
3334         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3335         rte_pktmbuf_tailroom(ut_params->ibuf));
3336
3337         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3338         /* Append data which is padded to a multiple of */
3339         /* the algorithms block size */
3340         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3341         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3342                                 plaintext_pad_len);
3343         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3344
3345         /* Create KASUMI operation */
3346         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
3347                         NULL, 0,
3348                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3349                         tdata->plaintext.len,
3350                         0);
3351         if (retval < 0)
3352                 return retval;
3353
3354         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3355                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
3356                         ut_params->op);
3357         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3358                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3359                                 ut_params->op, 0, 1, 1, 0);
3360         else
3361                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3362                         ut_params->op);
3363
3364         ut_params->obuf = ut_params->op->sym->m_src;
3365         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3366         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3367                         + plaintext_pad_len;
3368
3369         /* Validate obuf */
3370         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3371         ut_params->digest,
3372         tdata->digest.data,
3373         DIGEST_BYTE_LENGTH_KASUMI_F9,
3374         "KASUMI Generated auth tag not as expected");
3375
3376         return 0;
3377 }
3378
3379 static int
3380 test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
3381 {
3382         struct crypto_testsuite_params *ts_params = &testsuite_params;
3383         struct crypto_unittest_params *ut_params = &unittest_params;
3384
3385         int retval;
3386         unsigned plaintext_pad_len;
3387         unsigned plaintext_len;
3388         uint8_t *plaintext;
3389         struct rte_cryptodev_info dev_info;
3390
3391         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3392         uint64_t feat_flags = dev_info.feature_flags;
3393
3394         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3395                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3396                 printf("Device doesn't support RAW data-path APIs.\n");
3397                 return TEST_SKIPPED;
3398         }
3399
3400         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3401                 return TEST_SKIPPED;
3402
3403         /* Verify the capabilities */
3404         struct rte_cryptodev_sym_capability_idx cap_idx;
3405         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3406         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
3407         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3408                         &cap_idx) == NULL)
3409                 return TEST_SKIPPED;
3410
3411         /* Create KASUMI session */
3412         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3413                                 tdata->key.data, tdata->key.len,
3414                                 0, tdata->digest.len,
3415                                 RTE_CRYPTO_AUTH_OP_VERIFY,
3416                                 RTE_CRYPTO_AUTH_KASUMI_F9);
3417         if (retval < 0)
3418                 return retval;
3419         /* alloc mbuf and set payload */
3420         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3421
3422         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3423         rte_pktmbuf_tailroom(ut_params->ibuf));
3424
3425         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3426         /* Append data which is padded to a multiple */
3427         /* of the algorithms block size */
3428         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3429         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3430                                 plaintext_pad_len);
3431         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3432
3433         /* Create KASUMI operation */
3434         retval = create_wireless_algo_hash_operation(tdata->digest.data,
3435                         tdata->digest.len,
3436                         NULL, 0,
3437                         plaintext_pad_len,
3438                         RTE_CRYPTO_AUTH_OP_VERIFY,
3439                         tdata->plaintext.len,
3440                         0);
3441         if (retval < 0)
3442                 return retval;
3443
3444         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3445                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3446                                 ut_params->op, 0, 1, 1, 0);
3447         else
3448                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3449                                 ut_params->op);
3450         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3451         ut_params->obuf = ut_params->op->sym->m_src;
3452         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3453                                 + plaintext_pad_len;
3454
3455         /* Validate obuf */
3456         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
3457                 return 0;
3458         else
3459                 return -1;
3460
3461         return 0;
3462 }
3463
3464 static int
3465 test_snow3g_hash_generate_test_case_1(void)
3466 {
3467         return test_snow3g_authentication(&snow3g_hash_test_case_1);
3468 }
3469
3470 static int
3471 test_snow3g_hash_generate_test_case_2(void)
3472 {
3473         return test_snow3g_authentication(&snow3g_hash_test_case_2);
3474 }
3475
3476 static int
3477 test_snow3g_hash_generate_test_case_3(void)
3478 {
3479         return test_snow3g_authentication(&snow3g_hash_test_case_3);
3480 }
3481
3482 static int
3483 test_snow3g_hash_generate_test_case_4(void)
3484 {
3485         return test_snow3g_authentication(&snow3g_hash_test_case_4);
3486 }
3487
3488 static int
3489 test_snow3g_hash_generate_test_case_5(void)
3490 {
3491         return test_snow3g_authentication(&snow3g_hash_test_case_5);
3492 }
3493
3494 static int
3495 test_snow3g_hash_generate_test_case_6(void)
3496 {
3497         return test_snow3g_authentication(&snow3g_hash_test_case_6);
3498 }
3499
3500 static int
3501 test_snow3g_hash_verify_test_case_1(void)
3502 {
3503         return test_snow3g_authentication_verify(&snow3g_hash_test_case_1);
3504
3505 }
3506
3507 static int
3508 test_snow3g_hash_verify_test_case_2(void)
3509 {
3510         return test_snow3g_authentication_verify(&snow3g_hash_test_case_2);
3511 }
3512
3513 static int
3514 test_snow3g_hash_verify_test_case_3(void)
3515 {
3516         return test_snow3g_authentication_verify(&snow3g_hash_test_case_3);
3517 }
3518
3519 static int
3520 test_snow3g_hash_verify_test_case_4(void)
3521 {
3522         return test_snow3g_authentication_verify(&snow3g_hash_test_case_4);
3523 }
3524
3525 static int
3526 test_snow3g_hash_verify_test_case_5(void)
3527 {
3528         return test_snow3g_authentication_verify(&snow3g_hash_test_case_5);
3529 }
3530
3531 static int
3532 test_snow3g_hash_verify_test_case_6(void)
3533 {
3534         return test_snow3g_authentication_verify(&snow3g_hash_test_case_6);
3535 }
3536
3537 static int
3538 test_kasumi_hash_generate_test_case_1(void)
3539 {
3540         return test_kasumi_authentication(&kasumi_hash_test_case_1);
3541 }
3542
3543 static int
3544 test_kasumi_hash_generate_test_case_2(void)
3545 {
3546         return test_kasumi_authentication(&kasumi_hash_test_case_2);
3547 }
3548
3549 static int
3550 test_kasumi_hash_generate_test_case_3(void)
3551 {
3552         return test_kasumi_authentication(&kasumi_hash_test_case_3);
3553 }
3554
3555 static int
3556 test_kasumi_hash_generate_test_case_4(void)
3557 {
3558         return test_kasumi_authentication(&kasumi_hash_test_case_4);
3559 }
3560
3561 static int
3562 test_kasumi_hash_generate_test_case_5(void)
3563 {
3564         return test_kasumi_authentication(&kasumi_hash_test_case_5);
3565 }
3566
3567 static int
3568 test_kasumi_hash_generate_test_case_6(void)
3569 {
3570         return test_kasumi_authentication(&kasumi_hash_test_case_6);
3571 }
3572
3573 static int
3574 test_kasumi_hash_verify_test_case_1(void)
3575 {
3576         return test_kasumi_authentication_verify(&kasumi_hash_test_case_1);
3577 }
3578
3579 static int
3580 test_kasumi_hash_verify_test_case_2(void)
3581 {
3582         return test_kasumi_authentication_verify(&kasumi_hash_test_case_2);
3583 }
3584
3585 static int
3586 test_kasumi_hash_verify_test_case_3(void)
3587 {
3588         return test_kasumi_authentication_verify(&kasumi_hash_test_case_3);
3589 }
3590
3591 static int
3592 test_kasumi_hash_verify_test_case_4(void)
3593 {
3594         return test_kasumi_authentication_verify(&kasumi_hash_test_case_4);
3595 }
3596
3597 static int
3598 test_kasumi_hash_verify_test_case_5(void)
3599 {
3600         return test_kasumi_authentication_verify(&kasumi_hash_test_case_5);
3601 }
3602
3603 static int
3604 test_kasumi_encryption(const struct kasumi_test_data *tdata)
3605 {
3606         struct crypto_testsuite_params *ts_params = &testsuite_params;
3607         struct crypto_unittest_params *ut_params = &unittest_params;
3608
3609         int retval;
3610         uint8_t *plaintext, *ciphertext;
3611         unsigned plaintext_pad_len;
3612         unsigned plaintext_len;
3613         struct rte_cryptodev_info dev_info;
3614
3615         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3616         uint64_t feat_flags = dev_info.feature_flags;
3617
3618         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3619                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3620                 printf("Device doesn't support RAW data-path APIs.\n");
3621                 return TEST_SKIPPED;
3622         }
3623
3624         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3625                 return TEST_SKIPPED;
3626
3627         /* Verify the capabilities */
3628         struct rte_cryptodev_sym_capability_idx cap_idx;
3629         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3630         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3631         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3632                         &cap_idx) == NULL)
3633                 return TEST_SKIPPED;
3634
3635         /* Create KASUMI session */
3636         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3637                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3638                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3639                                         tdata->key.data, tdata->key.len,
3640                                         tdata->cipher_iv.len);
3641         if (retval < 0)
3642                 return retval;
3643
3644         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3645
3646         /* Clear mbuf payload */
3647         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3648                rte_pktmbuf_tailroom(ut_params->ibuf));
3649
3650         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3651         /* Append data which is padded to a multiple */
3652         /* of the algorithms block size */
3653         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3654         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3655                                 plaintext_pad_len);
3656         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3657
3658         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3659
3660         /* Create KASUMI operation */
3661         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3662                                 tdata->cipher_iv.len,
3663                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3664                                 tdata->validCipherOffsetInBits.len);
3665         if (retval < 0)
3666                 return retval;
3667
3668         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3669                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3670                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
3671         else
3672                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3673                                 ut_params->op);
3674         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3675
3676         ut_params->obuf = ut_params->op->sym->m_dst;
3677         if (ut_params->obuf)
3678                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3679         else
3680                 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3681
3682         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3683
3684         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3685                                 (tdata->validCipherOffsetInBits.len >> 3);
3686         /* Validate obuf */
3687         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3688                 ciphertext,
3689                 reference_ciphertext,
3690                 tdata->validCipherLenInBits.len,
3691                 "KASUMI Ciphertext data not as expected");
3692         return 0;
3693 }
3694
3695 static int
3696 test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
3697 {
3698         struct crypto_testsuite_params *ts_params = &testsuite_params;
3699         struct crypto_unittest_params *ut_params = &unittest_params;
3700
3701         int retval;
3702
3703         unsigned int plaintext_pad_len;
3704         unsigned int plaintext_len;
3705
3706         uint8_t buffer[10000];
3707         const uint8_t *ciphertext;
3708
3709         struct rte_cryptodev_info dev_info;
3710
3711         /* Verify the capabilities */
3712         struct rte_cryptodev_sym_capability_idx cap_idx;
3713         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3714         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3715         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3716                         &cap_idx) == NULL)
3717                 return TEST_SKIPPED;
3718
3719         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3720
3721         uint64_t feat_flags = dev_info.feature_flags;
3722
3723         if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
3724                 printf("Device doesn't support in-place scatter-gather. "
3725                                 "Test Skipped.\n");
3726                 return TEST_SKIPPED;
3727         }
3728
3729         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3730                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3731                 printf("Device doesn't support RAW data-path APIs.\n");
3732                 return TEST_SKIPPED;
3733         }
3734
3735         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3736                 return TEST_SKIPPED;
3737
3738         /* Create KASUMI session */
3739         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3740                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3741                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3742                                         tdata->key.data, tdata->key.len,
3743                                         tdata->cipher_iv.len);
3744         if (retval < 0)
3745                 return retval;
3746
3747         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3748
3749
3750         /* Append data which is padded to a multiple */
3751         /* of the algorithms block size */
3752         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3753
3754         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3755                         plaintext_pad_len, 10, 0);
3756
3757         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3758
3759         /* Create KASUMI operation */
3760         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3761                                 tdata->cipher_iv.len,
3762                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3763                                 tdata->validCipherOffsetInBits.len);
3764         if (retval < 0)
3765                 return retval;
3766
3767         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3768                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3769                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
3770         else
3771                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3772                                                 ut_params->op);
3773         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3774
3775         ut_params->obuf = ut_params->op->sym->m_dst;
3776
3777         if (ut_params->obuf)
3778                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3779                                 plaintext_len, buffer);
3780         else
3781                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3782                                 tdata->validCipherOffsetInBits.len >> 3,
3783                                 plaintext_len, buffer);
3784
3785         /* Validate obuf */
3786         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3787
3788         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3789                                 (tdata->validCipherOffsetInBits.len >> 3);
3790         /* Validate obuf */
3791         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3792                 ciphertext,
3793                 reference_ciphertext,
3794                 tdata->validCipherLenInBits.len,
3795                 "KASUMI Ciphertext data not as expected");
3796         return 0;
3797 }
3798
3799 static int
3800 test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
3801 {
3802         struct crypto_testsuite_params *ts_params = &testsuite_params;
3803         struct crypto_unittest_params *ut_params = &unittest_params;
3804
3805         int retval;
3806         uint8_t *plaintext, *ciphertext;
3807         unsigned plaintext_pad_len;
3808         unsigned plaintext_len;
3809
3810         /* Verify the capabilities */
3811         struct rte_cryptodev_sym_capability_idx cap_idx;
3812         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3813         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3814         /* Data-path service does not support OOP */
3815         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3816                         &cap_idx) == NULL)
3817                 return TEST_SKIPPED;
3818
3819         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3820                 return TEST_SKIPPED;
3821
3822         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3823                 return TEST_SKIPPED;
3824
3825         /* Create KASUMI session */
3826         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3827                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3828                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3829                                         tdata->key.data, tdata->key.len,
3830                                         tdata->cipher_iv.len);
3831         if (retval < 0)
3832                 return retval;
3833
3834         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3835         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3836
3837         /* Clear mbuf payload */
3838         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3839                rte_pktmbuf_tailroom(ut_params->ibuf));
3840
3841         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3842         /* Append data which is padded to a multiple */
3843         /* of the algorithms block size */
3844         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3845         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3846                                 plaintext_pad_len);
3847         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3848         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3849
3850         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3851
3852         /* Create KASUMI operation */
3853         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3854                                 tdata->cipher_iv.len,
3855                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3856                                 tdata->validCipherOffsetInBits.len);
3857         if (retval < 0)
3858                 return retval;
3859
3860         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3861                                                 ut_params->op);
3862         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3863
3864         ut_params->obuf = ut_params->op->sym->m_dst;
3865         if (ut_params->obuf)
3866                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3867         else
3868                 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3869
3870         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3871
3872         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3873                                 (tdata->validCipherOffsetInBits.len >> 3);
3874         /* Validate obuf */
3875         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3876                 ciphertext,
3877                 reference_ciphertext,
3878                 tdata->validCipherLenInBits.len,
3879                 "KASUMI Ciphertext data not as expected");
3880         return 0;
3881 }
3882
3883 static int
3884 test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
3885 {
3886         struct crypto_testsuite_params *ts_params = &testsuite_params;
3887         struct crypto_unittest_params *ut_params = &unittest_params;
3888
3889         int retval;
3890         unsigned int plaintext_pad_len;
3891         unsigned int plaintext_len;
3892
3893         const uint8_t *ciphertext;
3894         uint8_t buffer[2048];
3895
3896         struct rte_cryptodev_info dev_info;
3897
3898         /* Verify the capabilities */
3899         struct rte_cryptodev_sym_capability_idx cap_idx;
3900         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3901         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3902         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3903                         &cap_idx) == NULL)
3904                 return TEST_SKIPPED;
3905
3906         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3907                 return TEST_SKIPPED;
3908
3909         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3910                 return TEST_SKIPPED;
3911
3912         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3913
3914         uint64_t feat_flags = dev_info.feature_flags;
3915         if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
3916                 printf("Device doesn't support out-of-place scatter-gather "
3917                                 "in both input and output mbufs. "
3918                                 "Test Skipped.\n");
3919                 return TEST_SKIPPED;
3920         }
3921
3922         /* Create KASUMI session */
3923         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3924                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3925                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3926                                         tdata->key.data, tdata->key.len,
3927                                         tdata->cipher_iv.len);
3928         if (retval < 0)
3929                 return retval;
3930
3931         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3932         /* Append data which is padded to a multiple */
3933         /* of the algorithms block size */
3934         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3935
3936         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3937                         plaintext_pad_len, 10, 0);
3938         ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
3939                         plaintext_pad_len, 3, 0);
3940
3941         /* Append data which is padded to a multiple */
3942         /* of the algorithms block size */
3943         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3944
3945         /* Create KASUMI operation */
3946         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3947                                 tdata->cipher_iv.len,
3948                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3949                                 tdata->validCipherOffsetInBits.len);
3950         if (retval < 0)
3951                 return retval;
3952
3953         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3954                                                 ut_params->op);
3955         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3956
3957         ut_params->obuf = ut_params->op->sym->m_dst;
3958         if (ut_params->obuf)
3959                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3960                                 plaintext_pad_len, buffer);
3961         else
3962                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3963                                 tdata->validCipherOffsetInBits.len >> 3,
3964                                 plaintext_pad_len, buffer);
3965
3966         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3967                                 (tdata->validCipherOffsetInBits.len >> 3);
3968         /* Validate obuf */
3969         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3970                 ciphertext,
3971                 reference_ciphertext,
3972                 tdata->validCipherLenInBits.len,
3973                 "KASUMI Ciphertext data not as expected");
3974         return 0;
3975 }
3976
3977
3978 static int
3979 test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
3980 {
3981         struct crypto_testsuite_params *ts_params = &testsuite_params;
3982         struct crypto_unittest_params *ut_params = &unittest_params;
3983
3984         int retval;
3985         uint8_t *ciphertext, *plaintext;
3986         unsigned ciphertext_pad_len;
3987         unsigned ciphertext_len;
3988
3989         /* Verify the capabilities */
3990         struct rte_cryptodev_sym_capability_idx cap_idx;
3991         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3992         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3993         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3994                         &cap_idx) == NULL)
3995                 return TEST_SKIPPED;
3996
3997         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3998                 return TEST_SKIPPED;
3999
4000         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4001                 return TEST_SKIPPED;
4002
4003         /* Create KASUMI session */
4004         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4005                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4006                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
4007                                         tdata->key.data, tdata->key.len,
4008                                         tdata->cipher_iv.len);
4009         if (retval < 0)
4010                 return retval;
4011
4012         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4013         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4014
4015         /* Clear mbuf payload */
4016         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4017                rte_pktmbuf_tailroom(ut_params->ibuf));
4018
4019         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4020         /* Append data which is padded to a multiple */
4021         /* of the algorithms block size */
4022         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
4023         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4024                                 ciphertext_pad_len);
4025         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4026         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4027
4028         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4029
4030         /* Create KASUMI operation */
4031         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4032                                 tdata->cipher_iv.len,
4033                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
4034                                 tdata->validCipherOffsetInBits.len);
4035         if (retval < 0)
4036                 return retval;
4037
4038         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4039                                                 ut_params->op);
4040         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4041
4042         ut_params->obuf = ut_params->op->sym->m_dst;
4043         if (ut_params->obuf)
4044                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4045         else
4046                 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
4047
4048         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4049
4050         const uint8_t *reference_plaintext = tdata->plaintext.data +
4051                                 (tdata->validCipherOffsetInBits.len >> 3);
4052         /* Validate obuf */
4053         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4054                 plaintext,
4055                 reference_plaintext,
4056                 tdata->validCipherLenInBits.len,
4057                 "KASUMI Plaintext data not as expected");
4058         return 0;
4059 }
4060
4061 static int
4062 test_kasumi_decryption(const struct kasumi_test_data *tdata)
4063 {
4064         struct crypto_testsuite_params *ts_params = &testsuite_params;
4065         struct crypto_unittest_params *ut_params = &unittest_params;
4066
4067         int retval;
4068         uint8_t *ciphertext, *plaintext;
4069         unsigned ciphertext_pad_len;
4070         unsigned ciphertext_len;
4071         struct rte_cryptodev_info dev_info;
4072
4073         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4074         uint64_t feat_flags = dev_info.feature_flags;
4075
4076         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4077                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4078                 printf("Device doesn't support RAW data-path APIs.\n");
4079                 return TEST_SKIPPED;
4080         }
4081
4082         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4083                 return TEST_SKIPPED;
4084
4085         /* Verify the capabilities */
4086         struct rte_cryptodev_sym_capability_idx cap_idx;
4087         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4088         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
4089         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4090                         &cap_idx) == NULL)
4091                 return TEST_SKIPPED;
4092
4093         /* Create KASUMI session */
4094         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4095                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4096                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
4097                                         tdata->key.data, tdata->key.len,
4098                                         tdata->cipher_iv.len);
4099         if (retval < 0)
4100                 return retval;
4101
4102         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4103
4104         /* Clear mbuf payload */
4105         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4106                rte_pktmbuf_tailroom(ut_params->ibuf));
4107
4108         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4109         /* Append data which is padded to a multiple */
4110         /* of the algorithms block size */
4111         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
4112         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4113                                 ciphertext_pad_len);
4114         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4115
4116         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4117
4118         /* Create KASUMI operation */
4119         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4120                         tdata->cipher_iv.len,
4121                         RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
4122                         tdata->validCipherOffsetInBits.len);
4123         if (retval < 0)
4124                 return retval;
4125
4126         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4127                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4128                                 ut_params->op, 1, 0, 1, 0);
4129         else
4130                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4131                                                 ut_params->op);
4132         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4133
4134         ut_params->obuf = ut_params->op->sym->m_dst;
4135         if (ut_params->obuf)
4136                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4137         else
4138                 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
4139
4140         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4141
4142         const uint8_t *reference_plaintext = tdata->plaintext.data +
4143                                 (tdata->validCipherOffsetInBits.len >> 3);
4144         /* Validate obuf */
4145         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4146                 plaintext,
4147                 reference_plaintext,
4148                 tdata->validCipherLenInBits.len,
4149                 "KASUMI Plaintext data not as expected");
4150         return 0;
4151 }
4152
4153 static int
4154 test_snow3g_encryption(const struct snow3g_test_data *tdata)
4155 {
4156         struct crypto_testsuite_params *ts_params = &testsuite_params;
4157         struct crypto_unittest_params *ut_params = &unittest_params;
4158
4159         int retval;
4160         uint8_t *plaintext, *ciphertext;
4161         unsigned plaintext_pad_len;
4162         unsigned plaintext_len;
4163         struct rte_cryptodev_info dev_info;
4164
4165         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4166         uint64_t feat_flags = dev_info.feature_flags;
4167
4168         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4169                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4170                 printf("Device doesn't support RAW data-path APIs.\n");
4171                 return TEST_SKIPPED;
4172         }
4173
4174         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4175                 return TEST_SKIPPED;
4176
4177         /* Verify the capabilities */
4178         struct rte_cryptodev_sym_capability_idx cap_idx;
4179         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4180         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4181         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4182                         &cap_idx) == NULL)
4183                 return TEST_SKIPPED;
4184
4185         /* Create SNOW 3G session */
4186         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4187                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4188                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4189                                         tdata->key.data, tdata->key.len,
4190                                         tdata->cipher_iv.len);
4191         if (retval < 0)
4192                 return retval;
4193
4194         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4195
4196         /* Clear mbuf payload */
4197         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4198                rte_pktmbuf_tailroom(ut_params->ibuf));
4199
4200         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4201         /* Append data which is padded to a multiple of */
4202         /* the algorithms block size */
4203         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4204         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4205                                 plaintext_pad_len);
4206         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4207
4208         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4209
4210         /* Create SNOW 3G operation */
4211         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4212                                         tdata->cipher_iv.len,
4213                                         tdata->validCipherLenInBits.len,
4214                                         0);
4215         if (retval < 0)
4216                 return retval;
4217
4218         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4219                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4220                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4221         else
4222                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4223                                                 ut_params->op);
4224         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4225
4226         ut_params->obuf = ut_params->op->sym->m_dst;
4227         if (ut_params->obuf)
4228                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4229         else
4230                 ciphertext = plaintext;
4231
4232         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4233
4234         /* Validate obuf */
4235         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4236                 ciphertext,
4237                 tdata->ciphertext.data,
4238                 tdata->validDataLenInBits.len,
4239                 "SNOW 3G Ciphertext data not as expected");
4240         return 0;
4241 }
4242
4243
4244 static int
4245 test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
4246 {
4247         struct crypto_testsuite_params *ts_params = &testsuite_params;
4248         struct crypto_unittest_params *ut_params = &unittest_params;
4249         uint8_t *plaintext, *ciphertext;
4250
4251         int retval;
4252         unsigned plaintext_pad_len;
4253         unsigned plaintext_len;
4254         struct rte_cryptodev_info dev_info;
4255
4256         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4257         uint64_t feat_flags = dev_info.feature_flags;
4258
4259         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4260                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4261                 printf("Device does not support RAW data-path APIs.\n");
4262                 return -ENOTSUP;
4263         }
4264
4265         /* Verify the capabilities */
4266         struct rte_cryptodev_sym_capability_idx cap_idx;
4267         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4268         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4269         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4270                         &cap_idx) == NULL)
4271                 return TEST_SKIPPED;
4272
4273         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4274                 return TEST_SKIPPED;
4275
4276         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4277                 return TEST_SKIPPED;
4278
4279         /* Create SNOW 3G session */
4280         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4281                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4282                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4283                                         tdata->key.data, tdata->key.len,
4284                                         tdata->cipher_iv.len);
4285         if (retval < 0)
4286                 return retval;
4287
4288         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4289         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4290
4291         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4292                         "Failed to allocate input buffer in mempool");
4293         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4294                         "Failed to allocate output buffer in mempool");
4295
4296         /* Clear mbuf payload */
4297         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4298                rte_pktmbuf_tailroom(ut_params->ibuf));
4299
4300         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4301         /* Append data which is padded to a multiple of */
4302         /* the algorithms block size */
4303         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4304         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4305                                 plaintext_pad_len);
4306         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4307         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4308
4309         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4310
4311         /* Create SNOW 3G operation */
4312         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4313                                         tdata->cipher_iv.len,
4314                                         tdata->validCipherLenInBits.len,
4315                                         0);
4316         if (retval < 0)
4317                 return retval;
4318
4319         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4320                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4321                         ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4322         else
4323                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4324                                                 ut_params->op);
4325         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4326
4327         ut_params->obuf = ut_params->op->sym->m_dst;
4328         if (ut_params->obuf)
4329                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4330         else
4331                 ciphertext = plaintext;
4332
4333         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4334
4335         /* Validate obuf */
4336         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4337                 ciphertext,
4338                 tdata->ciphertext.data,
4339                 tdata->validDataLenInBits.len,
4340                 "SNOW 3G Ciphertext data not as expected");
4341         return 0;
4342 }
4343
4344 static int
4345 test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
4346 {
4347         struct crypto_testsuite_params *ts_params = &testsuite_params;
4348         struct crypto_unittest_params *ut_params = &unittest_params;
4349
4350         int retval;
4351         unsigned int plaintext_pad_len;
4352         unsigned int plaintext_len;
4353         uint8_t buffer[10000];
4354         const uint8_t *ciphertext;
4355
4356         struct rte_cryptodev_info dev_info;
4357
4358         /* Verify the capabilities */
4359         struct rte_cryptodev_sym_capability_idx cap_idx;
4360         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4361         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4362         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4363                         &cap_idx) == NULL)
4364                 return TEST_SKIPPED;
4365
4366         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4367                 return TEST_SKIPPED;
4368
4369         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4370                 return TEST_SKIPPED;
4371
4372         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4373
4374         uint64_t feat_flags = dev_info.feature_flags;
4375
4376         if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
4377                 printf("Device doesn't support out-of-place scatter-gather "
4378                                 "in both input and output mbufs. "
4379                                 "Test Skipped.\n");
4380                 return TEST_SKIPPED;
4381         }
4382
4383         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4384                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4385                 printf("Device does not support RAW data-path APIs.\n");
4386                 return -ENOTSUP;
4387         }
4388
4389         /* Create SNOW 3G session */
4390         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4391                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4392                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4393                                         tdata->key.data, tdata->key.len,
4394                                         tdata->cipher_iv.len);
4395         if (retval < 0)
4396                 return retval;
4397
4398         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4399         /* Append data which is padded to a multiple of */
4400         /* the algorithms block size */
4401         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4402
4403         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
4404                         plaintext_pad_len, 10, 0);
4405         ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
4406                         plaintext_pad_len, 3, 0);
4407
4408         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4409                         "Failed to allocate input buffer in mempool");
4410         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4411                         "Failed to allocate output buffer in mempool");
4412
4413         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
4414
4415         /* Create SNOW 3G operation */
4416         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4417                                         tdata->cipher_iv.len,
4418                                         tdata->validCipherLenInBits.len,
4419                                         0);
4420         if (retval < 0)
4421                 return retval;
4422
4423         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4424                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4425                         ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4426         else
4427                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4428                                                 ut_params->op);
4429         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4430
4431         ut_params->obuf = ut_params->op->sym->m_dst;
4432         if (ut_params->obuf)
4433                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
4434                                 plaintext_len, buffer);
4435         else
4436                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
4437                                 plaintext_len, buffer);
4438
4439         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4440
4441         /* Validate obuf */
4442         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4443                 ciphertext,
4444                 tdata->ciphertext.data,
4445                 tdata->validDataLenInBits.len,
4446                 "SNOW 3G Ciphertext data not as expected");
4447
4448         return 0;
4449 }
4450
4451 /* Shift right a buffer by "offset" bits, "offset" < 8 */
4452 static void
4453 buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset)
4454 {
4455         uint8_t curr_byte, prev_byte;
4456         uint32_t length_in_bytes = ceil_byte_length(length + offset);
4457         uint8_t lower_byte_mask = (1 << offset) - 1;
4458         unsigned i;
4459
4460         prev_byte = buffer[0];
4461         buffer[0] >>= offset;
4462
4463         for (i = 1; i < length_in_bytes; i++) {
4464                 curr_byte = buffer[i];
4465                 buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) |
4466                                 (curr_byte >> offset);
4467                 prev_byte = curr_byte;
4468         }
4469 }
4470
4471 static int
4472 test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
4473 {
4474         struct crypto_testsuite_params *ts_params = &testsuite_params;
4475         struct crypto_unittest_params *ut_params = &unittest_params;
4476         uint8_t *plaintext, *ciphertext;
4477         int retval;
4478         uint32_t plaintext_len;
4479         uint32_t plaintext_pad_len;
4480         uint8_t extra_offset = 4;
4481         uint8_t *expected_ciphertext_shifted;
4482         struct rte_cryptodev_info dev_info;
4483
4484         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4485         uint64_t feat_flags = dev_info.feature_flags;
4486
4487         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
4488                         ((tdata->validDataLenInBits.len % 8) != 0)) {
4489                 printf("Device doesn't support NON-Byte Aligned Data.\n");
4490                 return TEST_SKIPPED;
4491         }
4492
4493         /* Verify the capabilities */
4494         struct rte_cryptodev_sym_capability_idx cap_idx;
4495         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4496         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4497         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4498                         &cap_idx) == NULL)
4499                 return TEST_SKIPPED;
4500
4501         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4502                 return TEST_SKIPPED;
4503
4504         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4505                 return TEST_SKIPPED;
4506
4507         /* Create SNOW 3G session */
4508         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4509                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4510                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4511                                         tdata->key.data, tdata->key.len,
4512                                         tdata->cipher_iv.len);
4513         if (retval < 0)
4514                 return retval;
4515
4516         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4517         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4518
4519         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4520                         "Failed to allocate input buffer in mempool");
4521         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4522                         "Failed to allocate output buffer in mempool");
4523
4524         /* Clear mbuf payload */
4525         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4526                rte_pktmbuf_tailroom(ut_params->ibuf));
4527
4528         plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset);
4529         /*
4530          * Append data which is padded to a
4531          * multiple of the algorithms block size
4532          */
4533         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4534
4535         plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf,
4536                                                 plaintext_pad_len);
4537
4538         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4539
4540         memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3));
4541         buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset);
4542
4543 #ifdef RTE_APP_TEST_DEBUG
4544         rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
4545 #endif
4546         /* Create SNOW 3G operation */
4547         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4548                                         tdata->cipher_iv.len,
4549                                         tdata->validCipherLenInBits.len,
4550                                         extra_offset);
4551         if (retval < 0)
4552                 return retval;
4553
4554         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4555                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4556                         ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4557         else
4558                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4559                                                 ut_params->op);
4560         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4561
4562         ut_params->obuf = ut_params->op->sym->m_dst;
4563         if (ut_params->obuf)
4564                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4565         else
4566                 ciphertext = plaintext;
4567
4568 #ifdef RTE_APP_TEST_DEBUG
4569         rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4570 #endif
4571
4572         expected_ciphertext_shifted = rte_malloc(NULL, plaintext_len, 8);
4573
4574         TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted,
4575                         "failed to reserve memory for ciphertext shifted\n");
4576
4577         memcpy(expected_ciphertext_shifted, tdata->ciphertext.data,
4578                         ceil_byte_length(tdata->ciphertext.len));
4579         buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len,
4580                         extra_offset);
4581         /* Validate obuf */
4582         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
4583                 ciphertext,
4584                 expected_ciphertext_shifted,
4585                 tdata->validDataLenInBits.len,
4586                 extra_offset,
4587                 "SNOW 3G Ciphertext data not as expected");
4588         return 0;
4589 }
4590
4591 static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
4592 {
4593         struct crypto_testsuite_params *ts_params = &testsuite_params;
4594         struct crypto_unittest_params *ut_params = &unittest_params;
4595
4596         int retval;
4597
4598         uint8_t *plaintext, *ciphertext;
4599         unsigned ciphertext_pad_len;
4600         unsigned ciphertext_len;
4601         struct rte_cryptodev_info dev_info;
4602
4603         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4604         uint64_t feat_flags = dev_info.feature_flags;
4605
4606         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4607                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4608                 printf("Device doesn't support RAW data-path APIs.\n");
4609                 return TEST_SKIPPED;
4610         }
4611
4612         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4613                 return TEST_SKIPPED;
4614
4615         /* Verify the capabilities */
4616         struct rte_cryptodev_sym_capability_idx cap_idx;
4617         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4618         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4619         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4620                         &cap_idx) == NULL)
4621                 return TEST_SKIPPED;
4622
4623         /* Create SNOW 3G session */
4624         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4625                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4626                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4627                                         tdata->key.data, tdata->key.len,
4628                                         tdata->cipher_iv.len);
4629         if (retval < 0)
4630                 return retval;
4631
4632         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4633
4634         /* Clear mbuf payload */
4635         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4636                rte_pktmbuf_tailroom(ut_params->ibuf));
4637
4638         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4639         /* Append data which is padded to a multiple of */
4640         /* the algorithms block size */
4641         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4642         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4643                                 ciphertext_pad_len);
4644         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4645
4646         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4647
4648         /* Create SNOW 3G operation */
4649         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4650                                         tdata->cipher_iv.len,
4651                                         tdata->validCipherLenInBits.len,
4652                                         tdata->cipher.offset_bits);
4653         if (retval < 0)
4654                 return retval;
4655
4656         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4657                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4658                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4659         else
4660                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4661                                                 ut_params->op);
4662         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4663         ut_params->obuf = ut_params->op->sym->m_dst;
4664         if (ut_params->obuf)
4665                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4666         else
4667                 plaintext = ciphertext;
4668
4669         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4670
4671         /* Validate obuf */
4672         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4673                                 tdata->plaintext.data,
4674                                 tdata->validDataLenInBits.len,
4675                                 "SNOW 3G Plaintext data not as expected");
4676         return 0;
4677 }
4678
4679 static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
4680 {
4681         struct crypto_testsuite_params *ts_params = &testsuite_params;
4682         struct crypto_unittest_params *ut_params = &unittest_params;
4683
4684         int retval;
4685
4686         uint8_t *plaintext, *ciphertext;
4687         unsigned ciphertext_pad_len;
4688         unsigned ciphertext_len;
4689         struct rte_cryptodev_info dev_info;
4690
4691         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4692         uint64_t feat_flags = dev_info.feature_flags;
4693
4694         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4695                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4696                 printf("Device does not support RAW data-path APIs.\n");
4697                 return -ENOTSUP;
4698         }
4699         /* Verify the capabilities */
4700         struct rte_cryptodev_sym_capability_idx cap_idx;
4701         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4702         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4703         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4704                         &cap_idx) == NULL)
4705                 return TEST_SKIPPED;
4706
4707         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4708                 return TEST_SKIPPED;
4709
4710         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4711                 return TEST_SKIPPED;
4712
4713         /* Create SNOW 3G session */
4714         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4715                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4716                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4717                                         tdata->key.data, tdata->key.len,
4718                                         tdata->cipher_iv.len);
4719         if (retval < 0)
4720                 return retval;
4721
4722         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4723         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4724
4725         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4726                         "Failed to allocate input buffer");
4727         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4728                         "Failed to allocate output buffer");
4729
4730         /* Clear mbuf payload */
4731         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4732                rte_pktmbuf_tailroom(ut_params->ibuf));
4733
4734         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
4735                        rte_pktmbuf_tailroom(ut_params->obuf));
4736
4737         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4738         /* Append data which is padded to a multiple of */
4739         /* the algorithms block size */
4740         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4741         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4742                                 ciphertext_pad_len);
4743         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4744         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4745
4746         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4747
4748         /* Create SNOW 3G operation */
4749         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4750                                         tdata->cipher_iv.len,
4751                                         tdata->validCipherLenInBits.len,
4752                                         0);
4753         if (retval < 0)
4754                 return retval;
4755
4756         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4757                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4758                         ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4759         else
4760                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4761                                                 ut_params->op);
4762         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4763         ut_params->obuf = ut_params->op->sym->m_dst;
4764         if (ut_params->obuf)
4765                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4766         else
4767                 plaintext = ciphertext;
4768
4769         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4770
4771         /* Validate obuf */
4772         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4773                                 tdata->plaintext.data,
4774                                 tdata->validDataLenInBits.len,
4775                                 "SNOW 3G Plaintext data not as expected");
4776         return 0;
4777 }
4778
4779 static int
4780 test_zuc_cipher_auth(const struct wireless_test_data *tdata)
4781 {
4782         struct crypto_testsuite_params *ts_params = &testsuite_params;
4783         struct crypto_unittest_params *ut_params = &unittest_params;
4784
4785         int retval;
4786
4787         uint8_t *plaintext, *ciphertext;
4788         unsigned int plaintext_pad_len;
4789         unsigned int plaintext_len;
4790
4791         struct rte_cryptodev_info dev_info;
4792         struct rte_cryptodev_sym_capability_idx cap_idx;
4793
4794         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4795         uint64_t feat_flags = dev_info.feature_flags;
4796
4797         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
4798                         ((tdata->validAuthLenInBits.len % 8 != 0) ||
4799                         (tdata->validDataLenInBits.len % 8 != 0))) {
4800                 printf("Device doesn't support NON-Byte Aligned Data.\n");
4801                 return TEST_SKIPPED;
4802         }
4803
4804         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4805                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4806                 printf("Device doesn't support RAW data-path APIs.\n");
4807                 return TEST_SKIPPED;
4808         }
4809
4810         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4811                 return TEST_SKIPPED;
4812
4813         /* Check if device supports ZUC EEA3 */
4814         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4815         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
4816
4817         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4818                         &cap_idx) == NULL)
4819                 return TEST_SKIPPED;
4820
4821         /* Check if device supports ZUC EIA3 */
4822         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4823         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
4824
4825         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4826                         &cap_idx) == NULL)
4827                 return TEST_SKIPPED;
4828
4829         /* Create ZUC session */
4830         retval = create_zuc_cipher_auth_encrypt_generate_session(
4831                         ts_params->valid_devs[0],
4832                         tdata);
4833         if (retval != 0)
4834                 return retval;
4835         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4836
4837         /* clear mbuf payload */
4838         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4839                         rte_pktmbuf_tailroom(ut_params->ibuf));
4840
4841         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4842         /* Append data which is padded to a multiple of */
4843         /* the algorithms block size */
4844         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4845         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4846                                 plaintext_pad_len);
4847         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4848
4849         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4850
4851         /* Create ZUC operation */
4852         retval = create_zuc_cipher_hash_generate_operation(tdata);
4853         if (retval < 0)
4854                 return retval;
4855
4856         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4857                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4858                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4859         else
4860                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4861                         ut_params->op);
4862         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4863         ut_params->obuf = ut_params->op->sym->m_src;
4864         if (ut_params->obuf)
4865                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4866         else
4867                 ciphertext = plaintext;
4868
4869         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4870         /* Validate obuf */
4871         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4872                         ciphertext,
4873                         tdata->ciphertext.data,
4874                         tdata->validDataLenInBits.len,
4875                         "ZUC Ciphertext data not as expected");
4876
4877         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4878             + plaintext_pad_len;
4879
4880         /* Validate obuf */
4881         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4882                         ut_params->digest,
4883                         tdata->digest.data,
4884                         4,
4885                         "ZUC Generated auth tag not as expected");
4886         return 0;
4887 }
4888
4889 static int
4890 test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
4891 {
4892         struct crypto_testsuite_params *ts_params = &testsuite_params;
4893         struct crypto_unittest_params *ut_params = &unittest_params;
4894
4895         int retval;
4896
4897         uint8_t *plaintext, *ciphertext;
4898         unsigned plaintext_pad_len;
4899         unsigned plaintext_len;
4900         struct rte_cryptodev_info dev_info;
4901
4902         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4903         uint64_t feat_flags = dev_info.feature_flags;
4904
4905         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4906                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4907                 printf("Device doesn't support RAW data-path APIs.\n");
4908                 return TEST_SKIPPED;
4909         }
4910
4911         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4912                 return TEST_SKIPPED;
4913
4914         /* Verify the capabilities */
4915         struct rte_cryptodev_sym_capability_idx cap_idx;
4916         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4917         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
4918         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4919                         &cap_idx) == NULL)
4920                 return TEST_SKIPPED;
4921         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4922         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4923         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4924                         &cap_idx) == NULL)
4925                 return TEST_SKIPPED;
4926
4927         /* Create SNOW 3G session */
4928         retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0],
4929                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4930                         RTE_CRYPTO_AUTH_OP_GENERATE,
4931                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4932                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4933                         tdata->key.data, tdata->key.len,
4934                         tdata->auth_iv.len, tdata->digest.len,
4935                         tdata->cipher_iv.len);
4936         if (retval != 0)
4937                 return retval;
4938         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4939
4940         /* clear mbuf payload */
4941         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4942                         rte_pktmbuf_tailroom(ut_params->ibuf));
4943
4944         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4945         /* Append data which is padded to a multiple of */
4946         /* the algorithms block size */
4947         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4948         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4949                                 plaintext_pad_len);
4950         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4951
4952         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4953
4954         /* Create SNOW 3G operation */
4955         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
4956                         tdata->digest.len, tdata->auth_iv.data,
4957                         tdata->auth_iv.len,
4958                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
4959                         tdata->cipher_iv.data, tdata->cipher_iv.len,
4960                         tdata->validCipherLenInBits.len,
4961                         0,
4962                         tdata->validAuthLenInBits.len,
4963                         0
4964                         );
4965         if (retval < 0)
4966                 return retval;
4967
4968         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4969                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4970                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4971         else
4972                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4973                         ut_params->op);
4974         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4975         ut_params->obuf = ut_params->op->sym->m_src;
4976         if (ut_params->obuf)
4977                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4978         else
4979                 ciphertext = plaintext;
4980
4981         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4982         /* Validate obuf */
4983         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4984                         ciphertext,
4985                         tdata->ciphertext.data,
4986                         tdata->validDataLenInBits.len,
4987                         "SNOW 3G Ciphertext data not as expected");
4988
4989         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4990             + plaintext_pad_len;
4991
4992         /* Validate obuf */
4993         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4994                         ut_params->digest,
4995                         tdata->digest.data,
4996                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4997                         "SNOW 3G Generated auth tag not as expected");
4998         return 0;
4999 }
5000
5001 static int
5002 test_snow3g_auth_cipher(const struct snow3g_test_data *tdata,
5003         uint8_t op_mode, uint8_t verify)
5004 {
5005         struct crypto_testsuite_params *ts_params = &testsuite_params;
5006         struct crypto_unittest_params *ut_params = &unittest_params;
5007
5008         int retval;
5009
5010         uint8_t *plaintext = NULL, *ciphertext = NULL;
5011         unsigned int plaintext_pad_len;
5012         unsigned int plaintext_len;
5013         unsigned int ciphertext_pad_len;
5014         unsigned int ciphertext_len;
5015
5016         struct rte_cryptodev_info dev_info;
5017
5018         /* Verify the capabilities */
5019         struct rte_cryptodev_sym_capability_idx cap_idx;
5020         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5021         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
5022         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5023                         &cap_idx) == NULL)
5024                 return TEST_SKIPPED;
5025         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5026         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
5027         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5028                         &cap_idx) == NULL)
5029                 return TEST_SKIPPED;
5030
5031         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5032                 return TEST_SKIPPED;
5033
5034         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5035
5036         uint64_t feat_flags = dev_info.feature_flags;
5037
5038         if (op_mode == OUT_OF_PLACE) {
5039                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5040                         printf("Device doesn't support digest encrypted.\n");
5041                         return TEST_SKIPPED;
5042                 }
5043                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5044                         return TEST_SKIPPED;
5045         }
5046
5047         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5048                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5049                 printf("Device doesn't support RAW data-path APIs.\n");
5050                 return TEST_SKIPPED;
5051         }
5052
5053         /* Create SNOW 3G session */
5054         retval = create_wireless_algo_auth_cipher_session(
5055                         ts_params->valid_devs[0],
5056                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5057                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5058                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5059                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5060                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
5061                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
5062                         tdata->key.data, tdata->key.len,
5063                         tdata->auth_iv.len, tdata->digest.len,
5064                         tdata->cipher_iv.len);
5065         if (retval != 0)
5066                 return retval;
5067
5068         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5069         if (op_mode == OUT_OF_PLACE)
5070                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5071
5072         /* clear mbuf payload */
5073         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5074                 rte_pktmbuf_tailroom(ut_params->ibuf));
5075         if (op_mode == OUT_OF_PLACE)
5076                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5077                         rte_pktmbuf_tailroom(ut_params->obuf));
5078
5079         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5080         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5081         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5082         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5083
5084         if (verify) {
5085                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5086                                         ciphertext_pad_len);
5087                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
5088                 if (op_mode == OUT_OF_PLACE)
5089                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
5090                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5091                         ciphertext_len);
5092         } else {
5093                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5094                                         plaintext_pad_len);
5095                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5096                 if (op_mode == OUT_OF_PLACE)
5097                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
5098                 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5099         }
5100
5101         /* Create SNOW 3G operation */
5102         retval = create_wireless_algo_auth_cipher_operation(
5103                 tdata->digest.data, tdata->digest.len,
5104                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5105                 tdata->auth_iv.data, tdata->auth_iv.len,
5106                 (tdata->digest.offset_bytes == 0 ?
5107                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5108                         : tdata->digest.offset_bytes),
5109                 tdata->validCipherLenInBits.len,
5110                 tdata->cipher.offset_bits,
5111                 tdata->validAuthLenInBits.len,
5112                 tdata->auth.offset_bits,
5113                 op_mode, 0, verify);
5114
5115         if (retval < 0)
5116                 return retval;
5117
5118         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5119                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5120                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5121         else
5122                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5123                         ut_params->op);
5124
5125         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5126
5127         ut_params->obuf = (op_mode == IN_PLACE ?
5128                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5129
5130         if (verify) {
5131                 if (ut_params->obuf)
5132                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5133                                                         uint8_t *);
5134                 else
5135                         plaintext = ciphertext +
5136                                 (tdata->cipher.offset_bits >> 3);
5137
5138                 debug_hexdump(stdout, "plaintext:", plaintext,
5139                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5140                 debug_hexdump(stdout, "plaintext expected:",
5141                         tdata->plaintext.data,
5142                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5143         } else {
5144                 if (ut_params->obuf)
5145                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5146                                                         uint8_t *);
5147                 else
5148                         ciphertext = plaintext;
5149
5150                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5151                         ciphertext_len);
5152                 debug_hexdump(stdout, "ciphertext expected:",
5153                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5154
5155                 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5156                         + (tdata->digest.offset_bytes == 0 ?
5157                 plaintext_pad_len : tdata->digest.offset_bytes);
5158
5159                 debug_hexdump(stdout, "digest:", ut_params->digest,
5160                         tdata->digest.len);
5161                 debug_hexdump(stdout, "digest expected:", tdata->digest.data,
5162                                 tdata->digest.len);
5163         }
5164
5165         /* Validate obuf */
5166         if (verify) {
5167                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5168                         plaintext,
5169                         tdata->plaintext.data,
5170                         (tdata->plaintext.len - tdata->cipher.offset_bits -
5171                          (tdata->digest.len << 3)),
5172                         tdata->cipher.offset_bits,
5173                         "SNOW 3G Plaintext data not as expected");
5174         } else {
5175                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5176                         ciphertext,
5177                         tdata->ciphertext.data,
5178                         (tdata->validDataLenInBits.len -
5179                          tdata->cipher.offset_bits),
5180                         tdata->cipher.offset_bits,
5181                         "SNOW 3G Ciphertext data not as expected");
5182
5183                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5184                         ut_params->digest,
5185                         tdata->digest.data,
5186                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5187                         "SNOW 3G Generated auth tag not as expected");
5188         }
5189         return 0;
5190 }
5191
5192 static int
5193 test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata,
5194         uint8_t op_mode, uint8_t verify)
5195 {
5196         struct crypto_testsuite_params *ts_params = &testsuite_params;
5197         struct crypto_unittest_params *ut_params = &unittest_params;
5198
5199         int retval;
5200
5201         const uint8_t *plaintext = NULL;
5202         const uint8_t *ciphertext = NULL;
5203         const uint8_t *digest = NULL;
5204         unsigned int plaintext_pad_len;
5205         unsigned int plaintext_len;
5206         unsigned int ciphertext_pad_len;
5207         unsigned int ciphertext_len;
5208         uint8_t buffer[10000];
5209         uint8_t digest_buffer[10000];
5210
5211         struct rte_cryptodev_info dev_info;
5212
5213         /* Verify the capabilities */
5214         struct rte_cryptodev_sym_capability_idx cap_idx;
5215         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5216         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
5217         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5218                         &cap_idx) == NULL)
5219                 return TEST_SKIPPED;
5220         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5221         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
5222         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5223                         &cap_idx) == NULL)
5224                 return TEST_SKIPPED;
5225
5226         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5227                 return TEST_SKIPPED;
5228
5229         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5230
5231         uint64_t feat_flags = dev_info.feature_flags;
5232
5233         if (op_mode == IN_PLACE) {
5234                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5235                         printf("Device doesn't support in-place scatter-gather "
5236                                         "in both input and output mbufs.\n");
5237                         return TEST_SKIPPED;
5238                 }
5239                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5240                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5241                         printf("Device doesn't support RAW data-path APIs.\n");
5242                         return TEST_SKIPPED;
5243                 }
5244         } else {
5245                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5246                         return TEST_SKIPPED;
5247                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5248                         printf("Device doesn't support out-of-place scatter-gather "
5249                                         "in both input and output mbufs.\n");
5250                         return TEST_SKIPPED;
5251                 }
5252                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5253                         printf("Device doesn't support digest encrypted.\n");
5254                         return TEST_SKIPPED;
5255                 }
5256         }
5257
5258         /* Create SNOW 3G session */
5259         retval = create_wireless_algo_auth_cipher_session(
5260                         ts_params->valid_devs[0],
5261                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5262                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5263                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5264                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5265                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
5266                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
5267                         tdata->key.data, tdata->key.len,
5268                         tdata->auth_iv.len, tdata->digest.len,
5269                         tdata->cipher_iv.len);
5270
5271         if (retval != 0)
5272                 return retval;
5273
5274         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5275         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5276         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5277         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5278
5279         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5280                         plaintext_pad_len, 15, 0);
5281         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5282                         "Failed to allocate input buffer in mempool");
5283
5284         if (op_mode == OUT_OF_PLACE) {
5285                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5286                                 plaintext_pad_len, 15, 0);
5287                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5288                                 "Failed to allocate output buffer in mempool");
5289         }
5290
5291         if (verify) {
5292                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
5293                         tdata->ciphertext.data);
5294                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5295                                         ciphertext_len, buffer);
5296                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5297                         ciphertext_len);
5298         } else {
5299                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5300                         tdata->plaintext.data);
5301                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5302                                         plaintext_len, buffer);
5303                 debug_hexdump(stdout, "plaintext:", plaintext,
5304                         plaintext_len);
5305         }
5306         memset(buffer, 0, sizeof(buffer));
5307
5308         /* Create SNOW 3G operation */
5309         retval = create_wireless_algo_auth_cipher_operation(
5310                 tdata->digest.data, tdata->digest.len,
5311                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5312                 tdata->auth_iv.data, tdata->auth_iv.len,
5313                 (tdata->digest.offset_bytes == 0 ?
5314                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5315                         : tdata->digest.offset_bytes),
5316                 tdata->validCipherLenInBits.len,
5317                 tdata->cipher.offset_bits,
5318                 tdata->validAuthLenInBits.len,
5319                 tdata->auth.offset_bits,
5320                 op_mode, 1, verify);
5321
5322         if (retval < 0)
5323                 return retval;
5324
5325         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5326                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5327                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5328         else
5329                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5330                         ut_params->op);
5331
5332         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5333
5334         ut_params->obuf = (op_mode == IN_PLACE ?
5335                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5336
5337         if (verify) {
5338                 if (ut_params->obuf)
5339                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
5340                                         plaintext_len, buffer);
5341                 else
5342                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5343                                         plaintext_len, buffer);
5344
5345                 debug_hexdump(stdout, "plaintext:", plaintext,
5346                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5347                 debug_hexdump(stdout, "plaintext expected:",
5348                         tdata->plaintext.data,
5349                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5350         } else {
5351                 if (ut_params->obuf)
5352                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
5353                                         ciphertext_len, buffer);
5354                 else
5355                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5356                                         ciphertext_len, buffer);
5357
5358                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5359                         ciphertext_len);
5360                 debug_hexdump(stdout, "ciphertext expected:",
5361                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5362
5363                 if (ut_params->obuf)
5364                         digest = rte_pktmbuf_read(ut_params->obuf,
5365                                 (tdata->digest.offset_bytes == 0 ?
5366                                 plaintext_pad_len : tdata->digest.offset_bytes),
5367                                 tdata->digest.len, digest_buffer);
5368                 else
5369                         digest = rte_pktmbuf_read(ut_params->ibuf,
5370                                 (tdata->digest.offset_bytes == 0 ?
5371                                 plaintext_pad_len : tdata->digest.offset_bytes),
5372                                 tdata->digest.len, digest_buffer);
5373
5374                 debug_hexdump(stdout, "digest:", digest,
5375                         tdata->digest.len);
5376                 debug_hexdump(stdout, "digest expected:",
5377                         tdata->digest.data, tdata->digest.len);
5378         }
5379
5380         /* Validate obuf */
5381         if (verify) {
5382                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5383                         plaintext,
5384                         tdata->plaintext.data,
5385                         (tdata->plaintext.len - tdata->cipher.offset_bits -
5386                          (tdata->digest.len << 3)),
5387                         tdata->cipher.offset_bits,
5388                         "SNOW 3G Plaintext data not as expected");
5389         } else {
5390                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5391                         ciphertext,
5392                         tdata->ciphertext.data,
5393                         (tdata->validDataLenInBits.len -
5394                          tdata->cipher.offset_bits),
5395                         tdata->cipher.offset_bits,
5396                         "SNOW 3G Ciphertext data not as expected");
5397
5398                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5399                         digest,
5400                         tdata->digest.data,
5401                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5402                         "SNOW 3G Generated auth tag not as expected");
5403         }
5404         return 0;
5405 }
5406
5407 static int
5408 test_kasumi_auth_cipher(const struct kasumi_test_data *tdata,
5409         uint8_t op_mode, uint8_t verify)
5410 {
5411         struct crypto_testsuite_params *ts_params = &testsuite_params;
5412         struct crypto_unittest_params *ut_params = &unittest_params;
5413
5414         int retval;
5415
5416         uint8_t *plaintext = NULL, *ciphertext = NULL;
5417         unsigned int plaintext_pad_len;
5418         unsigned int plaintext_len;
5419         unsigned int ciphertext_pad_len;
5420         unsigned int ciphertext_len;
5421
5422         struct rte_cryptodev_info dev_info;
5423
5424         /* Verify the capabilities */
5425         struct rte_cryptodev_sym_capability_idx cap_idx;
5426         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5427         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5428         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5429                         &cap_idx) == NULL)
5430                 return TEST_SKIPPED;
5431         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5432         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5433         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5434                         &cap_idx) == NULL)
5435                 return TEST_SKIPPED;
5436
5437         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5438
5439         uint64_t feat_flags = dev_info.feature_flags;
5440
5441         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5442                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5443                 printf("Device doesn't support RAW data-path APIs.\n");
5444                 return TEST_SKIPPED;
5445         }
5446
5447         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5448                 return TEST_SKIPPED;
5449
5450         if (op_mode == OUT_OF_PLACE) {
5451                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5452                         return TEST_SKIPPED;
5453                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5454                         printf("Device doesn't support digest encrypted.\n");
5455                         return TEST_SKIPPED;
5456                 }
5457         }
5458
5459         /* Create KASUMI session */
5460         retval = create_wireless_algo_auth_cipher_session(
5461                         ts_params->valid_devs[0],
5462                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5463                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5464                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5465                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5466                         RTE_CRYPTO_AUTH_KASUMI_F9,
5467                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5468                         tdata->key.data, tdata->key.len,
5469                         0, tdata->digest.len,
5470                         tdata->cipher_iv.len);
5471
5472         if (retval != 0)
5473                 return retval;
5474
5475         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5476         if (op_mode == OUT_OF_PLACE)
5477                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5478
5479         /* clear mbuf payload */
5480         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5481                 rte_pktmbuf_tailroom(ut_params->ibuf));
5482         if (op_mode == OUT_OF_PLACE)
5483                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5484                         rte_pktmbuf_tailroom(ut_params->obuf));
5485
5486         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5487         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5488         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5489         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5490
5491         if (verify) {
5492                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5493                                         ciphertext_pad_len);
5494                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
5495                 if (op_mode == OUT_OF_PLACE)
5496                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
5497                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5498                         ciphertext_len);
5499         } else {
5500                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5501                                         plaintext_pad_len);
5502                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5503                 if (op_mode == OUT_OF_PLACE)
5504                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
5505                 debug_hexdump(stdout, "plaintext:", plaintext,
5506                         plaintext_len);
5507         }
5508
5509         /* Create KASUMI operation */
5510         retval = create_wireless_algo_auth_cipher_operation(
5511                 tdata->digest.data, tdata->digest.len,
5512                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5513                 NULL, 0,
5514                 (tdata->digest.offset_bytes == 0 ?
5515                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5516                         : tdata->digest.offset_bytes),
5517                 tdata->validCipherLenInBits.len,
5518                 tdata->validCipherOffsetInBits.len,
5519                 tdata->validAuthLenInBits.len,
5520                 0,
5521                 op_mode, 0, verify);
5522
5523         if (retval < 0)
5524                 return retval;
5525
5526         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5527                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5528                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5529         else
5530                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5531                         ut_params->op);
5532
5533         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5534
5535         ut_params->obuf = (op_mode == IN_PLACE ?
5536                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5537
5538
5539         if (verify) {
5540                 if (ut_params->obuf)
5541                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5542                                                         uint8_t *);
5543                 else
5544                         plaintext = ciphertext;
5545
5546                 debug_hexdump(stdout, "plaintext:", plaintext,
5547                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5548                 debug_hexdump(stdout, "plaintext expected:",
5549                         tdata->plaintext.data,
5550                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5551         } else {
5552                 if (ut_params->obuf)
5553                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5554                                                         uint8_t *);
5555                 else
5556                         ciphertext = plaintext;
5557
5558                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5559                         ciphertext_len);
5560                 debug_hexdump(stdout, "ciphertext expected:",
5561                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5562
5563                 ut_params->digest = rte_pktmbuf_mtod(
5564                         ut_params->obuf, uint8_t *) +
5565                         (tdata->digest.offset_bytes == 0 ?
5566                         plaintext_pad_len : tdata->digest.offset_bytes);
5567
5568                 debug_hexdump(stdout, "digest:", ut_params->digest,
5569                         tdata->digest.len);
5570                 debug_hexdump(stdout, "digest expected:",
5571                         tdata->digest.data, tdata->digest.len);
5572         }
5573
5574         /* Validate obuf */
5575         if (verify) {
5576                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5577                         plaintext,
5578                         tdata->plaintext.data,
5579                         tdata->plaintext.len >> 3,
5580                         "KASUMI Plaintext data not as expected");
5581         } else {
5582                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5583                         ciphertext,
5584                         tdata->ciphertext.data,
5585                         tdata->ciphertext.len >> 3,
5586                         "KASUMI Ciphertext data not as expected");
5587
5588                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5589                         ut_params->digest,
5590                         tdata->digest.data,
5591                         DIGEST_BYTE_LENGTH_KASUMI_F9,
5592                         "KASUMI Generated auth tag not as expected");
5593         }
5594         return 0;
5595 }
5596
5597 static int
5598 test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata,
5599         uint8_t op_mode, uint8_t verify)
5600 {
5601         struct crypto_testsuite_params *ts_params = &testsuite_params;
5602         struct crypto_unittest_params *ut_params = &unittest_params;
5603
5604         int retval;
5605
5606         const uint8_t *plaintext = NULL;
5607         const uint8_t *ciphertext = NULL;
5608         const uint8_t *digest = NULL;
5609         unsigned int plaintext_pad_len;
5610         unsigned int plaintext_len;
5611         unsigned int ciphertext_pad_len;
5612         unsigned int ciphertext_len;
5613         uint8_t buffer[10000];
5614         uint8_t digest_buffer[10000];
5615
5616         struct rte_cryptodev_info dev_info;
5617
5618         /* Verify the capabilities */
5619         struct rte_cryptodev_sym_capability_idx cap_idx;
5620         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5621         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5622         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5623                         &cap_idx) == NULL)
5624                 return TEST_SKIPPED;
5625         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5626         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5627         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5628                         &cap_idx) == NULL)
5629                 return TEST_SKIPPED;
5630
5631         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5632                 return TEST_SKIPPED;
5633
5634         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5635
5636         uint64_t feat_flags = dev_info.feature_flags;
5637
5638         if (op_mode == IN_PLACE) {
5639                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5640                         printf("Device doesn't support in-place scatter-gather "
5641                                         "in both input and output mbufs.\n");
5642                         return TEST_SKIPPED;
5643                 }
5644                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5645                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5646                         printf("Device doesn't support RAW data-path APIs.\n");
5647                         return TEST_SKIPPED;
5648                 }
5649         } else {
5650                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5651                         return TEST_SKIPPED;
5652                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5653                         printf("Device doesn't support out-of-place scatter-gather "
5654                                         "in both input and output mbufs.\n");
5655                         return TEST_SKIPPED;
5656                 }
5657                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5658                         printf("Device doesn't support digest encrypted.\n");
5659                         return TEST_SKIPPED;
5660                 }
5661         }
5662
5663         /* Create KASUMI session */
5664         retval = create_wireless_algo_auth_cipher_session(
5665                         ts_params->valid_devs[0],
5666                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5667                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5668                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5669                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5670                         RTE_CRYPTO_AUTH_KASUMI_F9,
5671                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5672                         tdata->key.data, tdata->key.len,
5673                         0, tdata->digest.len,
5674                         tdata->cipher_iv.len);
5675
5676         if (retval != 0)
5677                 return retval;
5678
5679         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5680         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5681         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5682         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5683
5684         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5685                         plaintext_pad_len, 15, 0);
5686         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5687                         "Failed to allocate input buffer in mempool");
5688
5689         if (op_mode == OUT_OF_PLACE) {
5690                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5691                                 plaintext_pad_len, 15, 0);
5692                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5693                                 "Failed to allocate output buffer in mempool");
5694         }
5695
5696         if (verify) {
5697                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
5698                         tdata->ciphertext.data);
5699                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5700                                         ciphertext_len, buffer);
5701                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5702                         ciphertext_len);
5703         } else {
5704                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5705                         tdata->plaintext.data);
5706                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5707                                         plaintext_len, buffer);
5708                 debug_hexdump(stdout, "plaintext:", plaintext,
5709                         plaintext_len);
5710         }
5711         memset(buffer, 0, sizeof(buffer));
5712
5713         /* Create KASUMI operation */
5714         retval = create_wireless_algo_auth_cipher_operation(
5715                 tdata->digest.data, tdata->digest.len,
5716                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5717                 NULL, 0,
5718                 (tdata->digest.offset_bytes == 0 ?
5719                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5720                         : tdata->digest.offset_bytes),
5721                 tdata->validCipherLenInBits.len,
5722                 tdata->validCipherOffsetInBits.len,
5723                 tdata->validAuthLenInBits.len,
5724                 0,
5725                 op_mode, 1, verify);
5726
5727         if (retval < 0)
5728                 return retval;
5729
5730         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5731                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5732                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5733         else
5734                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5735                         ut_params->op);
5736
5737         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5738
5739         ut_params->obuf = (op_mode == IN_PLACE ?
5740                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5741
5742         if (verify) {
5743                 if (ut_params->obuf)
5744                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
5745                                         plaintext_len, buffer);
5746                 else
5747                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5748                                         plaintext_len, buffer);
5749
5750                 debug_hexdump(stdout, "plaintext:", plaintext,
5751                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5752                 debug_hexdump(stdout, "plaintext expected:",
5753                         tdata->plaintext.data,
5754                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5755         } else {
5756                 if (ut_params->obuf)
5757                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
5758                                         ciphertext_len, buffer);
5759                 else
5760                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5761                                         ciphertext_len, buffer);
5762
5763                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5764                         ciphertext_len);
5765                 debug_hexdump(stdout, "ciphertext expected:",
5766                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5767
5768                 if (ut_params->obuf)
5769                         digest = rte_pktmbuf_read(ut_params->obuf,
5770                                 (tdata->digest.offset_bytes == 0 ?
5771                                 plaintext_pad_len : tdata->digest.offset_bytes),
5772                                 tdata->digest.len, digest_buffer);
5773                 else
5774                         digest = rte_pktmbuf_read(ut_params->ibuf,
5775                                 (tdata->digest.offset_bytes == 0 ?
5776                                 plaintext_pad_len : tdata->digest.offset_bytes),
5777                                 tdata->digest.len, digest_buffer);
5778
5779                 debug_hexdump(stdout, "digest:", digest,
5780                         tdata->digest.len);
5781                 debug_hexdump(stdout, "digest expected:",
5782                         tdata->digest.data, tdata->digest.len);
5783         }
5784
5785         /* Validate obuf */
5786         if (verify) {
5787                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5788                         plaintext,
5789                         tdata->plaintext.data,
5790                         tdata->plaintext.len >> 3,
5791                         "KASUMI Plaintext data not as expected");
5792         } else {
5793                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5794                         ciphertext,
5795                         tdata->ciphertext.data,
5796                         tdata->validDataLenInBits.len,
5797                         "KASUMI Ciphertext data not as expected");
5798
5799                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5800                         digest,
5801                         tdata->digest.data,
5802                         DIGEST_BYTE_LENGTH_KASUMI_F9,
5803                         "KASUMI Generated auth tag not as expected");
5804         }
5805         return 0;
5806 }
5807
5808 static int
5809 test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
5810 {
5811         struct crypto_testsuite_params *ts_params = &testsuite_params;
5812         struct crypto_unittest_params *ut_params = &unittest_params;
5813
5814         int retval;
5815
5816         uint8_t *plaintext, *ciphertext;
5817         unsigned plaintext_pad_len;
5818         unsigned plaintext_len;
5819         struct rte_cryptodev_info dev_info;
5820
5821         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5822         uint64_t feat_flags = dev_info.feature_flags;
5823
5824         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5825                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5826                 printf("Device doesn't support RAW data-path APIs.\n");
5827                 return TEST_SKIPPED;
5828         }
5829
5830         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5831                 return TEST_SKIPPED;
5832
5833         /* Verify the capabilities */
5834         struct rte_cryptodev_sym_capability_idx cap_idx;
5835         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5836         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5837         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5838                         &cap_idx) == NULL)
5839                 return TEST_SKIPPED;
5840         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5841         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5842         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5843                         &cap_idx) == NULL)
5844                 return TEST_SKIPPED;
5845
5846         /* Create KASUMI session */
5847         retval = create_wireless_algo_cipher_auth_session(
5848                         ts_params->valid_devs[0],
5849                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5850                         RTE_CRYPTO_AUTH_OP_GENERATE,
5851                         RTE_CRYPTO_AUTH_KASUMI_F9,
5852                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5853                         tdata->key.data, tdata->key.len,
5854                         0, tdata->digest.len,
5855                         tdata->cipher_iv.len);
5856         if (retval != 0)
5857                 return retval;
5858
5859         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5860
5861         /* clear mbuf payload */
5862         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5863                         rte_pktmbuf_tailroom(ut_params->ibuf));
5864
5865         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5866         /* Append data which is padded to a multiple of */
5867         /* the algorithms block size */
5868         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5869         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5870                                 plaintext_pad_len);
5871         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5872
5873         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5874
5875         /* Create KASUMI operation */
5876         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
5877                                 tdata->digest.len, NULL, 0,
5878                                 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
5879                                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5880                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
5881                                 tdata->validCipherOffsetInBits.len,
5882                                 tdata->validAuthLenInBits.len,
5883                                 0
5884                                 );
5885         if (retval < 0)
5886                 return retval;
5887
5888         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5889                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5890                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5891         else
5892                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5893                         ut_params->op);
5894         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5895
5896         if (ut_params->op->sym->m_dst)
5897                 ut_params->obuf = ut_params->op->sym->m_dst;
5898         else
5899                 ut_params->obuf = ut_params->op->sym->m_src;
5900
5901         ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
5902                                 tdata->validCipherOffsetInBits.len >> 3);
5903
5904         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5905                         + plaintext_pad_len;
5906
5907         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
5908                                 (tdata->validCipherOffsetInBits.len >> 3);
5909         /* Validate obuf */
5910         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5911                 ciphertext,
5912                 reference_ciphertext,
5913                 tdata->validCipherLenInBits.len,
5914                 "KASUMI Ciphertext data not as expected");
5915
5916         /* Validate obuf */
5917         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5918                 ut_params->digest,
5919                 tdata->digest.data,
5920                 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5921                 "KASUMI Generated auth tag not as expected");
5922         return 0;
5923 }
5924
5925 static int
5926 check_cipher_capability(const struct crypto_testsuite_params *ts_params,
5927                         const enum rte_crypto_cipher_algorithm cipher_algo,
5928                         const uint16_t key_size, const uint16_t iv_size)
5929 {
5930         struct rte_cryptodev_sym_capability_idx cap_idx;
5931         const struct rte_cryptodev_symmetric_capability *cap;
5932
5933         /* Check if device supports the algorithm */
5934         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5935         cap_idx.algo.cipher = cipher_algo;
5936
5937         cap = rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5938                         &cap_idx);
5939
5940         if (cap == NULL)
5941                 return -1;
5942
5943         /* Check if device supports key size and IV size */
5944         if (rte_cryptodev_sym_capability_check_cipher(cap, key_size,
5945                         iv_size) < 0) {
5946                 return -1;
5947         }
5948
5949         return 0;
5950 }
5951
5952 static int
5953 check_auth_capability(const struct crypto_testsuite_params *ts_params,
5954                         const enum rte_crypto_auth_algorithm auth_algo,
5955                         const uint16_t key_size, const uint16_t iv_size,
5956                         const uint16_t tag_size)
5957 {
5958         struct rte_cryptodev_sym_capability_idx cap_idx;
5959         const struct rte_cryptodev_symmetric_capability *cap;
5960
5961         /* Check if device supports the algorithm */
5962         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5963         cap_idx.algo.auth = auth_algo;
5964
5965         cap = rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5966                         &cap_idx);
5967
5968         if (cap == NULL)
5969                 return -1;
5970
5971         /* Check if device supports key size and IV size */
5972         if (rte_cryptodev_sym_capability_check_auth(cap, key_size,
5973                         tag_size, iv_size) < 0) {
5974                 return -1;
5975         }
5976
5977         return 0;
5978 }
5979
5980 static int
5981 test_zuc_encryption(const struct wireless_test_data *tdata)
5982 {
5983         struct crypto_testsuite_params *ts_params = &testsuite_params;
5984         struct crypto_unittest_params *ut_params = &unittest_params;
5985
5986         int retval;
5987         uint8_t *plaintext, *ciphertext;
5988         unsigned plaintext_pad_len;
5989         unsigned plaintext_len;
5990         struct rte_cryptodev_info dev_info;
5991
5992         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5993         uint64_t feat_flags = dev_info.feature_flags;
5994
5995         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5996                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5997                 printf("Device doesn't support RAW data-path APIs.\n");
5998                 return TEST_SKIPPED;
5999         }
6000
6001         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
6002                 return TEST_SKIPPED;
6003
6004         /* Check if device supports ZUC EEA3 */
6005         if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
6006                         tdata->key.len, tdata->cipher_iv.len) < 0)
6007                 return TEST_SKIPPED;
6008
6009         /* Create ZUC session */
6010         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
6011                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
6012                                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
6013                                         tdata->key.data, tdata->key.len,
6014                                         tdata->cipher_iv.len);
6015         if (retval != 0)
6016                 return retval;
6017
6018         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6019
6020         /* Clear mbuf payload */
6021         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6022                rte_pktmbuf_tailroom(ut_params->ibuf));
6023
6024         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6025         /* Append data which is padded to a multiple */
6026         /* of the algorithms block size */
6027         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
6028         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6029                                 plaintext_pad_len);
6030         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6031
6032         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
6033
6034         /* Create ZUC operation */
6035         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
6036                                         tdata->cipher_iv.len,
6037                                         tdata->plaintext.len,
6038                                         0);
6039         if (retval < 0)
6040                 return retval;
6041
6042         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6043                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6044                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
6045         else
6046                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6047                                                 ut_params->op);
6048         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6049
6050         ut_params->obuf = ut_params->op->sym->m_dst;
6051         if (ut_params->obuf)
6052                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
6053         else
6054                 ciphertext = plaintext;
6055
6056         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
6057
6058         /* Validate obuf */
6059         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6060                 ciphertext,
6061                 tdata->ciphertext.data,
6062                 tdata->validCipherLenInBits.len,
6063                 "ZUC Ciphertext data not as expected");
6064         return 0;
6065 }
6066
6067 static int
6068 test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
6069 {
6070         struct crypto_testsuite_params *ts_params = &testsuite_params;
6071         struct crypto_unittest_params *ut_params = &unittest_params;
6072
6073         int retval;
6074
6075         unsigned int plaintext_pad_len;
6076         unsigned int plaintext_len;
6077         const uint8_t *ciphertext;
6078         uint8_t ciphertext_buffer[2048];
6079         struct rte_cryptodev_info dev_info;
6080
6081         /* Check if device supports ZUC EEA3 */
6082         if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
6083                         tdata->key.len, tdata->cipher_iv.len) < 0)
6084                 return TEST_SKIPPED;
6085
6086         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
6087                 return TEST_SKIPPED;
6088
6089         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6090
6091         uint64_t feat_flags = dev_info.feature_flags;
6092
6093         if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6094                 printf("Device doesn't support in-place scatter-gather. "
6095                                 "Test Skipped.\n");
6096                 return TEST_SKIPPED;
6097         }
6098
6099         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6100                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6101                 printf("Device doesn't support RAW data-path APIs.\n");
6102                 return TEST_SKIPPED;
6103         }
6104
6105         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6106
6107         /* Append data which is padded to a multiple */
6108         /* of the algorithms block size */
6109         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
6110
6111         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
6112                         plaintext_pad_len, 10, 0);
6113
6114         pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
6115                         tdata->plaintext.data);
6116
6117         /* Create ZUC session */
6118         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
6119                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
6120                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
6121                         tdata->key.data, tdata->key.len,
6122                         tdata->cipher_iv.len);
6123         if (retval < 0)
6124                 return retval;
6125
6126         /* Clear mbuf payload */
6127
6128         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
6129
6130         /* Create ZUC operation */
6131         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
6132                         tdata->cipher_iv.len, tdata->plaintext.len,
6133                         0);
6134         if (retval < 0)
6135                 return retval;
6136
6137         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6138                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6139                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
6140         else
6141                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6142                                                 ut_params->op);
6143         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6144
6145         ut_params->obuf = ut_params->op->sym->m_dst;
6146         if (ut_params->obuf)
6147                 ciphertext = rte_pktmbuf_read(ut_params->obuf,
6148                         0, plaintext_len, ciphertext_buffer);
6149         else
6150                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
6151                         0, plaintext_len, ciphertext_buffer);
6152
6153         /* Validate obuf */
6154         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
6155
6156         /* Validate obuf */
6157         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6158                 ciphertext,
6159                 tdata->ciphertext.data,
6160                 tdata->validCipherLenInBits.len,
6161                 "ZUC Ciphertext data not as expected");
6162
6163         return 0;
6164 }
6165
6166 static int
6167 test_zuc_authentication(const struct wireless_test_data *tdata)
6168 {
6169         struct crypto_testsuite_params *ts_params = &testsuite_params;
6170         struct crypto_unittest_params *ut_params = &unittest_params;
6171
6172         int retval;
6173         unsigned plaintext_pad_len;
6174         unsigned plaintext_len;
6175         uint8_t *plaintext;
6176
6177         struct rte_cryptodev_info dev_info;
6178
6179         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6180         uint64_t feat_flags = dev_info.feature_flags;
6181
6182         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
6183                         (tdata->validAuthLenInBits.len % 8 != 0)) {
6184                 printf("Device doesn't support NON-Byte Aligned Data.\n");
6185                 return TEST_SKIPPED;
6186         }
6187
6188         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6189                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6190                 printf("Device doesn't support RAW data-path APIs.\n");
6191                 return TEST_SKIPPED;
6192         }
6193
6194         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
6195                 return TEST_SKIPPED;
6196
6197         /* Check if device supports ZUC EIA3 */
6198         if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3,
6199                         tdata->key.len, tdata->auth_iv.len,
6200                         tdata->digest.len) < 0)
6201                 return TEST_SKIPPED;
6202
6203         /* Create ZUC session */
6204         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
6205                         tdata->key.data, tdata->key.len,
6206                         tdata->auth_iv.len, tdata->digest.len,
6207                         RTE_CRYPTO_AUTH_OP_GENERATE,
6208                         RTE_CRYPTO_AUTH_ZUC_EIA3);
6209         if (retval != 0)
6210                 return retval;
6211
6212         /* alloc mbuf and set payload */
6213         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6214
6215         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6216         rte_pktmbuf_tailroom(ut_params->ibuf));
6217
6218         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6219         /* Append data which is padded to a multiple of */
6220         /* the algorithms block size */
6221         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
6222         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6223                                 plaintext_pad_len);
6224         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6225
6226         /* Create ZUC operation */
6227         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
6228                         tdata->auth_iv.data, tdata->auth_iv.len,
6229                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
6230                         tdata->validAuthLenInBits.len,
6231                         0);
6232         if (retval < 0)
6233                 return retval;
6234
6235         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6236                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6237                                 ut_params->op, 0, 1, 1, 0);
6238         else
6239                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6240                                 ut_params->op);
6241         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6242         ut_params->obuf = ut_params->op->sym->m_src;
6243         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
6244                         + plaintext_pad_len;
6245
6246         /* Validate obuf */
6247         TEST_ASSERT_BUFFERS_ARE_EQUAL(
6248         ut_params->digest,
6249         tdata->digest.data,
6250         tdata->digest.len,
6251         "ZUC Generated auth tag not as expected");
6252
6253         return 0;
6254 }
6255
6256 static int
6257 test_zuc_auth_cipher(const struct wireless_test_data *tdata,
6258         uint8_t op_mode, uint8_t verify)
6259 {
6260         struct crypto_testsuite_params *ts_params = &testsuite_params;
6261         struct crypto_unittest_params *ut_params = &unittest_params;
6262
6263         int retval;
6264
6265         uint8_t *plaintext = NULL, *ciphertext = NULL;
6266         unsigned int plaintext_pad_len;
6267         unsigned int plaintext_len;
6268         unsigned int ciphertext_pad_len;
6269         unsigned int ciphertext_len;
6270
6271         struct rte_cryptodev_info dev_info;
6272
6273         /* Check if device supports ZUC EEA3 */
6274         if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
6275                         tdata->key.len, tdata->cipher_iv.len) < 0)
6276                 return TEST_SKIPPED;
6277
6278         /* Check if device supports ZUC EIA3 */
6279         if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3,
6280                         tdata->key.len, tdata->auth_iv.len,
6281                         tdata->digest.len) < 0)
6282                 return TEST_SKIPPED;
6283
6284         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6285
6286         uint64_t feat_flags = dev_info.feature_flags;
6287
6288         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6289                 printf("Device doesn't support digest encrypted.\n");
6290                 return TEST_SKIPPED;
6291         }
6292         if (op_mode == IN_PLACE) {
6293                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6294                         printf("Device doesn't support in-place scatter-gather "
6295                                         "in both input and output mbufs.\n");
6296                         return TEST_SKIPPED;
6297                 }
6298
6299                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6300                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6301                         printf("Device doesn't support RAW data-path APIs.\n");
6302                         return TEST_SKIPPED;
6303                 }
6304         } else {
6305                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6306                         return TEST_SKIPPED;
6307                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
6308                         printf("Device doesn't support out-of-place scatter-gather "
6309                                         "in both input and output mbufs.\n");
6310                         return TEST_SKIPPED;
6311                 }
6312         }
6313
6314         /* Create ZUC session */
6315         retval = create_wireless_algo_auth_cipher_session(
6316                         ts_params->valid_devs[0],
6317                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
6318                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
6319                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
6320                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
6321                         RTE_CRYPTO_AUTH_ZUC_EIA3,
6322                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
6323                         tdata->key.data, tdata->key.len,
6324                         tdata->auth_iv.len, tdata->digest.len,
6325                         tdata->cipher_iv.len);
6326
6327         if (retval != 0)
6328                 return retval;
6329
6330         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6331         if (op_mode == OUT_OF_PLACE)
6332                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6333
6334         /* clear mbuf payload */
6335         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6336                 rte_pktmbuf_tailroom(ut_params->ibuf));
6337         if (op_mode == OUT_OF_PLACE)
6338                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
6339                         rte_pktmbuf_tailroom(ut_params->obuf));
6340
6341         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
6342         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6343         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6344         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6345
6346         if (verify) {
6347                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6348                                         ciphertext_pad_len);
6349                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
6350                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6351                         ciphertext_len);
6352         } else {
6353                 /* make sure enough space to cover partial digest verify case */
6354                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6355                                         ciphertext_pad_len);
6356                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6357                 debug_hexdump(stdout, "plaintext:", plaintext,
6358                         plaintext_len);
6359         }
6360
6361         if (op_mode == OUT_OF_PLACE)
6362                 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
6363
6364         /* Create ZUC operation */
6365         retval = create_wireless_algo_auth_cipher_operation(
6366                 tdata->digest.data, tdata->digest.len,
6367                 tdata->cipher_iv.data, tdata->cipher_iv.len,
6368                 tdata->auth_iv.data, tdata->auth_iv.len,
6369                 (tdata->digest.offset_bytes == 0 ?
6370                 (verify ? ciphertext_pad_len : plaintext_pad_len)
6371                         : tdata->digest.offset_bytes),
6372                 tdata->validCipherLenInBits.len,
6373                 tdata->validCipherOffsetInBits.len,
6374                 tdata->validAuthLenInBits.len,
6375                 0,
6376                 op_mode, 0, verify);
6377
6378         if (retval < 0)
6379                 return retval;
6380
6381         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6382                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6383                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
6384         else
6385                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6386                         ut_params->op);
6387
6388         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6389
6390         ut_params->obuf = (op_mode == IN_PLACE ?
6391                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6392
6393
6394         if (verify) {
6395                 if (ut_params->obuf)
6396                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
6397                                                         uint8_t *);
6398                 else
6399                         plaintext = ciphertext;
6400
6401                 debug_hexdump(stdout, "plaintext:", plaintext,
6402                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6403                 debug_hexdump(stdout, "plaintext expected:",
6404                         tdata->plaintext.data,
6405                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6406         } else {
6407                 if (ut_params->obuf)
6408                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
6409                                                         uint8_t *);
6410                 else
6411                         ciphertext = plaintext;
6412
6413                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6414                         ciphertext_len);
6415                 debug_hexdump(stdout, "ciphertext expected:",
6416                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
6417
6418                 ut_params->digest = rte_pktmbuf_mtod(
6419                         ut_params->obuf, uint8_t *) +
6420                         (tdata->digest.offset_bytes == 0 ?
6421                         plaintext_pad_len : tdata->digest.offset_bytes);
6422
6423                 debug_hexdump(stdout, "digest:", ut_params->digest,
6424                         tdata->digest.len);
6425                 debug_hexdump(stdout, "digest expected:",
6426                         tdata->digest.data, tdata->digest.len);
6427         }
6428
6429         /* Validate obuf */
6430         if (verify) {
6431                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6432                         plaintext,
6433                         tdata->plaintext.data,
6434                         tdata->plaintext.len >> 3,
6435                         "ZUC Plaintext data not as expected");
6436         } else {
6437                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6438                         ciphertext,
6439                         tdata->ciphertext.data,
6440                         tdata->ciphertext.len >> 3,
6441                         "ZUC Ciphertext data not as expected");
6442
6443                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6444                         ut_params->digest,
6445                         tdata->digest.data,
6446                         DIGEST_BYTE_LENGTH_KASUMI_F9,
6447                         "ZUC Generated auth tag not as expected");
6448         }
6449         return 0;
6450 }
6451
6452 static int
6453 test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata,
6454         uint8_t op_mode, uint8_t verify)
6455 {
6456         struct crypto_testsuite_params *ts_params = &testsuite_params;
6457         struct crypto_unittest_params *ut_params = &unittest_params;
6458
6459         int retval;
6460
6461         const uint8_t *plaintext = NULL;
6462         const uint8_t *ciphertext = NULL;
6463         const uint8_t *digest = NULL;
6464         unsigned int plaintext_pad_len;
6465         unsigned int plaintext_len;
6466         unsigned int ciphertext_pad_len;
6467         unsigned int ciphertext_len;
6468         uint8_t buffer[10000];
6469         uint8_t digest_buffer[10000];
6470
6471         struct rte_cryptodev_info dev_info;
6472
6473         /* Check if device supports ZUC EEA3 */
6474         if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
6475                         tdata->key.len, tdata->cipher_iv.len) < 0)
6476                 return TEST_SKIPPED;
6477
6478         /* Check if device supports ZUC EIA3 */
6479         if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3,
6480                         tdata->key.len, tdata->auth_iv.len,
6481                         tdata->digest.len) < 0)
6482                 return TEST_SKIPPED;
6483
6484         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6485
6486         uint64_t feat_flags = dev_info.feature_flags;
6487
6488         if (op_mode == IN_PLACE) {
6489                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6490                         printf("Device doesn't support in-place scatter-gather "
6491                                         "in both input and output mbufs.\n");
6492                         return TEST_SKIPPED;
6493                 }
6494
6495                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6496                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6497                         printf("Device doesn't support RAW data-path APIs.\n");
6498                         return TEST_SKIPPED;
6499                 }
6500         } else {
6501                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6502                         return TEST_SKIPPED;
6503                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
6504                         printf("Device doesn't support out-of-place scatter-gather "
6505                                         "in both input and output mbufs.\n");
6506                         return TEST_SKIPPED;
6507                 }
6508                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6509                         printf("Device doesn't support digest encrypted.\n");
6510                         return TEST_SKIPPED;
6511                 }
6512         }
6513
6514         /* Create ZUC session */
6515         retval = create_wireless_algo_auth_cipher_session(
6516                         ts_params->valid_devs[0],
6517                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
6518                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
6519                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
6520                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
6521                         RTE_CRYPTO_AUTH_ZUC_EIA3,
6522                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
6523                         tdata->key.data, tdata->key.len,
6524                         tdata->auth_iv.len, tdata->digest.len,
6525                         tdata->cipher_iv.len);
6526
6527         if (retval != 0)
6528                 return retval;
6529
6530         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
6531         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6532         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6533         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6534
6535         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
6536                         plaintext_pad_len, 15, 0);
6537         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
6538                         "Failed to allocate input buffer in mempool");
6539
6540         if (op_mode == OUT_OF_PLACE) {
6541                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
6542                                 plaintext_pad_len, 15, 0);
6543                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
6544                                 "Failed to allocate output buffer in mempool");
6545         }
6546
6547         if (verify) {
6548                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
6549                         tdata->ciphertext.data);
6550                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6551                                         ciphertext_len, buffer);
6552                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6553                         ciphertext_len);
6554         } else {
6555                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
6556                         tdata->plaintext.data);
6557                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6558                                         plaintext_len, buffer);
6559                 debug_hexdump(stdout, "plaintext:", plaintext,
6560                         plaintext_len);
6561         }
6562         memset(buffer, 0, sizeof(buffer));
6563
6564         /* Create ZUC operation */
6565         retval = create_wireless_algo_auth_cipher_operation(
6566                 tdata->digest.data, tdata->digest.len,
6567                 tdata->cipher_iv.data, tdata->cipher_iv.len,
6568                 NULL, 0,
6569                 (tdata->digest.offset_bytes == 0 ?
6570                 (verify ? ciphertext_pad_len : plaintext_pad_len)
6571                         : tdata->digest.offset_bytes),
6572                 tdata->validCipherLenInBits.len,
6573                 tdata->validCipherOffsetInBits.len,
6574                 tdata->validAuthLenInBits.len,
6575                 0,
6576                 op_mode, 1, verify);
6577
6578         if (retval < 0)
6579                 return retval;
6580
6581         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6582                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6583                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
6584         else
6585                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6586                         ut_params->op);
6587
6588         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6589
6590         ut_params->obuf = (op_mode == IN_PLACE ?
6591                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6592
6593         if (verify) {
6594                 if (ut_params->obuf)
6595                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
6596                                         plaintext_len, buffer);
6597                 else
6598                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6599                                         plaintext_len, buffer);
6600
6601                 debug_hexdump(stdout, "plaintext:", plaintext,
6602                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6603                 debug_hexdump(stdout, "plaintext expected:",
6604                         tdata->plaintext.data,
6605                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6606         } else {
6607                 if (ut_params->obuf)
6608                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
6609                                         ciphertext_len, buffer);
6610                 else
6611                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6612                                         ciphertext_len, buffer);
6613
6614                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6615                         ciphertext_len);
6616                 debug_hexdump(stdout, "ciphertext expected:",
6617                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
6618
6619                 if (ut_params->obuf)
6620                         digest = rte_pktmbuf_read(ut_params->obuf,
6621                                 (tdata->digest.offset_bytes == 0 ?
6622                                 plaintext_pad_len : tdata->digest.offset_bytes),
6623                                 tdata->digest.len, digest_buffer);
6624                 else
6625                         digest = rte_pktmbuf_read(ut_params->ibuf,
6626                                 (tdata->digest.offset_bytes == 0 ?
6627                                 plaintext_pad_len : tdata->digest.offset_bytes),
6628                                 tdata->digest.len, digest_buffer);
6629
6630                 debug_hexdump(stdout, "digest:", digest,
6631                         tdata->digest.len);
6632                 debug_hexdump(stdout, "digest expected:",
6633                         tdata->digest.data, tdata->digest.len);
6634         }
6635
6636         /* Validate obuf */
6637         if (verify) {
6638                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6639                         plaintext,
6640                         tdata->plaintext.data,
6641                         tdata->plaintext.len >> 3,
6642                         "ZUC Plaintext data not as expected");
6643         } else {
6644                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6645                         ciphertext,
6646                         tdata->ciphertext.data,
6647                         tdata->validDataLenInBits.len,
6648                         "ZUC Ciphertext data not as expected");
6649
6650                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6651                         digest,
6652                         tdata->digest.data,
6653                         DIGEST_BYTE_LENGTH_KASUMI_F9,
6654                         "ZUC Generated auth tag not as expected");
6655         }
6656         return 0;
6657 }
6658
6659 static int
6660 test_kasumi_encryption_test_case_1(void)
6661 {
6662         return test_kasumi_encryption(&kasumi_test_case_1);
6663 }
6664
6665 static int
6666 test_kasumi_encryption_test_case_1_sgl(void)
6667 {
6668         return test_kasumi_encryption_sgl(&kasumi_test_case_1);
6669 }
6670
6671 static int
6672 test_kasumi_encryption_test_case_1_oop(void)
6673 {
6674         return test_kasumi_encryption_oop(&kasumi_test_case_1);
6675 }
6676
6677 static int
6678 test_kasumi_encryption_test_case_1_oop_sgl(void)
6679 {
6680         return test_kasumi_encryption_oop_sgl(&kasumi_test_case_1);
6681 }
6682
6683 static int
6684 test_kasumi_encryption_test_case_2(void)
6685 {
6686         return test_kasumi_encryption(&kasumi_test_case_2);
6687 }
6688
6689 static int
6690 test_kasumi_encryption_test_case_3(void)
6691 {
6692         return test_kasumi_encryption(&kasumi_test_case_3);
6693 }
6694
6695 static int
6696 test_kasumi_encryption_test_case_4(void)
6697 {
6698         return test_kasumi_encryption(&kasumi_test_case_4);
6699 }
6700
6701 static int
6702 test_kasumi_encryption_test_case_5(void)
6703 {
6704         return test_kasumi_encryption(&kasumi_test_case_5);
6705 }
6706
6707 static int
6708 test_kasumi_decryption_test_case_1(void)
6709 {
6710         return test_kasumi_decryption(&kasumi_test_case_1);
6711 }
6712
6713 static int
6714 test_kasumi_decryption_test_case_1_oop(void)
6715 {
6716         return test_kasumi_decryption_oop(&kasumi_test_case_1);
6717 }
6718
6719 static int
6720 test_kasumi_decryption_test_case_2(void)
6721 {
6722         return test_kasumi_decryption(&kasumi_test_case_2);
6723 }
6724
6725 static int
6726 test_kasumi_decryption_test_case_3(void)
6727 {
6728         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6729         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6730                 return TEST_SKIPPED;
6731         return test_kasumi_decryption(&kasumi_test_case_3);
6732 }
6733
6734 static int
6735 test_kasumi_decryption_test_case_4(void)
6736 {
6737         return test_kasumi_decryption(&kasumi_test_case_4);
6738 }
6739
6740 static int
6741 test_kasumi_decryption_test_case_5(void)
6742 {
6743         return test_kasumi_decryption(&kasumi_test_case_5);
6744 }
6745 static int
6746 test_snow3g_encryption_test_case_1(void)
6747 {
6748         return test_snow3g_encryption(&snow3g_test_case_1);
6749 }
6750
6751 static int
6752 test_snow3g_encryption_test_case_1_oop(void)
6753 {
6754         return test_snow3g_encryption_oop(&snow3g_test_case_1);
6755 }
6756
6757 static int
6758 test_snow3g_encryption_test_case_1_oop_sgl(void)
6759 {
6760         return test_snow3g_encryption_oop_sgl(&snow3g_test_case_1);
6761 }
6762
6763
6764 static int
6765 test_snow3g_encryption_test_case_1_offset_oop(void)
6766 {
6767         return test_snow3g_encryption_offset_oop(&snow3g_test_case_1);
6768 }
6769
6770 static int
6771 test_snow3g_encryption_test_case_2(void)
6772 {
6773         return test_snow3g_encryption(&snow3g_test_case_2);
6774 }
6775
6776 static int
6777 test_snow3g_encryption_test_case_3(void)
6778 {
6779         return test_snow3g_encryption(&snow3g_test_case_3);
6780 }
6781
6782 static int
6783 test_snow3g_encryption_test_case_4(void)
6784 {
6785         return test_snow3g_encryption(&snow3g_test_case_4);
6786 }
6787
6788 static int
6789 test_snow3g_encryption_test_case_5(void)
6790 {
6791         return test_snow3g_encryption(&snow3g_test_case_5);
6792 }
6793
6794 static int
6795 test_snow3g_decryption_test_case_1(void)
6796 {
6797         return test_snow3g_decryption(&snow3g_test_case_1);
6798 }
6799
6800 static int
6801 test_snow3g_decryption_test_case_1_oop(void)
6802 {
6803         return test_snow3g_decryption_oop(&snow3g_test_case_1);
6804 }
6805
6806 static int
6807 test_snow3g_decryption_test_case_2(void)
6808 {
6809         return test_snow3g_decryption(&snow3g_test_case_2);
6810 }
6811
6812 static int
6813 test_snow3g_decryption_test_case_3(void)
6814 {
6815         return test_snow3g_decryption(&snow3g_test_case_3);
6816 }
6817
6818 static int
6819 test_snow3g_decryption_test_case_4(void)
6820 {
6821         return test_snow3g_decryption(&snow3g_test_case_4);
6822 }
6823
6824 static int
6825 test_snow3g_decryption_test_case_5(void)
6826 {
6827         return test_snow3g_decryption(&snow3g_test_case_5);
6828 }
6829
6830 /*
6831  * Function prepares snow3g_hash_test_data from snow3g_test_data.
6832  * Pattern digest from snow3g_test_data must be allocated as
6833  * 4 last bytes in plaintext.
6834  */
6835 static void
6836 snow3g_hash_test_vector_setup(const struct snow3g_test_data *pattern,
6837                 struct snow3g_hash_test_data *output)
6838 {
6839         if ((pattern != NULL) && (output != NULL)) {
6840                 output->key.len = pattern->key.len;
6841
6842                 memcpy(output->key.data,
6843                 pattern->key.data, pattern->key.len);
6844
6845                 output->auth_iv.len = pattern->auth_iv.len;
6846
6847                 memcpy(output->auth_iv.data,
6848                 pattern->auth_iv.data, pattern->auth_iv.len);
6849
6850                 output->plaintext.len = pattern->plaintext.len;
6851
6852                 memcpy(output->plaintext.data,
6853                 pattern->plaintext.data, pattern->plaintext.len >> 3);
6854
6855                 output->digest.len = pattern->digest.len;
6856
6857                 memcpy(output->digest.data,
6858                 &pattern->plaintext.data[pattern->digest.offset_bytes],
6859                 pattern->digest.len);
6860
6861                 output->validAuthLenInBits.len =
6862                 pattern->validAuthLenInBits.len;
6863         }
6864 }
6865
6866 /*
6867  * Test case verify computed cipher and digest from snow3g_test_case_7 data.
6868  */
6869 static int
6870 test_snow3g_decryption_with_digest_test_case_1(void)
6871 {
6872         struct snow3g_hash_test_data snow3g_hash_data;
6873         struct rte_cryptodev_info dev_info;
6874         struct crypto_testsuite_params *ts_params = &testsuite_params;
6875
6876         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6877         uint64_t feat_flags = dev_info.feature_flags;
6878
6879         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6880                 printf("Device doesn't support encrypted digest operations.\n");
6881                 return TEST_SKIPPED;
6882         }
6883
6884         /*
6885          * Function prepare data for hash verification test case.
6886          * Digest is allocated in 4 last bytes in plaintext, pattern.
6887          */
6888         snow3g_hash_test_vector_setup(&snow3g_test_case_7, &snow3g_hash_data);
6889
6890         return test_snow3g_decryption(&snow3g_test_case_7) &
6891                         test_snow3g_authentication_verify(&snow3g_hash_data);
6892 }
6893
6894 static int
6895 test_snow3g_cipher_auth_test_case_1(void)
6896 {
6897         return test_snow3g_cipher_auth(&snow3g_test_case_3);
6898 }
6899
6900 static int
6901 test_snow3g_auth_cipher_test_case_1(void)
6902 {
6903         return test_snow3g_auth_cipher(
6904                 &snow3g_auth_cipher_test_case_1, IN_PLACE, 0);
6905 }
6906
6907 static int
6908 test_snow3g_auth_cipher_test_case_2(void)
6909 {
6910         return test_snow3g_auth_cipher(
6911                 &snow3g_auth_cipher_test_case_2, IN_PLACE, 0);
6912 }
6913
6914 static int
6915 test_snow3g_auth_cipher_test_case_2_oop(void)
6916 {
6917         return test_snow3g_auth_cipher(
6918                 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
6919 }
6920
6921 static int
6922 test_snow3g_auth_cipher_part_digest_enc(void)
6923 {
6924         return test_snow3g_auth_cipher(
6925                 &snow3g_auth_cipher_partial_digest_encryption,
6926                         IN_PLACE, 0);
6927 }
6928
6929 static int
6930 test_snow3g_auth_cipher_part_digest_enc_oop(void)
6931 {
6932         return test_snow3g_auth_cipher(
6933                 &snow3g_auth_cipher_partial_digest_encryption,
6934                         OUT_OF_PLACE, 0);
6935 }
6936
6937 static int
6938 test_snow3g_auth_cipher_test_case_3_sgl(void)
6939 {
6940         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6941         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6942                 return TEST_SKIPPED;
6943         return test_snow3g_auth_cipher_sgl(
6944                 &snow3g_auth_cipher_test_case_3, IN_PLACE, 0);
6945 }
6946
6947 static int
6948 test_snow3g_auth_cipher_test_case_3_oop_sgl(void)
6949 {
6950         return test_snow3g_auth_cipher_sgl(
6951                 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 0);
6952 }
6953
6954 static int
6955 test_snow3g_auth_cipher_part_digest_enc_sgl(void)
6956 {
6957         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6958         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6959                 return TEST_SKIPPED;
6960         return test_snow3g_auth_cipher_sgl(
6961                 &snow3g_auth_cipher_partial_digest_encryption,
6962                         IN_PLACE, 0);
6963 }
6964
6965 static int
6966 test_snow3g_auth_cipher_part_digest_enc_oop_sgl(void)
6967 {
6968         return test_snow3g_auth_cipher_sgl(
6969                 &snow3g_auth_cipher_partial_digest_encryption,
6970                         OUT_OF_PLACE, 0);
6971 }
6972
6973 static int
6974 test_snow3g_auth_cipher_verify_test_case_1(void)
6975 {
6976         return test_snow3g_auth_cipher(
6977                 &snow3g_auth_cipher_test_case_1, IN_PLACE, 1);
6978 }
6979
6980 static int
6981 test_snow3g_auth_cipher_verify_test_case_2(void)
6982 {
6983         return test_snow3g_auth_cipher(
6984                 &snow3g_auth_cipher_test_case_2, IN_PLACE, 1);
6985 }
6986
6987 static int
6988 test_snow3g_auth_cipher_verify_test_case_2_oop(void)
6989 {
6990         return test_snow3g_auth_cipher(
6991                 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
6992 }
6993
6994 static int
6995 test_snow3g_auth_cipher_verify_part_digest_enc(void)
6996 {
6997         return test_snow3g_auth_cipher(
6998                 &snow3g_auth_cipher_partial_digest_encryption,
6999                         IN_PLACE, 1);
7000 }
7001
7002 static int
7003 test_snow3g_auth_cipher_verify_part_digest_enc_oop(void)
7004 {
7005         return test_snow3g_auth_cipher(
7006                 &snow3g_auth_cipher_partial_digest_encryption,
7007                         OUT_OF_PLACE, 1);
7008 }
7009
7010 static int
7011 test_snow3g_auth_cipher_verify_test_case_3_sgl(void)
7012 {
7013         return test_snow3g_auth_cipher_sgl(
7014                 &snow3g_auth_cipher_test_case_3, IN_PLACE, 1);
7015 }
7016
7017 static int
7018 test_snow3g_auth_cipher_verify_test_case_3_oop_sgl(void)
7019 {
7020         return test_snow3g_auth_cipher_sgl(
7021                 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 1);
7022 }
7023
7024 static int
7025 test_snow3g_auth_cipher_verify_part_digest_enc_sgl(void)
7026 {
7027         return test_snow3g_auth_cipher_sgl(
7028                 &snow3g_auth_cipher_partial_digest_encryption,
7029                         IN_PLACE, 1);
7030 }
7031
7032 static int
7033 test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl(void)
7034 {
7035         return test_snow3g_auth_cipher_sgl(
7036                 &snow3g_auth_cipher_partial_digest_encryption,
7037                         OUT_OF_PLACE, 1);
7038 }
7039
7040 static int
7041 test_snow3g_auth_cipher_with_digest_test_case_1(void)
7042 {
7043         return test_snow3g_auth_cipher(
7044                 &snow3g_test_case_7, IN_PLACE, 0);
7045 }
7046
7047 static int
7048 test_kasumi_auth_cipher_test_case_1(void)
7049 {
7050         return test_kasumi_auth_cipher(
7051                 &kasumi_test_case_3, IN_PLACE, 0);
7052 }
7053
7054 static int
7055 test_kasumi_auth_cipher_test_case_2(void)
7056 {
7057         return test_kasumi_auth_cipher(
7058                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
7059 }
7060
7061 static int
7062 test_kasumi_auth_cipher_test_case_2_oop(void)
7063 {
7064         return test_kasumi_auth_cipher(
7065                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
7066 }
7067
7068 static int
7069 test_kasumi_auth_cipher_test_case_2_sgl(void)
7070 {
7071         return test_kasumi_auth_cipher_sgl(
7072                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
7073 }
7074
7075 static int
7076 test_kasumi_auth_cipher_test_case_2_oop_sgl(void)
7077 {
7078         return test_kasumi_auth_cipher_sgl(
7079                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
7080 }
7081
7082 static int
7083 test_kasumi_auth_cipher_verify_test_case_1(void)
7084 {
7085         return test_kasumi_auth_cipher(
7086                 &kasumi_test_case_3, IN_PLACE, 1);
7087 }
7088
7089 static int
7090 test_kasumi_auth_cipher_verify_test_case_2(void)
7091 {
7092         return test_kasumi_auth_cipher(
7093                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
7094 }
7095
7096 static int
7097 test_kasumi_auth_cipher_verify_test_case_2_oop(void)
7098 {
7099         return test_kasumi_auth_cipher(
7100                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
7101 }
7102
7103 static int
7104 test_kasumi_auth_cipher_verify_test_case_2_sgl(void)
7105 {
7106         return test_kasumi_auth_cipher_sgl(
7107                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
7108 }
7109
7110 static int
7111 test_kasumi_auth_cipher_verify_test_case_2_oop_sgl(void)
7112 {
7113         return test_kasumi_auth_cipher_sgl(
7114                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
7115 }
7116
7117 static int
7118 test_kasumi_cipher_auth_test_case_1(void)
7119 {
7120         return test_kasumi_cipher_auth(&kasumi_test_case_6);
7121 }
7122
7123 static int
7124 test_zuc_encryption_test_case_1(void)
7125 {
7126         return test_zuc_encryption(&zuc_test_case_cipher_193b);
7127 }
7128
7129 static int
7130 test_zuc_encryption_test_case_2(void)
7131 {
7132         return test_zuc_encryption(&zuc_test_case_cipher_800b);
7133 }
7134
7135 static int
7136 test_zuc_encryption_test_case_3(void)
7137 {
7138         return test_zuc_encryption(&zuc_test_case_cipher_1570b);
7139 }
7140
7141 static int
7142 test_zuc_encryption_test_case_4(void)
7143 {
7144         return test_zuc_encryption(&zuc_test_case_cipher_2798b);
7145 }
7146
7147 static int
7148 test_zuc_encryption_test_case_5(void)
7149 {
7150         return test_zuc_encryption(&zuc_test_case_cipher_4019b);
7151 }
7152
7153 static int
7154 test_zuc_encryption_test_case_6_sgl(void)
7155 {
7156         return test_zuc_encryption_sgl(&zuc_test_case_cipher_193b);
7157 }
7158
7159 static int
7160 test_zuc_hash_generate_test_case_1(void)
7161 {
7162         return test_zuc_authentication(&zuc_test_case_auth_1b);
7163 }
7164
7165 static int
7166 test_zuc_hash_generate_test_case_2(void)
7167 {
7168         return test_zuc_authentication(&zuc_test_case_auth_90b);
7169 }
7170
7171 static int
7172 test_zuc_hash_generate_test_case_3(void)
7173 {
7174         return test_zuc_authentication(&zuc_test_case_auth_577b);
7175 }
7176
7177 static int
7178 test_zuc_hash_generate_test_case_4(void)
7179 {
7180         return test_zuc_authentication(&zuc_test_case_auth_2079b);
7181 }
7182
7183 static int
7184 test_zuc_hash_generate_test_case_5(void)
7185 {
7186         return test_zuc_authentication(&zuc_test_auth_5670b);
7187 }
7188
7189 static int
7190 test_zuc_hash_generate_test_case_6(void)
7191 {
7192         return test_zuc_authentication(&zuc_test_case_auth_128b);
7193 }
7194
7195 static int
7196 test_zuc_hash_generate_test_case_7(void)
7197 {
7198         return test_zuc_authentication(&zuc_test_case_auth_2080b);
7199 }
7200
7201 static int
7202 test_zuc_hash_generate_test_case_8(void)
7203 {
7204         return test_zuc_authentication(&zuc_test_case_auth_584b);
7205 }
7206
7207 static int
7208 test_zuc_hash_generate_test_case_9(void)
7209 {
7210         return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_32b);
7211 }
7212
7213 static int
7214 test_zuc_hash_generate_test_case_10(void)
7215 {
7216         return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_64b);
7217 }
7218
7219 static int
7220 test_zuc_hash_generate_test_case_11(void)
7221 {
7222         return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_128b);
7223 }
7224
7225 static int
7226 test_zuc_cipher_auth_test_case_1(void)
7227 {
7228         return test_zuc_cipher_auth(&zuc_test_case_cipher_200b_auth_200b);
7229 }
7230
7231 static int
7232 test_zuc_cipher_auth_test_case_2(void)
7233 {
7234         return test_zuc_cipher_auth(&zuc_test_case_cipher_800b_auth_120b);
7235 }
7236
7237 static int
7238 test_zuc_auth_cipher_test_case_1(void)
7239 {
7240         return test_zuc_auth_cipher(
7241                 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
7242 }
7243
7244 static int
7245 test_zuc_auth_cipher_test_case_1_oop(void)
7246 {
7247         return test_zuc_auth_cipher(
7248                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
7249 }
7250
7251 static int
7252 test_zuc_auth_cipher_test_case_1_sgl(void)
7253 {
7254         return test_zuc_auth_cipher_sgl(
7255                 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
7256 }
7257
7258 static int
7259 test_zuc_auth_cipher_test_case_1_oop_sgl(void)
7260 {
7261         return test_zuc_auth_cipher_sgl(
7262                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
7263 }
7264
7265 static int
7266 test_zuc_auth_cipher_verify_test_case_1(void)
7267 {
7268         return test_zuc_auth_cipher(
7269                 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
7270 }
7271
7272 static int
7273 test_zuc_auth_cipher_verify_test_case_1_oop(void)
7274 {
7275         return test_zuc_auth_cipher(
7276                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
7277 }
7278
7279 static int
7280 test_zuc_auth_cipher_verify_test_case_1_sgl(void)
7281 {
7282         return test_zuc_auth_cipher_sgl(
7283                 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
7284 }
7285
7286 static int
7287 test_zuc_auth_cipher_verify_test_case_1_oop_sgl(void)
7288 {
7289         return test_zuc_auth_cipher_sgl(
7290                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
7291 }
7292
7293 static int
7294 test_zuc256_encryption_test_case_1(void)
7295 {
7296         return test_zuc_encryption(&zuc256_test_case_cipher_1);
7297 }
7298
7299 static int
7300 test_zuc256_encryption_test_case_2(void)
7301 {
7302         return test_zuc_encryption(&zuc256_test_case_cipher_2);
7303 }
7304
7305 static int
7306 test_zuc256_authentication_test_case_1(void)
7307 {
7308         return test_zuc_authentication(&zuc256_test_case_auth_1);
7309 }
7310
7311 static int
7312 test_zuc256_authentication_test_case_2(void)
7313 {
7314         return test_zuc_authentication(&zuc256_test_case_auth_2);
7315 }
7316
7317 static int
7318 test_mixed_check_if_unsupported(const struct mixed_cipher_auth_test_data *tdata)
7319 {
7320         uint8_t dev_id = testsuite_params.valid_devs[0];
7321
7322         struct rte_cryptodev_sym_capability_idx cap_idx;
7323
7324         /* Check if device supports particular cipher algorithm */
7325         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
7326         cap_idx.algo.cipher = tdata->cipher_algo;
7327         if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
7328                 return TEST_SKIPPED;
7329
7330         /* Check if device supports particular hash algorithm */
7331         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
7332         cap_idx.algo.auth = tdata->auth_algo;
7333         if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
7334                 return TEST_SKIPPED;
7335
7336         return 0;
7337 }
7338
7339 static int
7340 test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata,
7341         uint8_t op_mode, uint8_t verify)
7342 {
7343         struct crypto_testsuite_params *ts_params = &testsuite_params;
7344         struct crypto_unittest_params *ut_params = &unittest_params;
7345
7346         int retval;
7347
7348         uint8_t *plaintext = NULL, *ciphertext = NULL;
7349         unsigned int plaintext_pad_len;
7350         unsigned int plaintext_len;
7351         unsigned int ciphertext_pad_len;
7352         unsigned int ciphertext_len;
7353
7354         struct rte_cryptodev_info dev_info;
7355         struct rte_crypto_op *op;
7356
7357         /* Check if device supports particular algorithms separately */
7358         if (test_mixed_check_if_unsupported(tdata))
7359                 return TEST_SKIPPED;
7360         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
7361                 return TEST_SKIPPED;
7362
7363         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
7364
7365         uint64_t feat_flags = dev_info.feature_flags;
7366
7367         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
7368                 printf("Device doesn't support digest encrypted.\n");
7369                 return TEST_SKIPPED;
7370         }
7371
7372         /* Create the session */
7373         if (verify)
7374                 retval = create_wireless_algo_cipher_auth_session(
7375                                 ts_params->valid_devs[0],
7376                                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
7377                                 RTE_CRYPTO_AUTH_OP_VERIFY,
7378                                 tdata->auth_algo,
7379                                 tdata->cipher_algo,
7380                                 tdata->auth_key.data, tdata->auth_key.len,
7381                                 tdata->auth_iv.len, tdata->digest_enc.len,
7382                                 tdata->cipher_iv.len);
7383         else
7384                 retval = create_wireless_algo_auth_cipher_session(
7385                                 ts_params->valid_devs[0],
7386                                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7387                                 RTE_CRYPTO_AUTH_OP_GENERATE,
7388                                 tdata->auth_algo,
7389                                 tdata->cipher_algo,
7390                                 tdata->auth_key.data, tdata->auth_key.len,
7391                                 tdata->auth_iv.len, tdata->digest_enc.len,
7392                                 tdata->cipher_iv.len);
7393         if (retval != 0)
7394                 return retval;
7395
7396         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7397         if (op_mode == OUT_OF_PLACE)
7398                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7399
7400         /* clear mbuf payload */
7401         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7402                 rte_pktmbuf_tailroom(ut_params->ibuf));
7403         if (op_mode == OUT_OF_PLACE) {
7404
7405                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
7406                                 rte_pktmbuf_tailroom(ut_params->obuf));
7407         }
7408
7409         ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
7410         plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
7411         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
7412         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
7413
7414         if (verify) {
7415                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7416                                 ciphertext_pad_len);
7417                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
7418                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7419                                 ciphertext_len);
7420         } else {
7421                 /* make sure enough space to cover partial digest verify case */
7422                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7423                                 ciphertext_pad_len);
7424                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
7425                 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
7426         }
7427
7428         if (op_mode == OUT_OF_PLACE)
7429                 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
7430
7431         /* Create the operation */
7432         retval = create_wireless_algo_auth_cipher_operation(
7433                         tdata->digest_enc.data, tdata->digest_enc.len,
7434                         tdata->cipher_iv.data, tdata->cipher_iv.len,
7435                         tdata->auth_iv.data, tdata->auth_iv.len,
7436                         (tdata->digest_enc.offset == 0 ?
7437                                 plaintext_pad_len
7438                                 : tdata->digest_enc.offset),
7439                         tdata->validCipherLen.len_bits,
7440                         tdata->cipher.offset_bits,
7441                         tdata->validAuthLen.len_bits,
7442                         tdata->auth.offset_bits,
7443                         op_mode, 0, verify);
7444
7445         if (retval < 0)
7446                 return retval;
7447
7448         op = process_crypto_request(ts_params->valid_devs[0], ut_params->op);
7449
7450         /* Check if the op failed because the device doesn't */
7451         /* support this particular combination of algorithms */
7452         if (op == NULL && ut_params->op->status ==
7453                         RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
7454                 printf("Device doesn't support this mixed combination. "
7455                                 "Test Skipped.\n");
7456                 return TEST_SKIPPED;
7457         }
7458         ut_params->op = op;
7459
7460         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
7461
7462         ut_params->obuf = (op_mode == IN_PLACE ?
7463                         ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
7464
7465         if (verify) {
7466                 if (ut_params->obuf)
7467                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
7468                                                         uint8_t *);
7469                 else
7470                         plaintext = ciphertext +
7471                                         (tdata->cipher.offset_bits >> 3);
7472
7473                 debug_hexdump(stdout, "plaintext:", plaintext,
7474                                 tdata->plaintext.len_bits >> 3);
7475                 debug_hexdump(stdout, "plaintext expected:",
7476                                 tdata->plaintext.data,
7477                                 tdata->plaintext.len_bits >> 3);
7478         } else {
7479                 if (ut_params->obuf)
7480                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
7481                                         uint8_t *);
7482                 else
7483                         ciphertext = plaintext;
7484
7485                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7486                                 ciphertext_len);
7487                 debug_hexdump(stdout, "ciphertext expected:",
7488                                 tdata->ciphertext.data,
7489                                 tdata->ciphertext.len_bits >> 3);
7490
7491                 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
7492                                 + (tdata->digest_enc.offset == 0 ?
7493                 plaintext_pad_len : tdata->digest_enc.offset);
7494
7495                 debug_hexdump(stdout, "digest:", ut_params->digest,
7496                                 tdata->digest_enc.len);
7497                 debug_hexdump(stdout, "digest expected:",
7498                                 tdata->digest_enc.data,
7499                                 tdata->digest_enc.len);
7500         }
7501
7502         if (!verify) {
7503                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7504                                 ut_params->digest,
7505                                 tdata->digest_enc.data,
7506                                 tdata->digest_enc.len,
7507                                 "Generated auth tag not as expected");
7508         }
7509
7510         if (tdata->cipher_algo != RTE_CRYPTO_CIPHER_NULL) {
7511                 if (verify) {
7512                         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7513                                         plaintext,
7514                                         tdata->plaintext.data,
7515                                         tdata->plaintext.len_bits >> 3,
7516                                         "Plaintext data not as expected");
7517                 } else {
7518                         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7519                                         ciphertext,
7520                                         tdata->ciphertext.data,
7521                                         tdata->validDataLen.len_bits,
7522                                         "Ciphertext data not as expected");
7523                 }
7524         }
7525
7526         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7527                         "crypto op processing failed");
7528
7529         return 0;
7530 }
7531
7532 static int
7533 test_mixed_auth_cipher_sgl(const struct mixed_cipher_auth_test_data *tdata,
7534         uint8_t op_mode, uint8_t verify)
7535 {
7536         struct crypto_testsuite_params *ts_params = &testsuite_params;
7537         struct crypto_unittest_params *ut_params = &unittest_params;
7538
7539         int retval;
7540
7541         const uint8_t *plaintext = NULL;
7542         const uint8_t *ciphertext = NULL;
7543         const uint8_t *digest = NULL;
7544         unsigned int plaintext_pad_len;
7545         unsigned int plaintext_len;
7546         unsigned int ciphertext_pad_len;
7547         unsigned int ciphertext_len;
7548         uint8_t buffer[10000];
7549         uint8_t digest_buffer[10000];
7550
7551         struct rte_cryptodev_info dev_info;
7552         struct rte_crypto_op *op;
7553
7554         /* Check if device supports particular algorithms */
7555         if (test_mixed_check_if_unsupported(tdata))
7556                 return TEST_SKIPPED;
7557         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
7558                 return TEST_SKIPPED;
7559
7560         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
7561
7562         uint64_t feat_flags = dev_info.feature_flags;
7563
7564         if (op_mode == IN_PLACE) {
7565                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
7566                         printf("Device doesn't support in-place scatter-gather "
7567                                         "in both input and output mbufs.\n");
7568                         return TEST_SKIPPED;
7569                 }
7570         } else {
7571                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
7572                         printf("Device doesn't support out-of-place scatter-gather "
7573                                         "in both input and output mbufs.\n");
7574                         return TEST_SKIPPED;
7575                 }
7576                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
7577                         printf("Device doesn't support digest encrypted.\n");
7578                         return TEST_SKIPPED;
7579                 }
7580         }
7581
7582         /* Create the session */
7583         if (verify)
7584                 retval = create_wireless_algo_cipher_auth_session(
7585                                 ts_params->valid_devs[0],
7586                                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
7587                                 RTE_CRYPTO_AUTH_OP_VERIFY,
7588                                 tdata->auth_algo,
7589                                 tdata->cipher_algo,
7590                                 tdata->auth_key.data, tdata->auth_key.len,
7591                                 tdata->auth_iv.len, tdata->digest_enc.len,
7592                                 tdata->cipher_iv.len);
7593         else
7594                 retval = create_wireless_algo_auth_cipher_session(
7595                                 ts_params->valid_devs[0],
7596                                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7597                                 RTE_CRYPTO_AUTH_OP_GENERATE,
7598                                 tdata->auth_algo,
7599                                 tdata->cipher_algo,
7600                                 tdata->auth_key.data, tdata->auth_key.len,
7601                                 tdata->auth_iv.len, tdata->digest_enc.len,
7602                                 tdata->cipher_iv.len);
7603         if (retval != 0)
7604                 return retval;
7605
7606         ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
7607         plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
7608         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
7609         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
7610
7611         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
7612                         ciphertext_pad_len, 15, 0);
7613         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
7614                         "Failed to allocate input buffer in mempool");
7615
7616         if (op_mode == OUT_OF_PLACE) {
7617                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
7618                                 plaintext_pad_len, 15, 0);
7619                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
7620                                 "Failed to allocate output buffer in mempool");
7621         }
7622
7623         if (verify) {
7624                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
7625                         tdata->ciphertext.data);
7626                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
7627                                         ciphertext_len, buffer);
7628                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7629                         ciphertext_len);
7630         } else {
7631                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
7632                         tdata->plaintext.data);
7633                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
7634                                         plaintext_len, buffer);
7635                 debug_hexdump(stdout, "plaintext:", plaintext,
7636                         plaintext_len);
7637         }
7638         memset(buffer, 0, sizeof(buffer));
7639
7640         /* Create the operation */
7641         retval = create_wireless_algo_auth_cipher_operation(
7642                         tdata->digest_enc.data, tdata->digest_enc.len,
7643                         tdata->cipher_iv.data, tdata->cipher_iv.len,
7644                         tdata->auth_iv.data, tdata->auth_iv.len,
7645                         (tdata->digest_enc.offset == 0 ?
7646                                 plaintext_pad_len
7647                                 : tdata->digest_enc.offset),
7648                         tdata->validCipherLen.len_bits,
7649                         tdata->cipher.offset_bits,
7650                         tdata->validAuthLen.len_bits,
7651                         tdata->auth.offset_bits,
7652                         op_mode, 1, verify);
7653
7654         if (retval < 0)
7655                 return retval;
7656
7657         op = process_crypto_request(ts_params->valid_devs[0], ut_params->op);
7658
7659         /* Check if the op failed because the device doesn't */
7660         /* support this particular combination of algorithms */
7661         if (op == NULL && ut_params->op->status ==
7662                         RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
7663                 printf("Device doesn't support this mixed combination. "
7664                                 "Test Skipped.\n");
7665                 return TEST_SKIPPED;
7666         }
7667         ut_params->op = op;
7668
7669         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
7670
7671         ut_params->obuf = (op_mode == IN_PLACE ?
7672                         ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
7673
7674         if (verify) {
7675                 if (ut_params->obuf)
7676                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
7677                                         plaintext_len, buffer);
7678                 else
7679                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
7680                                         plaintext_len, buffer);
7681
7682                 debug_hexdump(stdout, "plaintext:", plaintext,
7683                                 (tdata->plaintext.len_bits >> 3) -
7684                                 tdata->digest_enc.len);
7685                 debug_hexdump(stdout, "plaintext expected:",
7686                                 tdata->plaintext.data,
7687                                 (tdata->plaintext.len_bits >> 3) -
7688                                 tdata->digest_enc.len);
7689         } else {
7690                 if (ut_params->obuf)
7691                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
7692                                         ciphertext_len, buffer);
7693                 else
7694                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
7695                                         ciphertext_len, buffer);
7696
7697                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7698                         ciphertext_len);
7699                 debug_hexdump(stdout, "ciphertext expected:",
7700                         tdata->ciphertext.data,
7701                         tdata->ciphertext.len_bits >> 3);
7702
7703                 if (ut_params->obuf)
7704                         digest = rte_pktmbuf_read(ut_params->obuf,
7705                                         (tdata->digest_enc.offset == 0 ?
7706                                                 plaintext_pad_len :
7707                                                 tdata->digest_enc.offset),
7708                                         tdata->digest_enc.len, digest_buffer);
7709                 else
7710                         digest = rte_pktmbuf_read(ut_params->ibuf,
7711                                         (tdata->digest_enc.offset == 0 ?
7712                                                 plaintext_pad_len :
7713                                                 tdata->digest_enc.offset),
7714                                         tdata->digest_enc.len, digest_buffer);
7715
7716                 debug_hexdump(stdout, "digest:", digest,
7717                                 tdata->digest_enc.len);
7718                 debug_hexdump(stdout, "digest expected:",
7719                                 tdata->digest_enc.data, tdata->digest_enc.len);
7720         }
7721
7722         if (!verify) {
7723                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7724                                 digest,
7725                                 tdata->digest_enc.data,
7726                                 tdata->digest_enc.len,
7727                                 "Generated auth tag not as expected");
7728         }
7729
7730         if (tdata->cipher_algo != RTE_CRYPTO_CIPHER_NULL) {
7731                 if (verify) {
7732                         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7733                                         plaintext,
7734                                         tdata->plaintext.data,
7735                                         tdata->plaintext.len_bits >> 3,
7736                                         "Plaintext data not as expected");
7737                 } else {
7738                         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7739                                         ciphertext,
7740                                         tdata->ciphertext.data,
7741                                         tdata->validDataLen.len_bits,
7742                                         "Ciphertext data not as expected");
7743                 }
7744         }
7745
7746         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7747                         "crypto op processing failed");
7748
7749         return 0;
7750 }
7751
7752 /** AUTH AES CMAC + CIPHER AES CTR */
7753
7754 static int
7755 test_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7756 {
7757         return test_mixed_auth_cipher(
7758                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7759 }
7760
7761 static int
7762 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7763 {
7764         return test_mixed_auth_cipher(
7765                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7766 }
7767
7768 static int
7769 test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7770 {
7771         return test_mixed_auth_cipher_sgl(
7772                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7773 }
7774
7775 static int
7776 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7777 {
7778         return test_mixed_auth_cipher_sgl(
7779                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7780 }
7781
7782 static int
7783 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7784 {
7785         return test_mixed_auth_cipher(
7786                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7787 }
7788
7789 static int
7790 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7791 {
7792         return test_mixed_auth_cipher(
7793                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7794 }
7795
7796 static int
7797 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7798 {
7799         return test_mixed_auth_cipher_sgl(
7800                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7801 }
7802
7803 static int
7804 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7805 {
7806         return test_mixed_auth_cipher_sgl(
7807                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7808 }
7809
7810 /** MIXED AUTH + CIPHER */
7811
7812 static int
7813 test_auth_zuc_cipher_snow_test_case_1(void)
7814 {
7815         return test_mixed_auth_cipher(
7816                 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7817 }
7818
7819 static int
7820 test_verify_auth_zuc_cipher_snow_test_case_1(void)
7821 {
7822         return test_mixed_auth_cipher(
7823                 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7824 }
7825
7826 static int
7827 test_auth_aes_cmac_cipher_snow_test_case_1(void)
7828 {
7829         return test_mixed_auth_cipher(
7830                 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7831 }
7832
7833 static int
7834 test_verify_auth_aes_cmac_cipher_snow_test_case_1(void)
7835 {
7836         return test_mixed_auth_cipher(
7837                 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7838 }
7839
7840 static int
7841 test_auth_zuc_cipher_aes_ctr_test_case_1(void)
7842 {
7843         return test_mixed_auth_cipher(
7844                 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7845 }
7846
7847 static int
7848 test_verify_auth_zuc_cipher_aes_ctr_test_case_1(void)
7849 {
7850         return test_mixed_auth_cipher(
7851                 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7852 }
7853
7854 static int
7855 test_auth_snow_cipher_aes_ctr_test_case_1(void)
7856 {
7857         return test_mixed_auth_cipher(
7858                 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7859 }
7860
7861 static int
7862 test_verify_auth_snow_cipher_aes_ctr_test_case_1(void)
7863 {
7864         return test_mixed_auth_cipher(
7865                 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7866 }
7867
7868 static int
7869 test_auth_snow_cipher_zuc_test_case_1(void)
7870 {
7871         return test_mixed_auth_cipher(
7872                 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7873 }
7874
7875 static int
7876 test_verify_auth_snow_cipher_zuc_test_case_1(void)
7877 {
7878         return test_mixed_auth_cipher(
7879                 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7880 }
7881
7882 static int
7883 test_auth_aes_cmac_cipher_zuc_test_case_1(void)
7884 {
7885         return test_mixed_auth_cipher(
7886                 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7887 }
7888
7889 static int
7890 test_verify_auth_aes_cmac_cipher_zuc_test_case_1(void)
7891 {
7892         return test_mixed_auth_cipher(
7893                 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7894 }
7895
7896 static int
7897 test_auth_null_cipher_snow_test_case_1(void)
7898 {
7899         return test_mixed_auth_cipher(
7900                 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7901 }
7902
7903 static int
7904 test_verify_auth_null_cipher_snow_test_case_1(void)
7905 {
7906         return test_mixed_auth_cipher(
7907                 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7908 }
7909
7910 static int
7911 test_auth_null_cipher_zuc_test_case_1(void)
7912 {
7913         return test_mixed_auth_cipher(
7914                 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7915 }
7916
7917 static int
7918 test_verify_auth_null_cipher_zuc_test_case_1(void)
7919 {
7920         return test_mixed_auth_cipher(
7921                 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7922 }
7923
7924 static int
7925 test_auth_snow_cipher_null_test_case_1(void)
7926 {
7927         return test_mixed_auth_cipher(
7928                 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7929 }
7930
7931 static int
7932 test_verify_auth_snow_cipher_null_test_case_1(void)
7933 {
7934         return test_mixed_auth_cipher(
7935                 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7936 }
7937
7938 static int
7939 test_auth_zuc_cipher_null_test_case_1(void)
7940 {
7941         return test_mixed_auth_cipher(
7942                 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7943 }
7944
7945 static int
7946 test_verify_auth_zuc_cipher_null_test_case_1(void)
7947 {
7948         return test_mixed_auth_cipher(
7949                 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7950 }
7951
7952 static int
7953 test_auth_null_cipher_aes_ctr_test_case_1(void)
7954 {
7955         return test_mixed_auth_cipher(
7956                 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7957 }
7958
7959 static int
7960 test_verify_auth_null_cipher_aes_ctr_test_case_1(void)
7961 {
7962         return test_mixed_auth_cipher(
7963                 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7964 }
7965
7966 static int
7967 test_auth_aes_cmac_cipher_null_test_case_1(void)
7968 {
7969         return test_mixed_auth_cipher(
7970                 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7971 }
7972
7973 static int
7974 test_verify_auth_aes_cmac_cipher_null_test_case_1(void)
7975 {
7976         return test_mixed_auth_cipher(
7977                 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7978 }
7979
7980 /* ***** AEAD algorithm Tests ***** */
7981
7982 static int
7983 create_aead_session(uint8_t dev_id, enum rte_crypto_aead_algorithm algo,
7984                 enum rte_crypto_aead_operation op,
7985                 const uint8_t *key, const uint8_t key_len,
7986                 const uint16_t aad_len, const uint8_t auth_len,
7987                 uint8_t iv_len)
7988 {
7989         uint8_t aead_key[key_len];
7990         int status;
7991
7992         struct crypto_testsuite_params *ts_params = &testsuite_params;
7993         struct crypto_unittest_params *ut_params = &unittest_params;
7994
7995         memcpy(aead_key, key, key_len);
7996
7997         /* Setup AEAD Parameters */
7998         ut_params->aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD;
7999         ut_params->aead_xform.next = NULL;
8000         ut_params->aead_xform.aead.algo = algo;
8001         ut_params->aead_xform.aead.op = op;
8002         ut_params->aead_xform.aead.key.data = aead_key;
8003         ut_params->aead_xform.aead.key.length = key_len;
8004         ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
8005         ut_params->aead_xform.aead.iv.length = iv_len;
8006         ut_params->aead_xform.aead.digest_length = auth_len;
8007         ut_params->aead_xform.aead.aad_length = aad_len;
8008
8009         debug_hexdump(stdout, "key:", key, key_len);
8010
8011         /* Create Crypto session*/
8012         ut_params->sess = rte_cryptodev_sym_session_create(
8013                         ts_params->session_mpool);
8014         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
8015
8016         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
8017                         &ut_params->aead_xform,
8018                         ts_params->session_priv_mpool);
8019
8020         return status;
8021 }
8022
8023 static int
8024 create_aead_xform(struct rte_crypto_op *op,
8025                 enum rte_crypto_aead_algorithm algo,
8026                 enum rte_crypto_aead_operation aead_op,
8027                 uint8_t *key, const uint8_t key_len,
8028                 const uint8_t aad_len, const uint8_t auth_len,
8029                 uint8_t iv_len)
8030 {
8031         TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 1),
8032                         "failed to allocate space for crypto transform");
8033
8034         struct rte_crypto_sym_op *sym_op = op->sym;
8035
8036         /* Setup AEAD Parameters */
8037         sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_AEAD;
8038         sym_op->xform->next = NULL;
8039         sym_op->xform->aead.algo = algo;
8040         sym_op->xform->aead.op = aead_op;
8041         sym_op->xform->aead.key.data = key;
8042         sym_op->xform->aead.key.length = key_len;
8043         sym_op->xform->aead.iv.offset = IV_OFFSET;
8044         sym_op->xform->aead.iv.length = iv_len;
8045         sym_op->xform->aead.digest_length = auth_len;
8046         sym_op->xform->aead.aad_length = aad_len;
8047
8048         debug_hexdump(stdout, "key:", key, key_len);
8049
8050         return 0;
8051 }
8052
8053 static int
8054 create_aead_operation(enum rte_crypto_aead_operation op,
8055                 const struct aead_test_data *tdata)
8056 {
8057         struct crypto_testsuite_params *ts_params = &testsuite_params;
8058         struct crypto_unittest_params *ut_params = &unittest_params;
8059
8060         uint8_t *plaintext, *ciphertext;
8061         unsigned int aad_pad_len, plaintext_pad_len;
8062
8063         /* Generate Crypto op data structure */
8064         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8065                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8066         TEST_ASSERT_NOT_NULL(ut_params->op,
8067                         "Failed to allocate symmetric crypto operation struct");
8068
8069         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
8070
8071         /* Append aad data */
8072         if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
8073                 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len + 18, 16);
8074                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8075                                 aad_pad_len);
8076                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
8077                                 "no room to append aad");
8078
8079                 sym_op->aead.aad.phys_addr =
8080                                 rte_pktmbuf_iova(ut_params->ibuf);
8081                 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
8082                 memcpy(sym_op->aead.aad.data + 18, tdata->aad.data, tdata->aad.len);
8083                 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
8084                         tdata->aad.len);
8085
8086                 /* Append IV at the end of the crypto operation*/
8087                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
8088                                 uint8_t *, IV_OFFSET);
8089
8090                 /* Copy IV 1 byte after the IV pointer, according to the API */
8091                 rte_memcpy(iv_ptr + 1, tdata->iv.data, tdata->iv.len);
8092                 debug_hexdump(stdout, "iv:", iv_ptr,
8093                         tdata->iv.len);
8094         } else {
8095                 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
8096                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8097                                 aad_pad_len);
8098                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
8099                                 "no room to append aad");
8100
8101                 sym_op->aead.aad.phys_addr =
8102                                 rte_pktmbuf_iova(ut_params->ibuf);
8103                 memcpy(sym_op->aead.aad.data, tdata->aad.data, tdata->aad.len);
8104                 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
8105                         tdata->aad.len);
8106
8107                 /* Append IV at the end of the crypto operation*/
8108                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
8109                                 uint8_t *, IV_OFFSET);
8110
8111                 if (tdata->iv.len == 0) {
8112                         rte_memcpy(iv_ptr, tdata->iv.data, AES_GCM_J0_LENGTH);
8113                         debug_hexdump(stdout, "iv:", iv_ptr,
8114                                 AES_GCM_J0_LENGTH);
8115                 } else {
8116                         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
8117                         debug_hexdump(stdout, "iv:", iv_ptr,
8118                                 tdata->iv.len);
8119                 }
8120         }
8121
8122         /* Append plaintext/ciphertext */
8123         if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
8124                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
8125                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8126                                 plaintext_pad_len);
8127                 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
8128
8129                 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
8130                 debug_hexdump(stdout, "plaintext:", plaintext,
8131                                 tdata->plaintext.len);
8132
8133                 if (ut_params->obuf) {
8134                         ciphertext = (uint8_t *)rte_pktmbuf_append(
8135                                         ut_params->obuf,
8136                                         plaintext_pad_len + aad_pad_len);
8137                         TEST_ASSERT_NOT_NULL(ciphertext,
8138                                         "no room to append ciphertext");
8139
8140                         memset(ciphertext + aad_pad_len, 0,
8141                                         tdata->ciphertext.len);
8142                 }
8143         } else {
8144                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16);
8145                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8146                                 plaintext_pad_len);
8147                 TEST_ASSERT_NOT_NULL(ciphertext,
8148                                 "no room to append ciphertext");
8149
8150                 memcpy(ciphertext, tdata->ciphertext.data,
8151                                 tdata->ciphertext.len);
8152                 debug_hexdump(stdout, "ciphertext:", ciphertext,
8153                                 tdata->ciphertext.len);
8154
8155                 if (ut_params->obuf) {
8156                         plaintext = (uint8_t *)rte_pktmbuf_append(
8157                                         ut_params->obuf,
8158                                         plaintext_pad_len + aad_pad_len);
8159                         TEST_ASSERT_NOT_NULL(plaintext,
8160                                         "no room to append plaintext");
8161
8162                         memset(plaintext + aad_pad_len, 0,
8163                                         tdata->plaintext.len);
8164                 }
8165         }
8166
8167         /* Append digest data */
8168         if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
8169                 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
8170                                 ut_params->obuf ? ut_params->obuf :
8171                                                 ut_params->ibuf,
8172                                                 tdata->auth_tag.len);
8173                 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
8174                                 "no room to append digest");
8175                 memset(sym_op->aead.digest.data, 0, tdata->auth_tag.len);
8176                 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
8177                                 ut_params->obuf ? ut_params->obuf :
8178                                                 ut_params->ibuf,
8179                                                 plaintext_pad_len +
8180                                                 aad_pad_len);
8181         } else {
8182                 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
8183                                 ut_params->ibuf, tdata->auth_tag.len);
8184                 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
8185                                 "no room to append digest");
8186                 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
8187                                 ut_params->ibuf,
8188                                 plaintext_pad_len + aad_pad_len);
8189
8190                 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
8191                         tdata->auth_tag.len);
8192                 debug_hexdump(stdout, "digest:",
8193                         sym_op->aead.digest.data,
8194                         tdata->auth_tag.len);
8195         }
8196
8197         sym_op->aead.data.length = tdata->plaintext.len;
8198         sym_op->aead.data.offset = aad_pad_len;
8199
8200         return 0;
8201 }
8202
8203 static int
8204 test_authenticated_encryption(const struct aead_test_data *tdata)
8205 {
8206         struct crypto_testsuite_params *ts_params = &testsuite_params;
8207         struct crypto_unittest_params *ut_params = &unittest_params;
8208
8209         int retval;
8210         uint8_t *ciphertext, *auth_tag;
8211         uint16_t plaintext_pad_len;
8212         uint32_t i;
8213         struct rte_cryptodev_info dev_info;
8214
8215         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8216         uint64_t feat_flags = dev_info.feature_flags;
8217
8218         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
8219                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
8220                 printf("Device doesn't support RAW data-path APIs.\n");
8221                 return TEST_SKIPPED;
8222         }
8223
8224         /* Verify the capabilities */
8225         struct rte_cryptodev_sym_capability_idx cap_idx;
8226         const struct rte_cryptodev_symmetric_capability *capability;
8227         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
8228         cap_idx.algo.aead = tdata->algo;
8229         capability = rte_cryptodev_sym_capability_get(
8230                         ts_params->valid_devs[0], &cap_idx);
8231         if (capability == NULL)
8232                 return TEST_SKIPPED;
8233         if (rte_cryptodev_sym_capability_check_aead(
8234                         capability, tdata->key.len, tdata->auth_tag.len,
8235                         tdata->aad.len, tdata->iv.len))
8236                 return TEST_SKIPPED;
8237
8238         /* Create AEAD session */
8239         retval = create_aead_session(ts_params->valid_devs[0],
8240                         tdata->algo,
8241                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
8242                         tdata->key.data, tdata->key.len,
8243                         tdata->aad.len, tdata->auth_tag.len,
8244                         tdata->iv.len);
8245         if (retval < 0)
8246                 return retval;
8247
8248         if (tdata->aad.len > MBUF_SIZE) {
8249                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
8250                 /* Populate full size of add data */
8251                 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
8252                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
8253         } else
8254                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8255
8256         /* clear mbuf payload */
8257         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8258                         rte_pktmbuf_tailroom(ut_params->ibuf));
8259
8260         /* Create AEAD operation */
8261         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
8262         if (retval < 0)
8263                 return retval;
8264
8265         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
8266
8267         ut_params->op->sym->m_src = ut_params->ibuf;
8268
8269         /* Process crypto operation */
8270         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
8271                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
8272         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
8273                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
8274                                 ut_params->op, 0, 0, 0, 0);
8275         else
8276                 TEST_ASSERT_NOT_NULL(
8277                         process_crypto_request(ts_params->valid_devs[0],
8278                         ut_params->op), "failed to process sym crypto op");
8279
8280         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8281                         "crypto op processing failed");
8282
8283         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
8284
8285         if (ut_params->op->sym->m_dst) {
8286                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8287                                 uint8_t *);
8288                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
8289                                 uint8_t *, plaintext_pad_len);
8290         } else {
8291                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
8292                                 uint8_t *,
8293                                 ut_params->op->sym->cipher.data.offset);
8294                 auth_tag = ciphertext + plaintext_pad_len;
8295         }
8296
8297         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
8298         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
8299
8300         /* Validate obuf */
8301         TEST_ASSERT_BUFFERS_ARE_EQUAL(
8302                         ciphertext,
8303                         tdata->ciphertext.data,
8304                         tdata->ciphertext.len,
8305                         "Ciphertext data not as expected");
8306
8307         TEST_ASSERT_BUFFERS_ARE_EQUAL(
8308                         auth_tag,
8309                         tdata->auth_tag.data,
8310                         tdata->auth_tag.len,
8311                         "Generated auth tag not as expected");
8312
8313         return 0;
8314
8315 }
8316
8317 #ifdef RTE_LIB_SECURITY
8318 static int
8319 security_proto_supported(enum rte_security_session_action_type action,
8320         enum rte_security_session_protocol proto)
8321 {
8322         struct crypto_testsuite_params *ts_params = &testsuite_params;
8323
8324         const struct rte_security_capability *capabilities;
8325         const struct rte_security_capability *capability;
8326         uint16_t i = 0;
8327
8328         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8329                                 rte_cryptodev_get_sec_ctx(
8330                                 ts_params->valid_devs[0]);
8331
8332
8333         capabilities = rte_security_capabilities_get(ctx);
8334
8335         if (capabilities == NULL)
8336                 return -ENOTSUP;
8337
8338         while ((capability = &capabilities[i++])->action !=
8339                         RTE_SECURITY_ACTION_TYPE_NONE) {
8340                 if (capability->action == action &&
8341                                 capability->protocol == proto)
8342                         return 0;
8343         }
8344
8345         return -ENOTSUP;
8346 }
8347
8348 /* Basic algorithm run function for async inplace mode.
8349  * Creates a session from input parameters and runs one operation
8350  * on input_vec. Checks the output of the crypto operation against
8351  * output_vec.
8352  */
8353 static int test_pdcp_proto(int i, int oop, enum rte_crypto_cipher_operation opc,
8354                            enum rte_crypto_auth_operation opa,
8355                            const uint8_t *input_vec, unsigned int input_vec_len,
8356                            const uint8_t *output_vec,
8357                            unsigned int output_vec_len,
8358                            enum rte_crypto_cipher_algorithm cipher_alg,
8359                            const uint8_t *cipher_key, uint32_t cipher_key_len,
8360                            enum rte_crypto_auth_algorithm auth_alg,
8361                            const uint8_t *auth_key, uint32_t auth_key_len,
8362                            uint8_t bearer, enum rte_security_pdcp_domain domain,
8363                            uint8_t packet_direction, uint8_t sn_size,
8364                            uint32_t hfn, uint32_t hfn_threshold, uint8_t sdap)
8365 {
8366         struct crypto_testsuite_params *ts_params = &testsuite_params;
8367         struct crypto_unittest_params *ut_params = &unittest_params;
8368         uint8_t *plaintext;
8369         int ret = TEST_SUCCESS;
8370         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8371                                 rte_cryptodev_get_sec_ctx(
8372                                 ts_params->valid_devs[0]);
8373         struct rte_cryptodev_info dev_info;
8374         uint64_t feat_flags;
8375
8376         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8377         feat_flags = dev_info.feature_flags;
8378
8379         /* Verify the capabilities */
8380         struct rte_security_capability_idx sec_cap_idx;
8381
8382         sec_cap_idx.action = ut_params->type;
8383         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
8384         sec_cap_idx.pdcp.domain = domain;
8385         if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
8386                 return TEST_SKIPPED;
8387
8388         /* Generate test mbuf data */
8389         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8390
8391         /* clear mbuf payload */
8392         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8393                         rte_pktmbuf_tailroom(ut_params->ibuf));
8394
8395         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8396                                                   input_vec_len);
8397         memcpy(plaintext, input_vec, input_vec_len);
8398
8399         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
8400                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
8401                 printf("Device does not support RAW data-path APIs.\n");
8402                 return TEST_SKIPPED;
8403         }
8404         /* Out of place support */
8405         if (oop) {
8406                 /*
8407                  * For out-op-place we need to alloc another mbuf
8408                  */
8409                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8410                 rte_pktmbuf_append(ut_params->obuf, output_vec_len);
8411         }
8412
8413         /* Setup Cipher Parameters */
8414         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8415         ut_params->cipher_xform.cipher.algo = cipher_alg;
8416         ut_params->cipher_xform.cipher.op = opc;
8417         ut_params->cipher_xform.cipher.key.data = cipher_key;
8418         ut_params->cipher_xform.cipher.key.length = cipher_key_len;
8419         ut_params->cipher_xform.cipher.iv.length =
8420                                 packet_direction ? 4 : 0;
8421         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
8422
8423         /* Setup HMAC Parameters if ICV header is required */
8424         if (auth_alg != 0) {
8425                 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8426                 ut_params->auth_xform.next = NULL;
8427                 ut_params->auth_xform.auth.algo = auth_alg;
8428                 ut_params->auth_xform.auth.op = opa;
8429                 ut_params->auth_xform.auth.key.data = auth_key;
8430                 ut_params->auth_xform.auth.key.length = auth_key_len;
8431
8432                 ut_params->cipher_xform.next = &ut_params->auth_xform;
8433         } else {
8434                 ut_params->cipher_xform.next = NULL;
8435         }
8436
8437         struct rte_security_session_conf sess_conf = {
8438                 .action_type = ut_params->type,
8439                 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
8440                 {.pdcp = {
8441                         .bearer = bearer,
8442                         .domain = domain,
8443                         .pkt_dir = packet_direction,
8444                         .sn_size = sn_size,
8445                         .hfn = packet_direction ? 0 : hfn,
8446                         /**
8447                          * hfn can be set as pdcp_test_hfn[i]
8448                          * if hfn_ovrd is not set. Here, PDCP
8449                          * packet direction is just used to
8450                          * run half of the cases with session
8451                          * HFN and other half with per packet
8452                          * HFN.
8453                          */
8454                         .hfn_threshold = hfn_threshold,
8455                         .hfn_ovrd = packet_direction ? 1 : 0,
8456                         .sdap_enabled = sdap,
8457                 } },
8458                 .crypto_xform = &ut_params->cipher_xform
8459         };
8460
8461         /* Create security session */
8462         ut_params->sec_session = rte_security_session_create(ctx,
8463                                 &sess_conf, ts_params->session_mpool,
8464                                 ts_params->session_priv_mpool);
8465
8466         if (!ut_params->sec_session) {
8467                 printf("TestCase %s()-%d line %d failed %s: ",
8468                         __func__, i, __LINE__, "Failed to allocate session");
8469                 ret = TEST_FAILED;
8470                 goto on_err;
8471         }
8472
8473         /* Generate crypto op data structure */
8474         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8475                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8476         if (!ut_params->op) {
8477                 printf("TestCase %s()-%d line %d failed %s: ",
8478                         __func__, i, __LINE__,
8479                         "Failed to allocate symmetric crypto operation struct");
8480                 ret = TEST_FAILED;
8481                 goto on_err;
8482         }
8483
8484         uint32_t *per_pkt_hfn = rte_crypto_op_ctod_offset(ut_params->op,
8485                                         uint32_t *, IV_OFFSET);
8486         *per_pkt_hfn = packet_direction ? hfn : 0;
8487
8488         rte_security_attach_session(ut_params->op, ut_params->sec_session);
8489
8490         /* set crypto operation source mbuf */
8491         ut_params->op->sym->m_src = ut_params->ibuf;
8492         if (oop)
8493                 ut_params->op->sym->m_dst = ut_params->obuf;
8494
8495         /* Process crypto operation */
8496         if (global_api_test_type == CRYPTODEV_RAW_API_TEST) {
8497                 /* filling lengths */
8498                 ut_params->op->sym->cipher.data.length = ut_params->op->sym->m_src->pkt_len;
8499                 ut_params->op->sym->auth.data.length = ut_params->op->sym->m_src->pkt_len;
8500                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
8501                         ut_params->op, 1, 1, 0, 0);
8502         } else {
8503                 ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op);
8504         }
8505         if (ut_params->op == NULL) {
8506                 printf("TestCase %s()-%d line %d failed %s: ",
8507                         __func__, i, __LINE__,
8508                         "failed to process sym crypto op");
8509                 ret = TEST_FAILED;
8510                 goto on_err;
8511         }
8512
8513         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8514                 printf("TestCase %s()-%d line %d failed %s: ",
8515                         __func__, i, __LINE__, "crypto op processing failed");
8516                 ret = TEST_FAILED;
8517                 goto on_err;
8518         }
8519
8520         /* Validate obuf */
8521         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
8522                         uint8_t *);
8523         if (oop) {
8524                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8525                                 uint8_t *);
8526         }
8527
8528         if (memcmp(ciphertext, output_vec, output_vec_len)) {
8529                 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8530                 rte_hexdump(stdout, "encrypted", ciphertext, output_vec_len);
8531                 rte_hexdump(stdout, "reference", output_vec, output_vec_len);
8532                 ret = TEST_FAILED;
8533                 goto on_err;
8534         }
8535
8536 on_err:
8537         rte_crypto_op_free(ut_params->op);
8538         ut_params->op = NULL;
8539
8540         if (ut_params->sec_session)
8541                 rte_security_session_destroy(ctx, ut_params->sec_session);
8542         ut_params->sec_session = NULL;
8543
8544         rte_pktmbuf_free(ut_params->ibuf);
8545         ut_params->ibuf = NULL;
8546         if (oop) {
8547                 rte_pktmbuf_free(ut_params->obuf);
8548                 ut_params->obuf = NULL;
8549         }
8550
8551         return ret;
8552 }
8553
8554 static int
8555 test_pdcp_proto_SGL(int i, int oop,
8556         enum rte_crypto_cipher_operation opc,
8557         enum rte_crypto_auth_operation opa,
8558         uint8_t *input_vec,
8559         unsigned int input_vec_len,
8560         uint8_t *output_vec,
8561         unsigned int output_vec_len,
8562         uint32_t fragsz,
8563         uint32_t fragsz_oop)
8564 {
8565         struct crypto_testsuite_params *ts_params = &testsuite_params;
8566         struct crypto_unittest_params *ut_params = &unittest_params;
8567         uint8_t *plaintext;
8568         struct rte_mbuf *buf, *buf_oop = NULL;
8569         int ret = TEST_SUCCESS;
8570         int to_trn = 0;
8571         int to_trn_tbl[16];
8572         int segs = 1;
8573         unsigned int trn_data = 0;
8574         struct rte_cryptodev_info dev_info;
8575         uint64_t feat_flags;
8576         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8577                                 rte_cryptodev_get_sec_ctx(
8578                                 ts_params->valid_devs[0]);
8579         struct rte_mbuf *temp_mbuf;
8580
8581         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8582         feat_flags = dev_info.feature_flags;
8583
8584         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
8585                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
8586                 printf("Device does not support RAW data-path APIs.\n");
8587                 return -ENOTSUP;
8588         }
8589         /* Verify the capabilities */
8590         struct rte_security_capability_idx sec_cap_idx;
8591
8592         sec_cap_idx.action = ut_params->type;
8593         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
8594         sec_cap_idx.pdcp.domain = pdcp_test_params[i].domain;
8595         if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
8596                 return TEST_SKIPPED;
8597
8598         if (fragsz > input_vec_len)
8599                 fragsz = input_vec_len;
8600
8601         uint16_t plaintext_len = fragsz;
8602         uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
8603
8604         if (fragsz_oop > output_vec_len)
8605                 frag_size_oop = output_vec_len;
8606
8607         int ecx = 0;
8608         if (input_vec_len % fragsz != 0) {
8609                 if (input_vec_len / fragsz + 1 > 16)
8610                         return 1;
8611         } else if (input_vec_len / fragsz > 16)
8612                 return 1;
8613
8614         /* Out of place support */
8615         if (oop) {
8616                 /*
8617                  * For out-op-place we need to alloc another mbuf
8618                  */
8619                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8620                 rte_pktmbuf_append(ut_params->obuf, frag_size_oop);
8621                 buf_oop = ut_params->obuf;
8622         }
8623
8624         /* Generate test mbuf data */
8625         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8626
8627         /* clear mbuf payload */
8628         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8629                         rte_pktmbuf_tailroom(ut_params->ibuf));
8630
8631         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8632                                                   plaintext_len);
8633         memcpy(plaintext, input_vec, plaintext_len);
8634         trn_data += plaintext_len;
8635
8636         buf = ut_params->ibuf;
8637
8638         /*
8639          * Loop until no more fragments
8640          */
8641
8642         while (trn_data < input_vec_len) {
8643                 ++segs;
8644                 to_trn = (input_vec_len - trn_data < fragsz) ?
8645                                 (input_vec_len - trn_data) : fragsz;
8646
8647                 to_trn_tbl[ecx++] = to_trn;
8648
8649                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8650                 buf = buf->next;
8651
8652                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
8653                                 rte_pktmbuf_tailroom(buf));
8654
8655                 /* OOP */
8656                 if (oop && !fragsz_oop) {
8657                         buf_oop->next =
8658                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
8659                         buf_oop = buf_oop->next;
8660                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8661                                         0, rte_pktmbuf_tailroom(buf_oop));
8662                         rte_pktmbuf_append(buf_oop, to_trn);
8663                 }
8664
8665                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
8666                                 to_trn);
8667
8668                 memcpy(plaintext, input_vec + trn_data, to_trn);
8669                 trn_data += to_trn;
8670         }
8671
8672         ut_params->ibuf->nb_segs = segs;
8673
8674         segs = 1;
8675         if (fragsz_oop && oop) {
8676                 to_trn = 0;
8677                 ecx = 0;
8678
8679                 trn_data = frag_size_oop;
8680                 while (trn_data < output_vec_len) {
8681                         ++segs;
8682                         to_trn =
8683                                 (output_vec_len - trn_data <
8684                                                 frag_size_oop) ?
8685                                 (output_vec_len - trn_data) :
8686                                                 frag_size_oop;
8687
8688                         to_trn_tbl[ecx++] = to_trn;
8689
8690                         buf_oop->next =
8691                                 rte_pktmbuf_alloc(ts_params->mbuf_pool);
8692                         buf_oop = buf_oop->next;
8693                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8694                                         0, rte_pktmbuf_tailroom(buf_oop));
8695                         rte_pktmbuf_append(buf_oop, to_trn);
8696
8697                         trn_data += to_trn;
8698                 }
8699                 ut_params->obuf->nb_segs = segs;
8700         }
8701
8702         /* Setup Cipher Parameters */
8703         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8704         ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg;
8705         ut_params->cipher_xform.cipher.op = opc;
8706         ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i];
8707         ut_params->cipher_xform.cipher.key.length =
8708                                         pdcp_test_params[i].cipher_key_len;
8709         ut_params->cipher_xform.cipher.iv.length = 0;
8710
8711         /* Setup HMAC Parameters if ICV header is required */
8712         if (pdcp_test_params[i].auth_alg != 0) {
8713                 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8714                 ut_params->auth_xform.next = NULL;
8715                 ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg;
8716                 ut_params->auth_xform.auth.op = opa;
8717                 ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i];
8718                 ut_params->auth_xform.auth.key.length =
8719                                         pdcp_test_params[i].auth_key_len;
8720
8721                 ut_params->cipher_xform.next = &ut_params->auth_xform;
8722         } else {
8723                 ut_params->cipher_xform.next = NULL;
8724         }
8725
8726         struct rte_security_session_conf sess_conf = {
8727                 .action_type = ut_params->type,
8728                 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
8729                 {.pdcp = {
8730                         .bearer = pdcp_test_bearer[i],
8731                         .domain = pdcp_test_params[i].domain,
8732                         .pkt_dir = pdcp_test_packet_direction[i],
8733                         .sn_size = pdcp_test_data_sn_size[i],
8734                         .hfn = pdcp_test_hfn[i],
8735                         .hfn_threshold = pdcp_test_hfn_threshold[i],
8736                         .hfn_ovrd = 0,
8737                 } },
8738                 .crypto_xform = &ut_params->cipher_xform
8739         };
8740
8741         /* Create security session */
8742         ut_params->sec_session = rte_security_session_create(ctx,
8743                                 &sess_conf, ts_params->session_mpool,
8744                                 ts_params->session_priv_mpool);
8745
8746         if (!ut_params->sec_session) {
8747                 printf("TestCase %s()-%d line %d failed %s: ",
8748                         __func__, i, __LINE__, "Failed to allocate session");
8749                 ret = TEST_FAILED;
8750                 goto on_err;
8751         }
8752
8753         /* Generate crypto op data structure */
8754         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8755                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8756         if (!ut_params->op) {
8757                 printf("TestCase %s()-%d line %d failed %s: ",
8758                         __func__, i, __LINE__,
8759                         "Failed to allocate symmetric crypto operation struct");
8760                 ret = TEST_FAILED;
8761                 goto on_err;
8762         }
8763
8764         rte_security_attach_session(ut_params->op, ut_params->sec_session);
8765
8766         /* set crypto operation source mbuf */
8767         ut_params->op->sym->m_src = ut_params->ibuf;
8768         if (oop)
8769                 ut_params->op->sym->m_dst = ut_params->obuf;
8770
8771         /* Process crypto operation */
8772         temp_mbuf = ut_params->op->sym->m_src;
8773         if (global_api_test_type == CRYPTODEV_RAW_API_TEST) {
8774                 /* filling lengths */
8775                 while (temp_mbuf) {
8776                         ut_params->op->sym->cipher.data.length
8777                                 += temp_mbuf->pkt_len;
8778                         ut_params->op->sym->auth.data.length
8779                                 += temp_mbuf->pkt_len;
8780                         temp_mbuf = temp_mbuf->next;
8781                 }
8782                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
8783                         ut_params->op, 1, 1, 0, 0);
8784         } else {
8785                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
8786                                                         ut_params->op);
8787         }
8788         if (ut_params->op == NULL) {
8789                 printf("TestCase %s()-%d line %d failed %s: ",
8790                         __func__, i, __LINE__,
8791                         "failed to process sym crypto op");
8792                 ret = TEST_FAILED;
8793                 goto on_err;
8794         }
8795
8796         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8797                 printf("TestCase %s()-%d line %d failed %s: ",
8798                         __func__, i, __LINE__, "crypto op processing failed");
8799                 ret = TEST_FAILED;
8800                 goto on_err;
8801         }
8802
8803         /* Validate obuf */
8804         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
8805                         uint8_t *);
8806         if (oop) {
8807                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8808                                 uint8_t *);
8809         }
8810         if (fragsz_oop)
8811                 fragsz = frag_size_oop;
8812         if (memcmp(ciphertext, output_vec, fragsz)) {
8813                 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8814                 rte_hexdump(stdout, "encrypted", ciphertext, fragsz);
8815                 rte_hexdump(stdout, "reference", output_vec, fragsz);
8816                 ret = TEST_FAILED;
8817                 goto on_err;
8818         }
8819
8820         buf = ut_params->op->sym->m_src->next;
8821         if (oop)
8822                 buf = ut_params->op->sym->m_dst->next;
8823
8824         unsigned int off = fragsz;
8825
8826         ecx = 0;
8827         while (buf) {
8828                 ciphertext = rte_pktmbuf_mtod(buf,
8829                                 uint8_t *);
8830                 if (memcmp(ciphertext, output_vec + off, to_trn_tbl[ecx])) {
8831                         printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8832                         rte_hexdump(stdout, "encrypted", ciphertext, to_trn_tbl[ecx]);
8833                         rte_hexdump(stdout, "reference", output_vec + off,
8834                                         to_trn_tbl[ecx]);
8835                         ret = TEST_FAILED;
8836                         goto on_err;
8837                 }
8838                 off += to_trn_tbl[ecx++];
8839                 buf = buf->next;
8840         }
8841 on_err:
8842         rte_crypto_op_free(ut_params->op);
8843         ut_params->op = NULL;
8844
8845         if (ut_params->sec_session)
8846                 rte_security_session_destroy(ctx, ut_params->sec_session);
8847         ut_params->sec_session = NULL;
8848
8849         rte_pktmbuf_free(ut_params->ibuf);
8850         ut_params->ibuf = NULL;
8851         if (oop) {
8852                 rte_pktmbuf_free(ut_params->obuf);
8853                 ut_params->obuf = NULL;
8854         }
8855
8856         return ret;
8857 }
8858
8859 int
8860 test_pdcp_proto_cplane_encap(int i)
8861 {
8862         return test_pdcp_proto(
8863                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8864                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8865                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8866                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8867                 pdcp_test_params[i].cipher_key_len,
8868                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8869                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8870                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8871                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8872                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8873 }
8874
8875 int
8876 test_pdcp_proto_uplane_encap(int i)
8877 {
8878         return test_pdcp_proto(
8879                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8880                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8881                 pdcp_test_data_out[i], pdcp_test_data_in_len[i],
8882                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8883                 pdcp_test_params[i].cipher_key_len,
8884                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8885                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8886                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8887                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8888                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8889 }
8890
8891 int
8892 test_pdcp_proto_uplane_encap_with_int(int i)
8893 {
8894         return test_pdcp_proto(
8895                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8896                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8897                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8898                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8899                 pdcp_test_params[i].cipher_key_len,
8900                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8901                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8902                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8903                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8904                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8905 }
8906
8907 int
8908 test_pdcp_proto_cplane_decap(int i)
8909 {
8910         return test_pdcp_proto(
8911                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8912                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8913                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8914                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8915                 pdcp_test_params[i].cipher_key_len,
8916                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8917                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8918                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8919                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8920                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8921 }
8922
8923 int
8924 test_pdcp_proto_uplane_decap(int i)
8925 {
8926         return test_pdcp_proto(
8927                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8928                 pdcp_test_data_out[i], pdcp_test_data_in_len[i],
8929                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8930                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8931                 pdcp_test_params[i].cipher_key_len,
8932                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8933                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8934                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8935                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8936                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8937 }
8938
8939 int
8940 test_pdcp_proto_uplane_decap_with_int(int i)
8941 {
8942         return test_pdcp_proto(
8943                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8944                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8945                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8946                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8947                 pdcp_test_params[i].cipher_key_len,
8948                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8949                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8950                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8951                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8952                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8953 }
8954
8955 static int
8956 test_PDCP_PROTO_SGL_in_place_32B(void)
8957 {
8958         /* i can be used for running any PDCP case
8959          * In this case it is uplane 12-bit AES-SNOW DL encap
8960          */
8961         int i = PDCP_UPLANE_12BIT_OFFSET + AES_ENC + SNOW_AUTH + DOWNLINK;
8962         return test_pdcp_proto_SGL(i, IN_PLACE,
8963                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8964                         RTE_CRYPTO_AUTH_OP_GENERATE,
8965                         pdcp_test_data_in[i],
8966                         pdcp_test_data_in_len[i],
8967                         pdcp_test_data_out[i],
8968                         pdcp_test_data_in_len[i]+4,
8969                         32, 0);
8970 }
8971 static int
8972 test_PDCP_PROTO_SGL_oop_32B_128B(void)
8973 {
8974         /* i can be used for running any PDCP case
8975          * In this case it is uplane 18-bit NULL-NULL DL encap
8976          */
8977         int i = PDCP_UPLANE_18BIT_OFFSET + NULL_ENC + NULL_AUTH + DOWNLINK;
8978         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8979                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8980                         RTE_CRYPTO_AUTH_OP_GENERATE,
8981                         pdcp_test_data_in[i],
8982                         pdcp_test_data_in_len[i],
8983                         pdcp_test_data_out[i],
8984                         pdcp_test_data_in_len[i]+4,
8985                         32, 128);
8986 }
8987 static int
8988 test_PDCP_PROTO_SGL_oop_32B_40B(void)
8989 {
8990         /* i can be used for running any PDCP case
8991          * In this case it is uplane 18-bit AES DL encap
8992          */
8993         int i = PDCP_UPLANE_OFFSET + AES_ENC + EIGHTEEN_BIT_SEQ_NUM_OFFSET
8994                         + DOWNLINK;
8995         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8996                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8997                         RTE_CRYPTO_AUTH_OP_GENERATE,
8998                         pdcp_test_data_in[i],
8999                         pdcp_test_data_in_len[i],
9000                         pdcp_test_data_out[i],
9001                         pdcp_test_data_in_len[i],
9002                         32, 40);
9003 }
9004 static int
9005 test_PDCP_PROTO_SGL_oop_128B_32B(void)
9006 {
9007         /* i can be used for running any PDCP case
9008          * In this case it is cplane 12-bit AES-ZUC DL encap
9009          */
9010         int i = PDCP_CPLANE_LONG_SN_OFFSET + AES_ENC + ZUC_AUTH + DOWNLINK;
9011         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
9012                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
9013                         RTE_CRYPTO_AUTH_OP_GENERATE,
9014                         pdcp_test_data_in[i],
9015                         pdcp_test_data_in_len[i],
9016                         pdcp_test_data_out[i],
9017                         pdcp_test_data_in_len[i]+4,
9018                         128, 32);
9019 }
9020
9021 static int
9022 test_PDCP_SDAP_PROTO_encap_all(void)
9023 {
9024         int i = 0, size = 0;
9025         int err, all_err = TEST_SUCCESS;
9026         const struct pdcp_sdap_test *cur_test;
9027
9028         size = RTE_DIM(list_pdcp_sdap_tests);
9029
9030         for (i = 0; i < size; i++) {
9031                 cur_test = &list_pdcp_sdap_tests[i];
9032                 err = test_pdcp_proto(
9033                         i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT,
9034                         RTE_CRYPTO_AUTH_OP_GENERATE, cur_test->data_in,
9035                         cur_test->in_len, cur_test->data_out,
9036                         cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
9037                         cur_test->param.cipher_alg, cur_test->cipher_key,
9038                         cur_test->param.cipher_key_len,
9039                         cur_test->param.auth_alg,
9040                         cur_test->auth_key, cur_test->param.auth_key_len,
9041                         cur_test->bearer, cur_test->param.domain,
9042                         cur_test->packet_direction, cur_test->sn_size,
9043                         cur_test->hfn,
9044                         cur_test->hfn_threshold, SDAP_ENABLED);
9045                 if (err) {
9046                         printf("\t%d) %s: Encapsulation failed\n",
9047                                         cur_test->test_idx,
9048                                         cur_test->param.name);
9049                         err = TEST_FAILED;
9050                 } else {
9051                         printf("\t%d) %s: Encap PASS\n", cur_test->test_idx,
9052                                         cur_test->param.name);
9053                         err = TEST_SUCCESS;
9054                 }
9055                 all_err += err;
9056         }
9057
9058         printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
9059
9060         return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
9061 }
9062
9063 static int
9064 test_PDCP_PROTO_short_mac(void)
9065 {
9066         int i = 0, size = 0;
9067         int err, all_err = TEST_SUCCESS;
9068         const struct pdcp_short_mac_test *cur_test;
9069
9070         size = RTE_DIM(list_pdcp_smac_tests);
9071
9072         for (i = 0; i < size; i++) {
9073                 cur_test = &list_pdcp_smac_tests[i];
9074                 err = test_pdcp_proto(
9075                         i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT,
9076                         RTE_CRYPTO_AUTH_OP_GENERATE, cur_test->data_in,
9077                         cur_test->in_len, cur_test->data_out,
9078                         cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
9079                         RTE_CRYPTO_CIPHER_NULL, NULL,
9080                         0, cur_test->param.auth_alg,
9081                         cur_test->auth_key, cur_test->param.auth_key_len,
9082                         0, cur_test->param.domain, 0, 0,
9083                         0, 0, 0);
9084                 if (err) {
9085                         printf("\t%d) %s: Short MAC test failed\n",
9086                                         cur_test->test_idx,
9087                                         cur_test->param.name);
9088                         err = TEST_FAILED;
9089                 } else {
9090                         printf("\t%d) %s: Short MAC test PASS\n",
9091                                         cur_test->test_idx,
9092                                         cur_test->param.name);
9093                         rte_hexdump(stdout, "MAC I",
9094                                     cur_test->data_out + cur_test->in_len + 2,
9095                                     2);
9096                         err = TEST_SUCCESS;
9097                 }
9098                 all_err += err;
9099         }
9100
9101         printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
9102
9103         return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
9104
9105 }
9106
9107 static int
9108 test_PDCP_SDAP_PROTO_decap_all(void)
9109 {
9110         int i = 0, size = 0;
9111         int err, all_err = TEST_SUCCESS;
9112         const struct pdcp_sdap_test *cur_test;
9113
9114         size = RTE_DIM(list_pdcp_sdap_tests);
9115
9116         for (i = 0; i < size; i++) {
9117                 cur_test = &list_pdcp_sdap_tests[i];
9118                 err = test_pdcp_proto(
9119                         i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT,
9120                         RTE_CRYPTO_AUTH_OP_VERIFY,
9121                         cur_test->data_out,
9122                         cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
9123                         cur_test->data_in, cur_test->in_len,
9124                         cur_test->param.cipher_alg,
9125                         cur_test->cipher_key, cur_test->param.cipher_key_len,
9126                         cur_test->param.auth_alg, cur_test->auth_key,
9127                         cur_test->param.auth_key_len, cur_test->bearer,
9128                         cur_test->param.domain, cur_test->packet_direction,
9129                         cur_test->sn_size, cur_test->hfn,
9130                         cur_test->hfn_threshold, SDAP_ENABLED);
9131                 if (err) {
9132                         printf("\t%d) %s: Decapsulation failed\n",
9133                                         cur_test->test_idx,
9134                                         cur_test->param.name);
9135                         err = TEST_FAILED;
9136                 } else {
9137                         printf("\t%d) %s: Decap PASS\n", cur_test->test_idx,
9138                                         cur_test->param.name);
9139                         err = TEST_SUCCESS;
9140                 }
9141                 all_err += err;
9142         }
9143
9144         printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
9145
9146         return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
9147 }
9148
9149 static int
9150 test_ipsec_proto_process(const struct ipsec_test_data td[],
9151                          struct ipsec_test_data res_d[],
9152                          int nb_td,
9153                          bool silent,
9154                          const struct ipsec_test_flags *flags)
9155 {
9156         uint16_t v6_src[8] = {0x2607, 0xf8b0, 0x400c, 0x0c03, 0x0000, 0x0000,
9157                                 0x0000, 0x001a};
9158         uint16_t v6_dst[8] = {0x2001, 0x0470, 0xe5bf, 0xdead, 0x4957, 0x2174,
9159                                 0xe82c, 0x4887};
9160         const struct rte_ipv4_hdr *ipv4 =
9161                         (const struct rte_ipv4_hdr *)td[0].output_text.data;
9162         struct crypto_testsuite_params *ts_params = &testsuite_params;
9163         struct crypto_unittest_params *ut_params = &unittest_params;
9164         struct rte_security_capability_idx sec_cap_idx;
9165         const struct rte_security_capability *sec_cap;
9166         struct rte_security_ipsec_xform ipsec_xform;
9167         uint8_t dev_id = ts_params->valid_devs[0];
9168         enum rte_security_ipsec_sa_direction dir;
9169         struct ipsec_test_data *res_d_tmp = NULL;
9170         int salt_len, i, ret = TEST_SUCCESS;
9171         struct rte_security_ctx *ctx;
9172         uint8_t *input_text;
9173         uint32_t src, dst;
9174         uint32_t verify;
9175
9176         ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
9177         gbl_action_type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
9178
9179         /* Use first test data to create session */
9180
9181         /* Copy IPsec xform */
9182         memcpy(&ipsec_xform, &td[0].ipsec_xform, sizeof(ipsec_xform));
9183
9184         dir = ipsec_xform.direction;
9185         verify = flags->tunnel_hdr_verify;
9186
9187         memcpy(&src, &ipv4->src_addr, sizeof(ipv4->src_addr));
9188         memcpy(&dst, &ipv4->dst_addr, sizeof(ipv4->dst_addr));
9189
9190         if ((dir == RTE_SECURITY_IPSEC_SA_DIR_INGRESS) && verify) {
9191                 if (verify == RTE_SECURITY_IPSEC_TUNNEL_VERIFY_SRC_DST_ADDR)
9192                         src += 1;
9193                 else if (verify == RTE_SECURITY_IPSEC_TUNNEL_VERIFY_DST_ADDR)
9194                         dst += 1;
9195         }
9196
9197         if (td->ipsec_xform.mode == RTE_SECURITY_IPSEC_SA_MODE_TUNNEL) {
9198                 if (td->ipsec_xform.tunnel.type ==
9199                                 RTE_SECURITY_IPSEC_TUNNEL_IPV4) {
9200                         memcpy(&ipsec_xform.tunnel.ipv4.src_ip, &src,
9201                                sizeof(src));
9202                         memcpy(&ipsec_xform.tunnel.ipv4.dst_ip, &dst,
9203                                sizeof(dst));
9204
9205                         if (flags->df == TEST_IPSEC_SET_DF_0_INNER_1)
9206                                 ipsec_xform.tunnel.ipv4.df = 0;
9207
9208                         if (flags->df == TEST_IPSEC_SET_DF_1_INNER_0)
9209                                 ipsec_xform.tunnel.ipv4.df = 1;
9210
9211                         if (flags->dscp == TEST_IPSEC_SET_DSCP_0_INNER_1)
9212                                 ipsec_xform.tunnel.ipv4.dscp = 0;
9213
9214                         if (flags->dscp == TEST_IPSEC_SET_DSCP_1_INNER_0)
9215                                 ipsec_xform.tunnel.ipv4.dscp =
9216                                                 TEST_IPSEC_DSCP_VAL;
9217
9218                 } else {
9219                         if (flags->dscp == TEST_IPSEC_SET_DSCP_0_INNER_1)
9220                                 ipsec_xform.tunnel.ipv6.dscp = 0;
9221
9222                         if (flags->dscp == TEST_IPSEC_SET_DSCP_1_INNER_0)
9223                                 ipsec_xform.tunnel.ipv6.dscp =
9224                                                 TEST_IPSEC_DSCP_VAL;
9225
9226                         memcpy(&ipsec_xform.tunnel.ipv6.src_addr, &v6_src,
9227                                sizeof(v6_src));
9228                         memcpy(&ipsec_xform.tunnel.ipv6.dst_addr, &v6_dst,
9229                                sizeof(v6_dst));
9230                 }
9231         }
9232
9233         ctx = rte_cryptodev_get_sec_ctx(dev_id);
9234
9235         sec_cap_idx.action = ut_params->type;
9236         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_IPSEC;
9237         sec_cap_idx.ipsec.proto = ipsec_xform.proto;
9238         sec_cap_idx.ipsec.mode = ipsec_xform.mode;
9239         sec_cap_idx.ipsec.direction = ipsec_xform.direction;
9240
9241         if (flags->udp_encap)
9242                 ipsec_xform.options.udp_encap = 1;
9243
9244         sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
9245         if (sec_cap == NULL)
9246                 return TEST_SKIPPED;
9247
9248         /* Copy cipher session parameters */
9249         if (td[0].aead) {
9250                 memcpy(&ut_params->aead_xform, &td[0].xform.aead,
9251                        sizeof(ut_params->aead_xform));
9252                 ut_params->aead_xform.aead.key.data = td[0].key.data;
9253                 ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
9254
9255                 /* Verify crypto capabilities */
9256                 if (test_ipsec_crypto_caps_aead_verify(
9257                                 sec_cap,
9258                                 &ut_params->aead_xform) != 0) {
9259                         if (!silent)
9260                                 RTE_LOG(INFO, USER1,
9261                                         "Crypto capabilities not supported\n");
9262                         return TEST_SKIPPED;
9263                 }
9264         } else if (td[0].auth_only) {
9265                 memcpy(&ut_params->auth_xform, &td[0].xform.chain.auth,
9266                        sizeof(ut_params->auth_xform));
9267                 ut_params->auth_xform.auth.key.data = td[0].auth_key.data;
9268
9269                 if (test_ipsec_crypto_caps_auth_verify(
9270                                 sec_cap,
9271                                 &ut_params->auth_xform) != 0) {
9272                         if (!silent)
9273                                 RTE_LOG(INFO, USER1,
9274                                         "Auth crypto capabilities not supported\n");
9275                         return TEST_SKIPPED;
9276                 }
9277         } else {
9278                 memcpy(&ut_params->cipher_xform, &td[0].xform.chain.cipher,
9279                        sizeof(ut_params->cipher_xform));
9280                 memcpy(&ut_params->auth_xform, &td[0].xform.chain.auth,
9281                        sizeof(ut_params->auth_xform));
9282                 ut_params->cipher_xform.cipher.key.data = td[0].key.data;
9283                 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
9284                 ut_params->auth_xform.auth.key.data = td[0].auth_key.data;
9285
9286                 /* Verify crypto capabilities */
9287
9288                 if (test_ipsec_crypto_caps_cipher_verify(
9289                                 sec_cap,
9290                                 &ut_params->cipher_xform) != 0) {
9291                         if (!silent)
9292                                 RTE_LOG(INFO, USER1,
9293                                         "Cipher crypto capabilities not supported\n");
9294                         return TEST_SKIPPED;
9295                 }
9296
9297                 if (test_ipsec_crypto_caps_auth_verify(
9298                                 sec_cap,
9299                                 &ut_params->auth_xform) != 0) {
9300                         if (!silent)
9301                                 RTE_LOG(INFO, USER1,
9302                                         "Auth crypto capabilities not supported\n");
9303                         return TEST_SKIPPED;
9304                 }
9305         }
9306
9307         if (test_ipsec_sec_caps_verify(&ipsec_xform, sec_cap, silent) != 0)
9308                 return TEST_SKIPPED;
9309
9310         struct rte_security_session_conf sess_conf = {
9311                 .action_type = ut_params->type,
9312                 .protocol = RTE_SECURITY_PROTOCOL_IPSEC,
9313         };
9314
9315         if (td[0].aead || td[0].aes_gmac) {
9316                 salt_len = RTE_MIN(sizeof(ipsec_xform.salt), td[0].salt.len);
9317                 memcpy(&ipsec_xform.salt, td[0].salt.data, salt_len);
9318         }
9319
9320         if (td[0].aead) {
9321                 sess_conf.ipsec = ipsec_xform;
9322                 sess_conf.crypto_xform = &ut_params->aead_xform;
9323         } else if (td[0].auth_only) {
9324                 sess_conf.ipsec = ipsec_xform;
9325                 sess_conf.crypto_xform = &ut_params->auth_xform;
9326         } else {
9327                 sess_conf.ipsec = ipsec_xform;
9328                 if (dir == RTE_SECURITY_IPSEC_SA_DIR_EGRESS) {
9329                         sess_conf.crypto_xform = &ut_params->cipher_xform;
9330                         ut_params->cipher_xform.next = &ut_params->auth_xform;
9331                 } else {
9332                         sess_conf.crypto_xform = &ut_params->auth_xform;
9333                         ut_params->auth_xform.next = &ut_params->cipher_xform;
9334                 }
9335         }
9336
9337         /* Create security session */
9338         ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
9339                                         ts_params->session_mpool,
9340                                         ts_params->session_priv_mpool);
9341
9342         if (ut_params->sec_session == NULL)
9343                 return TEST_SKIPPED;
9344
9345         for (i = 0; i < nb_td; i++) {
9346                 if (flags->antireplay &&
9347                     (dir == RTE_SECURITY_IPSEC_SA_DIR_EGRESS)) {
9348                         sess_conf.ipsec.esn.value = td[i].ipsec_xform.esn.value;
9349                         ret = rte_security_session_update(ctx,
9350                                 ut_params->sec_session, &sess_conf);
9351                         if (ret) {
9352                                 printf("Could not update sequence number in "
9353                                        "session\n");
9354                                 return TEST_SKIPPED;
9355                         }
9356                 }
9357
9358                 /* Setup source mbuf payload */
9359                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9360                 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9361                                 rte_pktmbuf_tailroom(ut_params->ibuf));
9362
9363                 input_text = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9364                                 td[i].input_text.len);
9365
9366                 memcpy(input_text, td[i].input_text.data,
9367                        td[i].input_text.len);
9368
9369                 if (test_ipsec_pkt_update(input_text, flags))
9370                         return TEST_FAILED;
9371
9372                 /* Generate crypto op data structure */
9373                 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9374                                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9375                 if (!ut_params->op) {
9376                         printf("TestCase %s line %d: %s\n",
9377                                 __func__, __LINE__,
9378                                 "failed to allocate crypto op");
9379                         ret = TEST_FAILED;
9380                         goto crypto_op_free;
9381                 }
9382
9383                 /* Attach session to operation */
9384                 rte_security_attach_session(ut_params->op,
9385                                             ut_params->sec_session);
9386
9387                 /* Set crypto operation mbufs */
9388                 ut_params->op->sym->m_src = ut_params->ibuf;
9389                 ut_params->op->sym->m_dst = NULL;
9390
9391                 /* Copy IV in crypto operation when IV generation is disabled */
9392                 if (dir == RTE_SECURITY_IPSEC_SA_DIR_EGRESS &&
9393                     ipsec_xform.options.iv_gen_disable == 1) {
9394                         uint8_t *iv = rte_crypto_op_ctod_offset(ut_params->op,
9395                                                                 uint8_t *,
9396                                                                 IV_OFFSET);
9397                         int len;
9398
9399                         if (td[i].aead)
9400                                 len = td[i].xform.aead.aead.iv.length;
9401                         else if (td[i].aes_gmac)
9402                                 len = td[i].xform.chain.auth.auth.iv.length;
9403                         else
9404                                 len = td[i].xform.chain.cipher.cipher.iv.length;
9405
9406                         memcpy(iv, td[i].iv.data, len);
9407                 }
9408
9409                 /* Process crypto operation */
9410                 process_crypto_request(dev_id, ut_params->op);
9411
9412                 ret = test_ipsec_status_check(&td[i], ut_params->op, flags, dir,
9413                                               i + 1);
9414                 if (ret != TEST_SUCCESS)
9415                         goto crypto_op_free;
9416
9417                 if (res_d != NULL)
9418                         res_d_tmp = &res_d[i];
9419
9420                 ret = test_ipsec_post_process(ut_params->ibuf, &td[i],
9421                                               res_d_tmp, silent, flags);
9422                 if (ret != TEST_SUCCESS)
9423                         goto crypto_op_free;
9424
9425                 ret = test_ipsec_stats_verify(ctx, ut_params->sec_session,
9426                                               flags, dir);
9427                 if (ret != TEST_SUCCESS)
9428                         goto crypto_op_free;
9429
9430                 rte_crypto_op_free(ut_params->op);
9431                 ut_params->op = NULL;
9432
9433                 rte_pktmbuf_free(ut_params->ibuf);
9434                 ut_params->ibuf = NULL;
9435         }
9436
9437 crypto_op_free:
9438         rte_crypto_op_free(ut_params->op);
9439         ut_params->op = NULL;
9440
9441         rte_pktmbuf_free(ut_params->ibuf);
9442         ut_params->ibuf = NULL;
9443
9444         if (ut_params->sec_session)
9445                 rte_security_session_destroy(ctx, ut_params->sec_session);
9446         ut_params->sec_session = NULL;
9447
9448         return ret;
9449 }
9450
9451 static int
9452 test_ipsec_proto_known_vec(const void *test_data)
9453 {
9454         struct ipsec_test_data td_outb;
9455         struct ipsec_test_flags flags;
9456
9457         memset(&flags, 0, sizeof(flags));
9458
9459         memcpy(&td_outb, test_data, sizeof(td_outb));
9460
9461         if (td_outb.aes_gmac || td_outb.aead ||
9462             ((td_outb.ipsec_xform.proto != RTE_SECURITY_IPSEC_SA_PROTO_AH) &&
9463              (td_outb.xform.chain.cipher.cipher.algo != RTE_CRYPTO_CIPHER_NULL))) {
9464                 /* Disable IV gen to be able to test with known vectors */
9465                 td_outb.ipsec_xform.options.iv_gen_disable = 1;
9466         }
9467
9468         return test_ipsec_proto_process(&td_outb, NULL, 1, false, &flags);
9469 }
9470
9471 static int
9472 test_ipsec_proto_known_vec_inb(const void *test_data)
9473 {
9474         const struct ipsec_test_data *td = test_data;
9475         struct ipsec_test_flags flags;
9476         struct ipsec_test_data td_inb;
9477
9478         memset(&flags, 0, sizeof(flags));
9479
9480         if (td->ipsec_xform.direction == RTE_SECURITY_IPSEC_SA_DIR_EGRESS)
9481                 test_ipsec_td_in_from_out(td, &td_inb);
9482         else
9483                 memcpy(&td_inb, td, sizeof(td_inb));
9484
9485         return test_ipsec_proto_process(&td_inb, NULL, 1, false, &flags);
9486 }
9487
9488 static int
9489 test_ipsec_proto_known_vec_fragmented(const void *test_data)
9490 {
9491         struct ipsec_test_data td_outb;
9492         struct ipsec_test_flags flags;
9493
9494         memset(&flags, 0, sizeof(flags));
9495         flags.fragment = true;
9496
9497         memcpy(&td_outb, test_data, sizeof(td_outb));
9498
9499         /* Disable IV gen to be able to test with known vectors */
9500         td_outb.ipsec_xform.options.iv_gen_disable = 1;
9501
9502         return test_ipsec_proto_process(&td_outb, NULL, 1, false, &flags);
9503 }
9504
9505 static int
9506 test_ipsec_proto_all(const struct ipsec_test_flags *flags)
9507 {
9508         struct ipsec_test_data td_outb[IPSEC_TEST_PACKETS_MAX];
9509         struct ipsec_test_data td_inb[IPSEC_TEST_PACKETS_MAX];
9510         unsigned int i, nb_pkts = 1, pass_cnt = 0;
9511         int ret;
9512
9513         if (flags->iv_gen ||
9514             flags->sa_expiry_pkts_soft ||
9515             flags->sa_expiry_pkts_hard)
9516                 nb_pkts = IPSEC_TEST_PACKETS_MAX;
9517
9518         for (i = 0; i < RTE_DIM(alg_list); i++) {
9519                 test_ipsec_td_prepare(alg_list[i].param1,
9520                                       alg_list[i].param2,
9521                                       flags,
9522                                       td_outb,
9523                                       nb_pkts);
9524
9525                 if (!td_outb->aead) {
9526                         enum rte_crypto_cipher_algorithm cipher_alg;
9527                         enum rte_crypto_auth_algorithm auth_alg;
9528
9529                         cipher_alg = td_outb->xform.chain.cipher.cipher.algo;
9530                         auth_alg = td_outb->xform.chain.auth.auth.algo;
9531
9532                         if (td_outb->aes_gmac && cipher_alg != RTE_CRYPTO_CIPHER_NULL)
9533                                 continue;
9534
9535                         /* ICV is not applicable for NULL auth */
9536                         if (flags->icv_corrupt &&
9537                             auth_alg == RTE_CRYPTO_AUTH_NULL)
9538                                 continue;
9539
9540                         /* IV is not applicable for NULL cipher */
9541                         if (flags->iv_gen &&
9542                             cipher_alg == RTE_CRYPTO_CIPHER_NULL)
9543                                 continue;
9544                 }
9545
9546                 ret = test_ipsec_proto_process(td_outb, td_inb, nb_pkts, true,
9547                                                flags);
9548                 if (ret == TEST_SKIPPED)
9549                         continue;
9550
9551                 if (ret == TEST_FAILED)
9552                         return TEST_FAILED;
9553
9554                 test_ipsec_td_update(td_inb, td_outb, nb_pkts, flags);
9555
9556                 ret = test_ipsec_proto_process(td_inb, NULL, nb_pkts, true,
9557                                                flags);
9558                 if (ret == TEST_SKIPPED)
9559                         continue;
9560
9561                 if (ret == TEST_FAILED)
9562                         return TEST_FAILED;
9563
9564                 if (flags->display_alg)
9565                         test_ipsec_display_alg(alg_list[i].param1,
9566                                                alg_list[i].param2);
9567
9568                 pass_cnt++;
9569         }
9570
9571         if (pass_cnt > 0)
9572                 return TEST_SUCCESS;
9573         else
9574                 return TEST_SKIPPED;
9575 }
9576
9577 static int
9578 test_ipsec_ah_proto_all(const struct ipsec_test_flags *flags)
9579 {
9580         struct ipsec_test_data td_outb[IPSEC_TEST_PACKETS_MAX];
9581         struct ipsec_test_data td_inb[IPSEC_TEST_PACKETS_MAX];
9582         unsigned int i, nb_pkts = 1, pass_cnt = 0;
9583         int ret;
9584
9585         for (i = 0; i < RTE_DIM(ah_alg_list); i++) {
9586                 test_ipsec_td_prepare(ah_alg_list[i].param1,
9587                                       ah_alg_list[i].param2,
9588                                       flags,
9589                                       td_outb,
9590                                       nb_pkts);
9591
9592                 ret = test_ipsec_proto_process(td_outb, td_inb, nb_pkts, true,
9593                                                flags);
9594                 if (ret == TEST_SKIPPED)
9595                         continue;
9596
9597                 if (ret == TEST_FAILED)
9598                         return TEST_FAILED;
9599
9600                 test_ipsec_td_update(td_inb, td_outb, nb_pkts, flags);
9601
9602                 ret = test_ipsec_proto_process(td_inb, NULL, nb_pkts, true,
9603                                                flags);
9604                 if (ret == TEST_SKIPPED)
9605                         continue;
9606
9607                 if (ret == TEST_FAILED)
9608                         return TEST_FAILED;
9609
9610                 if (flags->display_alg)
9611                         test_ipsec_display_alg(ah_alg_list[i].param1,
9612                                                ah_alg_list[i].param2);
9613
9614                 pass_cnt++;
9615         }
9616
9617         if (pass_cnt > 0)
9618                 return TEST_SUCCESS;
9619         else
9620                 return TEST_SKIPPED;
9621 }
9622
9623 static int
9624 test_ipsec_proto_display_list(const void *data __rte_unused)
9625 {
9626         struct ipsec_test_flags flags;
9627
9628         memset(&flags, 0, sizeof(flags));
9629
9630         flags.display_alg = true;
9631
9632         return test_ipsec_proto_all(&flags);
9633 }
9634
9635 static int
9636 test_ipsec_proto_ah_tunnel_ipv4(const void *data __rte_unused)
9637 {
9638         struct ipsec_test_flags flags;
9639
9640         memset(&flags, 0, sizeof(flags));
9641
9642         flags.ah = true;
9643         flags.display_alg = true;
9644
9645         return test_ipsec_ah_proto_all(&flags);
9646 }
9647
9648 static int
9649 test_ipsec_proto_ah_transport_ipv4(const void *data __rte_unused)
9650 {
9651         struct ipsec_test_flags flags;
9652
9653         memset(&flags, 0, sizeof(flags));
9654
9655         flags.ah = true;
9656         flags.transport = true;
9657
9658         return test_ipsec_ah_proto_all(&flags);
9659 }
9660
9661 static int
9662 test_ipsec_proto_iv_gen(const void *data __rte_unused)
9663 {
9664         struct ipsec_test_flags flags;
9665
9666         memset(&flags, 0, sizeof(flags));
9667
9668         flags.iv_gen = true;
9669
9670         return test_ipsec_proto_all(&flags);
9671 }
9672
9673 static int
9674 test_ipsec_proto_sa_exp_pkts_soft(const void *data __rte_unused)
9675 {
9676         struct ipsec_test_flags flags;
9677
9678         memset(&flags, 0, sizeof(flags));
9679
9680         flags.sa_expiry_pkts_soft = true;
9681
9682         return test_ipsec_proto_all(&flags);
9683 }
9684
9685 static int
9686 test_ipsec_proto_sa_exp_pkts_hard(const void *data __rte_unused)
9687 {
9688         struct ipsec_test_flags flags;
9689
9690         memset(&flags, 0, sizeof(flags));
9691
9692         flags.sa_expiry_pkts_hard = true;
9693
9694         return test_ipsec_proto_all(&flags);
9695 }
9696
9697 static int
9698 test_ipsec_proto_err_icv_corrupt(const void *data __rte_unused)
9699 {
9700         struct ipsec_test_flags flags;
9701
9702         memset(&flags, 0, sizeof(flags));
9703
9704         flags.icv_corrupt = true;
9705
9706         return test_ipsec_proto_all(&flags);
9707 }
9708
9709 static int
9710 test_ipsec_proto_udp_encap(const void *data __rte_unused)
9711 {
9712         struct ipsec_test_flags flags;
9713
9714         memset(&flags, 0, sizeof(flags));
9715
9716         flags.udp_encap = true;
9717
9718         return test_ipsec_proto_all(&flags);
9719 }
9720
9721 static int
9722 test_ipsec_proto_tunnel_src_dst_addr_verify(const void *data __rte_unused)
9723 {
9724         struct ipsec_test_flags flags;
9725
9726         memset(&flags, 0, sizeof(flags));
9727
9728         flags.tunnel_hdr_verify = RTE_SECURITY_IPSEC_TUNNEL_VERIFY_SRC_DST_ADDR;
9729
9730         return test_ipsec_proto_all(&flags);
9731 }
9732
9733 static int
9734 test_ipsec_proto_tunnel_dst_addr_verify(const void *data __rte_unused)
9735 {
9736         struct ipsec_test_flags flags;
9737
9738         memset(&flags, 0, sizeof(flags));
9739
9740         flags.tunnel_hdr_verify = RTE_SECURITY_IPSEC_TUNNEL_VERIFY_DST_ADDR;
9741
9742         return test_ipsec_proto_all(&flags);
9743 }
9744
9745 static int
9746 test_ipsec_proto_udp_ports_verify(const void *data __rte_unused)
9747 {
9748         struct ipsec_test_flags flags;
9749
9750         memset(&flags, 0, sizeof(flags));
9751
9752         flags.udp_encap = true;
9753         flags.udp_ports_verify = true;
9754
9755         return test_ipsec_proto_all(&flags);
9756 }
9757
9758 static int
9759 test_ipsec_proto_inner_ip_csum(const void *data __rte_unused)
9760 {
9761         struct ipsec_test_flags flags;
9762
9763         memset(&flags, 0, sizeof(flags));
9764
9765         flags.ip_csum = true;
9766
9767         return test_ipsec_proto_all(&flags);
9768 }
9769
9770 static int
9771 test_ipsec_proto_inner_l4_csum(const void *data __rte_unused)
9772 {
9773         struct ipsec_test_flags flags;
9774
9775         memset(&flags, 0, sizeof(flags));
9776
9777         flags.l4_csum = true;
9778
9779         return test_ipsec_proto_all(&flags);
9780 }
9781
9782 static int
9783 test_ipsec_proto_tunnel_v4_in_v4(const void *data __rte_unused)
9784 {
9785         struct ipsec_test_flags flags;
9786
9787         memset(&flags, 0, sizeof(flags));
9788
9789         flags.ipv6 = false;
9790         flags.tunnel_ipv6 = false;
9791
9792         return test_ipsec_proto_all(&flags);
9793 }
9794
9795 static int
9796 test_ipsec_proto_tunnel_v6_in_v6(const void *data __rte_unused)
9797 {
9798         struct ipsec_test_flags flags;
9799
9800         memset(&flags, 0, sizeof(flags));
9801
9802         flags.ipv6 = true;
9803         flags.tunnel_ipv6 = true;
9804
9805         return test_ipsec_proto_all(&flags);
9806 }
9807
9808 static int
9809 test_ipsec_proto_tunnel_v4_in_v6(const void *data __rte_unused)
9810 {
9811         struct ipsec_test_flags flags;
9812
9813         memset(&flags, 0, sizeof(flags));
9814
9815         flags.ipv6 = false;
9816         flags.tunnel_ipv6 = true;
9817
9818         return test_ipsec_proto_all(&flags);
9819 }
9820
9821 static int
9822 test_ipsec_proto_tunnel_v6_in_v4(const void *data __rte_unused)
9823 {
9824         struct ipsec_test_flags flags;
9825
9826         memset(&flags, 0, sizeof(flags));
9827
9828         flags.ipv6 = true;
9829         flags.tunnel_ipv6 = false;
9830
9831         return test_ipsec_proto_all(&flags);
9832 }
9833
9834 static int
9835 test_ipsec_proto_transport_v4(const void *data __rte_unused)
9836 {
9837         struct ipsec_test_flags flags;
9838
9839         memset(&flags, 0, sizeof(flags));
9840
9841         flags.ipv6 = false;
9842         flags.transport = true;
9843
9844         return test_ipsec_proto_all(&flags);
9845 }
9846
9847 static int
9848 test_ipsec_proto_transport_l4_csum(const void *data __rte_unused)
9849 {
9850         struct ipsec_test_flags flags = {
9851                 .l4_csum = true,
9852                 .transport = true,
9853         };
9854
9855         return test_ipsec_proto_all(&flags);
9856 }
9857
9858 static int
9859 test_ipsec_proto_stats(const void *data __rte_unused)
9860 {
9861         struct ipsec_test_flags flags;
9862
9863         memset(&flags, 0, sizeof(flags));
9864
9865         flags.stats_success = true;
9866
9867         return test_ipsec_proto_all(&flags);
9868 }
9869
9870 static int
9871 test_ipsec_proto_pkt_fragment(const void *data __rte_unused)
9872 {
9873         struct ipsec_test_flags flags;
9874
9875         memset(&flags, 0, sizeof(flags));
9876
9877         flags.fragment = true;
9878
9879         return test_ipsec_proto_all(&flags);
9880
9881 }
9882
9883 static int
9884 test_ipsec_proto_copy_df_inner_0(const void *data __rte_unused)
9885 {
9886         struct ipsec_test_flags flags;
9887
9888         memset(&flags, 0, sizeof(flags));
9889
9890         flags.df = TEST_IPSEC_COPY_DF_INNER_0;
9891
9892         return test_ipsec_proto_all(&flags);
9893 }
9894
9895 static int
9896 test_ipsec_proto_copy_df_inner_1(const void *data __rte_unused)
9897 {
9898         struct ipsec_test_flags flags;
9899
9900         memset(&flags, 0, sizeof(flags));
9901
9902         flags.df = TEST_IPSEC_COPY_DF_INNER_1;
9903
9904         return test_ipsec_proto_all(&flags);
9905 }
9906
9907 static int
9908 test_ipsec_proto_set_df_0_inner_1(const void *data __rte_unused)
9909 {
9910         struct ipsec_test_flags flags;
9911
9912         memset(&flags, 0, sizeof(flags));
9913
9914         flags.df = TEST_IPSEC_SET_DF_0_INNER_1;
9915
9916         return test_ipsec_proto_all(&flags);
9917 }
9918
9919 static int
9920 test_ipsec_proto_set_df_1_inner_0(const void *data __rte_unused)
9921 {
9922         struct ipsec_test_flags flags;
9923
9924         memset(&flags, 0, sizeof(flags));
9925
9926         flags.df = TEST_IPSEC_SET_DF_1_INNER_0;
9927
9928         return test_ipsec_proto_all(&flags);
9929 }
9930
9931 static int
9932 test_ipsec_proto_ipv4_copy_dscp_inner_0(const void *data __rte_unused)
9933 {
9934         struct ipsec_test_flags flags;
9935
9936         memset(&flags, 0, sizeof(flags));
9937
9938         flags.dscp = TEST_IPSEC_COPY_DSCP_INNER_0;
9939
9940         return test_ipsec_proto_all(&flags);
9941 }
9942
9943 static int
9944 test_ipsec_proto_ipv4_copy_dscp_inner_1(const void *data __rte_unused)
9945 {
9946         struct ipsec_test_flags flags;
9947
9948         memset(&flags, 0, sizeof(flags));
9949
9950         flags.dscp = TEST_IPSEC_COPY_DSCP_INNER_1;
9951
9952         return test_ipsec_proto_all(&flags);
9953 }
9954
9955 static int
9956 test_ipsec_proto_ipv4_set_dscp_0_inner_1(const void *data __rte_unused)
9957 {
9958         struct ipsec_test_flags flags;
9959
9960         if (gbl_driver_id == rte_cryptodev_driver_id_get(
9961                         RTE_STR(CRYPTODEV_NAME_CN9K_PMD)))
9962                 return TEST_SKIPPED;
9963
9964         memset(&flags, 0, sizeof(flags));
9965
9966         flags.dscp = TEST_IPSEC_SET_DSCP_0_INNER_1;
9967
9968         return test_ipsec_proto_all(&flags);
9969 }
9970
9971 static int
9972 test_ipsec_proto_ipv4_set_dscp_1_inner_0(const void *data __rte_unused)
9973 {
9974         struct ipsec_test_flags flags;
9975
9976         if (gbl_driver_id == rte_cryptodev_driver_id_get(
9977                         RTE_STR(CRYPTODEV_NAME_CN9K_PMD)))
9978                 return TEST_SKIPPED;
9979
9980         memset(&flags, 0, sizeof(flags));
9981
9982         flags.dscp = TEST_IPSEC_SET_DSCP_1_INNER_0;
9983
9984         return test_ipsec_proto_all(&flags);
9985 }
9986
9987 static int
9988 test_ipsec_proto_ipv6_copy_dscp_inner_0(const void *data __rte_unused)
9989 {
9990         struct ipsec_test_flags flags;
9991
9992         memset(&flags, 0, sizeof(flags));
9993
9994         flags.ipv6 = true;
9995         flags.tunnel_ipv6 = true;
9996         flags.dscp = TEST_IPSEC_COPY_DSCP_INNER_0;
9997
9998         return test_ipsec_proto_all(&flags);
9999 }
10000
10001 static int
10002 test_ipsec_proto_ipv6_copy_dscp_inner_1(const void *data __rte_unused)
10003 {
10004         struct ipsec_test_flags flags;
10005
10006         memset(&flags, 0, sizeof(flags));
10007
10008         flags.ipv6 = true;
10009         flags.tunnel_ipv6 = true;
10010         flags.dscp = TEST_IPSEC_COPY_DSCP_INNER_1;
10011
10012         return test_ipsec_proto_all(&flags);
10013 }
10014
10015 static int
10016 test_ipsec_proto_ipv6_set_dscp_0_inner_1(const void *data __rte_unused)
10017 {
10018         struct ipsec_test_flags flags;
10019
10020         if (gbl_driver_id == rte_cryptodev_driver_id_get(
10021                         RTE_STR(CRYPTODEV_NAME_CN9K_PMD)))
10022                 return TEST_SKIPPED;
10023
10024         memset(&flags, 0, sizeof(flags));
10025
10026         flags.ipv6 = true;
10027         flags.tunnel_ipv6 = true;
10028         flags.dscp = TEST_IPSEC_SET_DSCP_0_INNER_1;
10029
10030         return test_ipsec_proto_all(&flags);
10031 }
10032
10033 static int
10034 test_ipsec_proto_ipv6_set_dscp_1_inner_0(const void *data __rte_unused)
10035 {
10036         struct ipsec_test_flags flags;
10037
10038         if (gbl_driver_id == rte_cryptodev_driver_id_get(
10039                         RTE_STR(CRYPTODEV_NAME_CN9K_PMD)))
10040                 return TEST_SKIPPED;
10041
10042         memset(&flags, 0, sizeof(flags));
10043
10044         flags.ipv6 = true;
10045         flags.tunnel_ipv6 = true;
10046         flags.dscp = TEST_IPSEC_SET_DSCP_1_INNER_0;
10047
10048         return test_ipsec_proto_all(&flags);
10049 }
10050
10051 static int
10052 test_ipsec_pkt_replay(const void *test_data, const uint64_t esn[],
10053                       bool replayed_pkt[], uint32_t nb_pkts, bool esn_en,
10054                       uint64_t winsz)
10055 {
10056         struct ipsec_test_data td_outb[IPSEC_TEST_PACKETS_MAX];
10057         struct ipsec_test_data td_inb[IPSEC_TEST_PACKETS_MAX];
10058         struct ipsec_test_flags flags;
10059         uint32_t i = 0, ret = 0;
10060
10061         memset(&flags, 0, sizeof(flags));
10062         flags.antireplay = true;
10063
10064         for (i = 0; i < nb_pkts; i++) {
10065                 memcpy(&td_outb[i], test_data, sizeof(td_outb[i]));
10066                 td_outb[i].ipsec_xform.options.iv_gen_disable = 1;
10067                 td_outb[i].ipsec_xform.replay_win_sz = winsz;
10068                 td_outb[i].ipsec_xform.options.esn = esn_en;
10069         }
10070
10071         for (i = 0; i < nb_pkts; i++)
10072                 td_outb[i].ipsec_xform.esn.value = esn[i];
10073
10074         ret = test_ipsec_proto_process(td_outb, td_inb, nb_pkts, true,
10075                                        &flags);
10076         if (ret != TEST_SUCCESS)
10077                 return ret;
10078
10079         test_ipsec_td_update(td_inb, td_outb, nb_pkts, &flags);
10080
10081         for (i = 0; i < nb_pkts; i++) {
10082                 td_inb[i].ipsec_xform.options.esn = esn_en;
10083                 /* Set antireplay flag for packets to be dropped */
10084                 td_inb[i].ar_packet = replayed_pkt[i];
10085         }
10086
10087         ret = test_ipsec_proto_process(td_inb, NULL, nb_pkts, true,
10088                                        &flags);
10089
10090         return ret;
10091 }
10092
10093 static int
10094 test_ipsec_proto_pkt_antireplay(const void *test_data, uint64_t winsz)
10095 {
10096
10097         uint32_t nb_pkts = 5;
10098         bool replayed_pkt[5];
10099         uint64_t esn[5];
10100
10101         /* 1. Advance the TOP of the window to WS * 2 */
10102         esn[0] = winsz * 2;
10103         /* 2. Test sequence number within the new window(WS + 1) */
10104         esn[1] = winsz + 1;
10105         /* 3. Test sequence number less than the window BOTTOM */
10106         esn[2] = winsz;
10107         /* 4. Test sequence number in the middle of the window */
10108         esn[3] = winsz + (winsz / 2);
10109         /* 5. Test replay of the packet in the middle of the window */
10110         esn[4] = winsz + (winsz / 2);
10111
10112         replayed_pkt[0] = false;
10113         replayed_pkt[1] = false;
10114         replayed_pkt[2] = true;
10115         replayed_pkt[3] = false;
10116         replayed_pkt[4] = true;
10117
10118         return test_ipsec_pkt_replay(test_data, esn, replayed_pkt, nb_pkts,
10119                                      false, winsz);
10120 }
10121
10122 static int
10123 test_ipsec_proto_pkt_antireplay1024(const void *test_data)
10124 {
10125         return test_ipsec_proto_pkt_antireplay(test_data, 1024);
10126 }
10127
10128 static int
10129 test_ipsec_proto_pkt_antireplay2048(const void *test_data)
10130 {
10131         return test_ipsec_proto_pkt_antireplay(test_data, 2048);
10132 }
10133
10134 static int
10135 test_ipsec_proto_pkt_antireplay4096(const void *test_data)
10136 {
10137         return test_ipsec_proto_pkt_antireplay(test_data, 4096);
10138 }
10139
10140 static int
10141 test_ipsec_proto_pkt_esn_antireplay(const void *test_data, uint64_t winsz)
10142 {
10143
10144         uint32_t nb_pkts = 7;
10145         bool replayed_pkt[7];
10146         uint64_t esn[7];
10147
10148         /* Set the initial sequence number */
10149         esn[0] = (uint64_t)(0xFFFFFFFF - winsz);
10150         /* 1. Advance the TOP of the window to (1<<32 + WS/2) */
10151         esn[1] = (uint64_t)((1ULL << 32) + (winsz / 2));
10152         /* 2. Test sequence number within new window (1<<32 + WS/2 + 1) */
10153         esn[2] = (uint64_t)((1ULL << 32) - (winsz / 2) + 1);
10154         /* 3. Test with sequence number within window (1<<32 - 1) */
10155         esn[3] = (uint64_t)((1ULL << 32) - 1);
10156         /* 4. Test with sequence number within window (1<<32 - 1) */
10157         esn[4] = (uint64_t)(1ULL << 32);
10158         /* 5. Test with duplicate sequence number within
10159          * new window (1<<32 - 1)
10160          */
10161         esn[5] = (uint64_t)((1ULL << 32) - 1);
10162         /* 6. Test with duplicate sequence number within new window (1<<32) */
10163         esn[6] = (uint64_t)(1ULL << 32);
10164
10165         replayed_pkt[0] = false;
10166         replayed_pkt[1] = false;
10167         replayed_pkt[2] = false;
10168         replayed_pkt[3] = false;
10169         replayed_pkt[4] = false;
10170         replayed_pkt[5] = true;
10171         replayed_pkt[6] = true;
10172
10173         return test_ipsec_pkt_replay(test_data, esn, replayed_pkt, nb_pkts,
10174                                      true, winsz);
10175 }
10176
10177 static int
10178 test_ipsec_proto_pkt_esn_antireplay1024(const void *test_data)
10179 {
10180         return test_ipsec_proto_pkt_esn_antireplay(test_data, 1024);
10181 }
10182
10183 static int
10184 test_ipsec_proto_pkt_esn_antireplay2048(const void *test_data)
10185 {
10186         return test_ipsec_proto_pkt_esn_antireplay(test_data, 2048);
10187 }
10188
10189 static int
10190 test_ipsec_proto_pkt_esn_antireplay4096(const void *test_data)
10191 {
10192         return test_ipsec_proto_pkt_esn_antireplay(test_data, 4096);
10193 }
10194
10195 static int
10196 test_PDCP_PROTO_all(void)
10197 {
10198         struct crypto_testsuite_params *ts_params = &testsuite_params;
10199         struct crypto_unittest_params *ut_params = &unittest_params;
10200         struct rte_cryptodev_info dev_info;
10201         int status;
10202
10203         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10204         uint64_t feat_flags = dev_info.feature_flags;
10205
10206         if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY))
10207                 return TEST_SKIPPED;
10208
10209         /* Set action type */
10210         ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
10211                 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
10212                 gbl_action_type;
10213
10214         if (security_proto_supported(ut_params->type,
10215                         RTE_SECURITY_PROTOCOL_PDCP) < 0)
10216                 return TEST_SKIPPED;
10217
10218         status = test_PDCP_PROTO_cplane_encap_all();
10219         status += test_PDCP_PROTO_cplane_decap_all();
10220         status += test_PDCP_PROTO_uplane_encap_all();
10221         status += test_PDCP_PROTO_uplane_decap_all();
10222         status += test_PDCP_PROTO_SGL_in_place_32B();
10223         status += test_PDCP_PROTO_SGL_oop_32B_128B();
10224         status += test_PDCP_PROTO_SGL_oop_32B_40B();
10225         status += test_PDCP_PROTO_SGL_oop_128B_32B();
10226         status += test_PDCP_SDAP_PROTO_encap_all();
10227         status += test_PDCP_SDAP_PROTO_decap_all();
10228         status += test_PDCP_PROTO_short_mac();
10229
10230         if (status)
10231                 return TEST_FAILED;
10232         else
10233                 return TEST_SUCCESS;
10234 }
10235
10236 static int
10237 test_ipsec_proto_ipv4_ttl_decrement(const void *data __rte_unused)
10238 {
10239         struct ipsec_test_flags flags = {
10240                 .dec_ttl_or_hop_limit = true
10241         };
10242
10243         return test_ipsec_proto_all(&flags);
10244 }
10245
10246 static int
10247 test_ipsec_proto_ipv6_hop_limit_decrement(const void *data __rte_unused)
10248 {
10249         struct ipsec_test_flags flags = {
10250                 .ipv6 = true,
10251                 .dec_ttl_or_hop_limit = true
10252         };
10253
10254         return test_ipsec_proto_all(&flags);
10255 }
10256
10257 static int
10258 test_docsis_proto_uplink(const void *data)
10259 {
10260         const struct docsis_test_data *d_td = data;
10261         struct crypto_testsuite_params *ts_params = &testsuite_params;
10262         struct crypto_unittest_params *ut_params = &unittest_params;
10263         uint8_t *plaintext = NULL;
10264         uint8_t *ciphertext = NULL;
10265         uint8_t *iv_ptr;
10266         int32_t cipher_len, crc_len;
10267         uint32_t crc_data_len;
10268         int ret = TEST_SUCCESS;
10269
10270         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
10271                                         rte_cryptodev_get_sec_ctx(
10272                                                 ts_params->valid_devs[0]);
10273
10274         /* Verify the capabilities */
10275         struct rte_security_capability_idx sec_cap_idx;
10276         const struct rte_security_capability *sec_cap;
10277         const struct rte_cryptodev_capabilities *crypto_cap;
10278         const struct rte_cryptodev_symmetric_capability *sym_cap;
10279         int j = 0;
10280
10281         /* Set action type */
10282         ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
10283                 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
10284                 gbl_action_type;
10285
10286         if (security_proto_supported(ut_params->type,
10287                         RTE_SECURITY_PROTOCOL_DOCSIS) < 0)
10288                 return TEST_SKIPPED;
10289
10290         sec_cap_idx.action = ut_params->type;
10291         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
10292         sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_UPLINK;
10293
10294         sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
10295         if (sec_cap == NULL)
10296                 return TEST_SKIPPED;
10297
10298         while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
10299                         RTE_CRYPTO_OP_TYPE_UNDEFINED) {
10300                 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
10301                                 crypto_cap->sym.xform_type ==
10302                                         RTE_CRYPTO_SYM_XFORM_CIPHER &&
10303                                 crypto_cap->sym.cipher.algo ==
10304                                         RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
10305                         sym_cap = &crypto_cap->sym;
10306                         if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
10307                                                 d_td->key.len,
10308                                                 d_td->iv.len) == 0)
10309                                 break;
10310                 }
10311         }
10312
10313         if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
10314                 return TEST_SKIPPED;
10315
10316         /* Setup source mbuf payload */
10317         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10318         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10319                         rte_pktmbuf_tailroom(ut_params->ibuf));
10320
10321         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
10322                         d_td->ciphertext.len);
10323
10324         memcpy(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len);
10325
10326         /* Setup cipher session parameters */
10327         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10328         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
10329         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
10330         ut_params->cipher_xform.cipher.key.data = d_td->key.data;
10331         ut_params->cipher_xform.cipher.key.length = d_td->key.len;
10332         ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
10333         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
10334         ut_params->cipher_xform.next = NULL;
10335
10336         /* Setup DOCSIS session parameters */
10337         ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_UPLINK;
10338
10339         struct rte_security_session_conf sess_conf = {
10340                 .action_type = ut_params->type,
10341                 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
10342                 .docsis = ut_params->docsis_xform,
10343                 .crypto_xform = &ut_params->cipher_xform,
10344         };
10345
10346         /* Create security session */
10347         ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
10348                                         ts_params->session_mpool,
10349                                         ts_params->session_priv_mpool);
10350
10351         if (!ut_params->sec_session) {
10352                 printf("Test function %s line %u: failed to allocate session\n",
10353                         __func__, __LINE__);
10354                 ret = TEST_FAILED;
10355                 goto on_err;
10356         }
10357
10358         /* Generate crypto op data structure */
10359         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10360                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10361         if (!ut_params->op) {
10362                 printf("Test function %s line %u: failed to allocate symmetric "
10363                         "crypto operation\n", __func__, __LINE__);
10364                 ret = TEST_FAILED;
10365                 goto on_err;
10366         }
10367
10368         /* Setup CRC operation parameters */
10369         crc_len = d_td->ciphertext.no_crc == false ?
10370                         (d_td->ciphertext.len -
10371                                 d_td->ciphertext.crc_offset -
10372                                 RTE_ETHER_CRC_LEN) :
10373                         0;
10374         crc_len = crc_len > 0 ? crc_len : 0;
10375         crc_data_len = crc_len == 0 ? 0 : RTE_ETHER_CRC_LEN;
10376         ut_params->op->sym->auth.data.length = crc_len;
10377         ut_params->op->sym->auth.data.offset = d_td->ciphertext.crc_offset;
10378
10379         /* Setup cipher operation parameters */
10380         cipher_len = d_td->ciphertext.no_cipher == false ?
10381                         (d_td->ciphertext.len -
10382                                 d_td->ciphertext.cipher_offset) :
10383                         0;
10384         cipher_len = cipher_len > 0 ? cipher_len : 0;
10385         ut_params->op->sym->cipher.data.length = cipher_len;
10386         ut_params->op->sym->cipher.data.offset = d_td->ciphertext.cipher_offset;
10387
10388         /* Setup cipher IV */
10389         iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
10390         rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
10391
10392         /* Attach session to operation */
10393         rte_security_attach_session(ut_params->op, ut_params->sec_session);
10394
10395         /* Set crypto operation mbufs */
10396         ut_params->op->sym->m_src = ut_params->ibuf;
10397         ut_params->op->sym->m_dst = NULL;
10398
10399         /* Process crypto operation */
10400         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
10401                         NULL) {
10402                 printf("Test function %s line %u: failed to process security "
10403                         "crypto op\n", __func__, __LINE__);
10404                 ret = TEST_FAILED;
10405                 goto on_err;
10406         }
10407
10408         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
10409                 printf("Test function %s line %u: failed to process crypto op\n",
10410                         __func__, __LINE__);
10411                 ret = TEST_FAILED;
10412                 goto on_err;
10413         }
10414
10415         /* Validate plaintext */
10416         plaintext = ciphertext;
10417
10418         if (memcmp(plaintext, d_td->plaintext.data,
10419                         d_td->plaintext.len - crc_data_len)) {
10420                 printf("Test function %s line %u: plaintext not as expected\n",
10421                         __func__, __LINE__);
10422                 rte_hexdump(stdout, "expected", d_td->plaintext.data,
10423                                 d_td->plaintext.len);
10424                 rte_hexdump(stdout, "actual", plaintext, d_td->plaintext.len);
10425                 ret = TEST_FAILED;
10426                 goto on_err;
10427         }
10428
10429 on_err:
10430         rte_crypto_op_free(ut_params->op);
10431         ut_params->op = NULL;
10432
10433         if (ut_params->sec_session)
10434                 rte_security_session_destroy(ctx, ut_params->sec_session);
10435         ut_params->sec_session = NULL;
10436
10437         rte_pktmbuf_free(ut_params->ibuf);
10438         ut_params->ibuf = NULL;
10439
10440         return ret;
10441 }
10442
10443 static int
10444 test_docsis_proto_downlink(const void *data)
10445 {
10446         const struct docsis_test_data *d_td = data;
10447         struct crypto_testsuite_params *ts_params = &testsuite_params;
10448         struct crypto_unittest_params *ut_params = &unittest_params;
10449         uint8_t *plaintext = NULL;
10450         uint8_t *ciphertext = NULL;
10451         uint8_t *iv_ptr;
10452         int32_t cipher_len, crc_len;
10453         int ret = TEST_SUCCESS;
10454
10455         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
10456                                         rte_cryptodev_get_sec_ctx(
10457                                                 ts_params->valid_devs[0]);
10458
10459         /* Verify the capabilities */
10460         struct rte_security_capability_idx sec_cap_idx;
10461         const struct rte_security_capability *sec_cap;
10462         const struct rte_cryptodev_capabilities *crypto_cap;
10463         const struct rte_cryptodev_symmetric_capability *sym_cap;
10464         int j = 0;
10465
10466         /* Set action type */
10467         ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
10468                 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
10469                 gbl_action_type;
10470
10471         if (security_proto_supported(ut_params->type,
10472                         RTE_SECURITY_PROTOCOL_DOCSIS) < 0)
10473                 return TEST_SKIPPED;
10474
10475         sec_cap_idx.action = ut_params->type;
10476         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
10477         sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
10478
10479         sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
10480         if (sec_cap == NULL)
10481                 return TEST_SKIPPED;
10482
10483         while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
10484                         RTE_CRYPTO_OP_TYPE_UNDEFINED) {
10485                 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
10486                                 crypto_cap->sym.xform_type ==
10487                                         RTE_CRYPTO_SYM_XFORM_CIPHER &&
10488                                 crypto_cap->sym.cipher.algo ==
10489                                         RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
10490                         sym_cap = &crypto_cap->sym;
10491                         if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
10492                                                 d_td->key.len,
10493                                                 d_td->iv.len) == 0)
10494                                 break;
10495                 }
10496         }
10497
10498         if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
10499                 return TEST_SKIPPED;
10500
10501         /* Setup source mbuf payload */
10502         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10503         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10504                         rte_pktmbuf_tailroom(ut_params->ibuf));
10505
10506         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
10507                         d_td->plaintext.len);
10508
10509         memcpy(plaintext, d_td->plaintext.data, d_td->plaintext.len);
10510
10511         /* Setup cipher session parameters */
10512         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10513         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
10514         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
10515         ut_params->cipher_xform.cipher.key.data = d_td->key.data;
10516         ut_params->cipher_xform.cipher.key.length = d_td->key.len;
10517         ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
10518         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
10519         ut_params->cipher_xform.next = NULL;
10520
10521         /* Setup DOCSIS session parameters */
10522         ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
10523
10524         struct rte_security_session_conf sess_conf = {
10525                 .action_type = ut_params->type,
10526                 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
10527                 .docsis = ut_params->docsis_xform,
10528                 .crypto_xform = &ut_params->cipher_xform,
10529         };
10530
10531         /* Create security session */
10532         ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
10533                                         ts_params->session_mpool,
10534                                         ts_params->session_priv_mpool);
10535
10536         if (!ut_params->sec_session) {
10537                 printf("Test function %s line %u: failed to allocate session\n",
10538                         __func__, __LINE__);
10539                 ret = TEST_FAILED;
10540                 goto on_err;
10541         }
10542
10543         /* Generate crypto op data structure */
10544         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10545                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10546         if (!ut_params->op) {
10547                 printf("Test function %s line %u: failed to allocate symmetric "
10548                         "crypto operation\n", __func__, __LINE__);
10549                 ret = TEST_FAILED;
10550                 goto on_err;
10551         }
10552
10553         /* Setup CRC operation parameters */
10554         crc_len = d_td->plaintext.no_crc == false ?
10555                         (d_td->plaintext.len -
10556                                 d_td->plaintext.crc_offset -
10557                                 RTE_ETHER_CRC_LEN) :
10558                         0;
10559         crc_len = crc_len > 0 ? crc_len : 0;
10560         ut_params->op->sym->auth.data.length = crc_len;
10561         ut_params->op->sym->auth.data.offset = d_td->plaintext.crc_offset;
10562
10563         /* Setup cipher operation parameters */
10564         cipher_len = d_td->plaintext.no_cipher == false ?
10565                         (d_td->plaintext.len -
10566                                 d_td->plaintext.cipher_offset) :
10567                         0;
10568         cipher_len = cipher_len > 0 ? cipher_len : 0;
10569         ut_params->op->sym->cipher.data.length = cipher_len;
10570         ut_params->op->sym->cipher.data.offset = d_td->plaintext.cipher_offset;
10571
10572         /* Setup cipher IV */
10573         iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
10574         rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
10575
10576         /* Attach session to operation */
10577         rte_security_attach_session(ut_params->op, ut_params->sec_session);
10578
10579         /* Set crypto operation mbufs */
10580         ut_params->op->sym->m_src = ut_params->ibuf;
10581         ut_params->op->sym->m_dst = NULL;
10582
10583         /* Process crypto operation */
10584         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
10585                         NULL) {
10586                 printf("Test function %s line %u: failed to process crypto op\n",
10587                         __func__, __LINE__);
10588                 ret = TEST_FAILED;
10589                 goto on_err;
10590         }
10591
10592         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
10593                 printf("Test function %s line %u: crypto op processing failed\n",
10594                         __func__, __LINE__);
10595                 ret = TEST_FAILED;
10596                 goto on_err;
10597         }
10598
10599         /* Validate ciphertext */
10600         ciphertext = plaintext;
10601
10602         if (memcmp(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len)) {
10603                 printf("Test function %s line %u: plaintext not as expected\n",
10604                         __func__, __LINE__);
10605                 rte_hexdump(stdout, "expected", d_td->ciphertext.data,
10606                                 d_td->ciphertext.len);
10607                 rte_hexdump(stdout, "actual", ciphertext, d_td->ciphertext.len);
10608                 ret = TEST_FAILED;
10609                 goto on_err;
10610         }
10611
10612 on_err:
10613         rte_crypto_op_free(ut_params->op);
10614         ut_params->op = NULL;
10615
10616         if (ut_params->sec_session)
10617                 rte_security_session_destroy(ctx, ut_params->sec_session);
10618         ut_params->sec_session = NULL;
10619
10620         rte_pktmbuf_free(ut_params->ibuf);
10621         ut_params->ibuf = NULL;
10622
10623         return ret;
10624 }
10625 #endif
10626
10627 static int
10628 test_AES_GCM_authenticated_encryption_test_case_1(void)
10629 {
10630         return test_authenticated_encryption(&gcm_test_case_1);
10631 }
10632
10633 static int
10634 test_AES_GCM_authenticated_encryption_test_case_2(void)
10635 {
10636         return test_authenticated_encryption(&gcm_test_case_2);
10637 }
10638
10639 static int
10640 test_AES_GCM_authenticated_encryption_test_case_3(void)
10641 {
10642         return test_authenticated_encryption(&gcm_test_case_3);
10643 }
10644
10645 static int
10646 test_AES_GCM_authenticated_encryption_test_case_4(void)
10647 {
10648         return test_authenticated_encryption(&gcm_test_case_4);
10649 }
10650
10651 static int
10652 test_AES_GCM_authenticated_encryption_test_case_5(void)
10653 {
10654         return test_authenticated_encryption(&gcm_test_case_5);
10655 }
10656
10657 static int
10658 test_AES_GCM_authenticated_encryption_test_case_6(void)
10659 {
10660         return test_authenticated_encryption(&gcm_test_case_6);
10661 }
10662
10663 static int
10664 test_AES_GCM_authenticated_encryption_test_case_7(void)
10665 {
10666         return test_authenticated_encryption(&gcm_test_case_7);
10667 }
10668
10669 static int
10670 test_AES_GCM_authenticated_encryption_test_case_8(void)
10671 {
10672         return test_authenticated_encryption(&gcm_test_case_8);
10673 }
10674
10675 static int
10676 test_AES_GCM_J0_authenticated_encryption_test_case_1(void)
10677 {
10678         return test_authenticated_encryption(&gcm_J0_test_case_1);
10679 }
10680
10681 static int
10682 test_AES_GCM_auth_encryption_test_case_192_1(void)
10683 {
10684         return test_authenticated_encryption(&gcm_test_case_192_1);
10685 }
10686
10687 static int
10688 test_AES_GCM_auth_encryption_test_case_192_2(void)
10689 {
10690         return test_authenticated_encryption(&gcm_test_case_192_2);
10691 }
10692
10693 static int
10694 test_AES_GCM_auth_encryption_test_case_192_3(void)
10695 {
10696         return test_authenticated_encryption(&gcm_test_case_192_3);
10697 }
10698
10699 static int
10700 test_AES_GCM_auth_encryption_test_case_192_4(void)
10701 {
10702         return test_authenticated_encryption(&gcm_test_case_192_4);
10703 }
10704
10705 static int
10706 test_AES_GCM_auth_encryption_test_case_192_5(void)
10707 {
10708         return test_authenticated_encryption(&gcm_test_case_192_5);
10709 }
10710
10711 static int
10712 test_AES_GCM_auth_encryption_test_case_192_6(void)
10713 {
10714         return test_authenticated_encryption(&gcm_test_case_192_6);
10715 }
10716
10717 static int
10718 test_AES_GCM_auth_encryption_test_case_192_7(void)
10719 {
10720         return test_authenticated_encryption(&gcm_test_case_192_7);
10721 }
10722
10723 static int
10724 test_AES_GCM_auth_encryption_test_case_256_1(void)
10725 {
10726         return test_authenticated_encryption(&gcm_test_case_256_1);
10727 }
10728
10729 static int
10730 test_AES_GCM_auth_encryption_test_case_256_2(void)
10731 {
10732         return test_authenticated_encryption(&gcm_test_case_256_2);
10733 }
10734
10735 static int
10736 test_AES_GCM_auth_encryption_test_case_256_3(void)
10737 {
10738         return test_authenticated_encryption(&gcm_test_case_256_3);
10739 }
10740
10741 static int
10742 test_AES_GCM_auth_encryption_test_case_256_4(void)
10743 {
10744         return test_authenticated_encryption(&gcm_test_case_256_4);
10745 }
10746
10747 static int
10748 test_AES_GCM_auth_encryption_test_case_256_5(void)
10749 {
10750         return test_authenticated_encryption(&gcm_test_case_256_5);
10751 }
10752
10753 static int
10754 test_AES_GCM_auth_encryption_test_case_256_6(void)
10755 {
10756         return test_authenticated_encryption(&gcm_test_case_256_6);
10757 }
10758
10759 static int
10760 test_AES_GCM_auth_encryption_test_case_256_7(void)
10761 {
10762         return test_authenticated_encryption(&gcm_test_case_256_7);
10763 }
10764
10765 static int
10766 test_AES_GCM_auth_encryption_test_case_aad_1(void)
10767 {
10768         return test_authenticated_encryption(&gcm_test_case_aad_1);
10769 }
10770
10771 static int
10772 test_AES_GCM_auth_encryption_test_case_aad_2(void)
10773 {
10774         return test_authenticated_encryption(&gcm_test_case_aad_2);
10775 }
10776
10777 static int
10778 test_AES_GCM_auth_encryption_fail_iv_corrupt(void)
10779 {
10780         struct aead_test_data tdata;
10781         int res;
10782
10783         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10784         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10785         tdata.iv.data[0] += 1;
10786         res = test_authenticated_encryption(&tdata);
10787         if (res == TEST_SKIPPED)
10788                 return res;
10789         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10790         return TEST_SUCCESS;
10791 }
10792
10793 static int
10794 test_AES_GCM_auth_encryption_fail_in_data_corrupt(void)
10795 {
10796         struct aead_test_data tdata;
10797         int res;
10798
10799         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10800         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10801         tdata.plaintext.data[0] += 1;
10802         res = test_authenticated_encryption(&tdata);
10803         if (res == TEST_SKIPPED)
10804                 return res;
10805         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10806         return TEST_SUCCESS;
10807 }
10808
10809 static int
10810 test_AES_GCM_auth_encryption_fail_out_data_corrupt(void)
10811 {
10812         struct aead_test_data tdata;
10813         int res;
10814
10815         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10816         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10817         tdata.ciphertext.data[0] += 1;
10818         res = test_authenticated_encryption(&tdata);
10819         if (res == TEST_SKIPPED)
10820                 return res;
10821         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10822         return TEST_SUCCESS;
10823 }
10824
10825 static int
10826 test_AES_GCM_auth_encryption_fail_aad_len_corrupt(void)
10827 {
10828         struct aead_test_data tdata;
10829         int res;
10830
10831         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10832         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10833         tdata.aad.len += 1;
10834         res = test_authenticated_encryption(&tdata);
10835         if (res == TEST_SKIPPED)
10836                 return res;
10837         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10838         return TEST_SUCCESS;
10839 }
10840
10841 static int
10842 test_AES_GCM_auth_encryption_fail_aad_corrupt(void)
10843 {
10844         struct aead_test_data tdata;
10845         uint8_t aad[gcm_test_case_7.aad.len];
10846         int res;
10847
10848         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10849         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10850         memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
10851         aad[0] += 1;
10852         tdata.aad.data = aad;
10853         res = test_authenticated_encryption(&tdata);
10854         if (res == TEST_SKIPPED)
10855                 return res;
10856         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10857         return TEST_SUCCESS;
10858 }
10859
10860 static int
10861 test_AES_GCM_auth_encryption_fail_tag_corrupt(void)
10862 {
10863         struct aead_test_data tdata;
10864         int res;
10865
10866         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10867         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10868         tdata.auth_tag.data[0] += 1;
10869         res = test_authenticated_encryption(&tdata);
10870         if (res == TEST_SKIPPED)
10871                 return res;
10872         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10873         return TEST_SUCCESS;
10874 }
10875
10876 static int
10877 test_authenticated_decryption(const struct aead_test_data *tdata)
10878 {
10879         struct crypto_testsuite_params *ts_params = &testsuite_params;
10880         struct crypto_unittest_params *ut_params = &unittest_params;
10881
10882         int retval;
10883         uint8_t *plaintext;
10884         uint32_t i;
10885         struct rte_cryptodev_info dev_info;
10886
10887         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10888         uint64_t feat_flags = dev_info.feature_flags;
10889
10890         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10891                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10892                 printf("Device doesn't support RAW data-path APIs.\n");
10893                 return TEST_SKIPPED;
10894         }
10895
10896         /* Verify the capabilities */
10897         struct rte_cryptodev_sym_capability_idx cap_idx;
10898         const struct rte_cryptodev_symmetric_capability *capability;
10899         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10900         cap_idx.algo.aead = tdata->algo;
10901         capability = rte_cryptodev_sym_capability_get(
10902                         ts_params->valid_devs[0], &cap_idx);
10903         if (capability == NULL)
10904                 return TEST_SKIPPED;
10905         if (rte_cryptodev_sym_capability_check_aead(
10906                         capability, tdata->key.len, tdata->auth_tag.len,
10907                         tdata->aad.len, tdata->iv.len))
10908                 return TEST_SKIPPED;
10909
10910         /* Create AEAD session */
10911         retval = create_aead_session(ts_params->valid_devs[0],
10912                         tdata->algo,
10913                         RTE_CRYPTO_AEAD_OP_DECRYPT,
10914                         tdata->key.data, tdata->key.len,
10915                         tdata->aad.len, tdata->auth_tag.len,
10916                         tdata->iv.len);
10917         if (retval < 0)
10918                 return retval;
10919
10920         /* alloc mbuf and set payload */
10921         if (tdata->aad.len > MBUF_SIZE) {
10922                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
10923                 /* Populate full size of add data */
10924                 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
10925                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
10926         } else
10927                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10928
10929         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10930                         rte_pktmbuf_tailroom(ut_params->ibuf));
10931
10932         /* Create AEAD operation */
10933         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
10934         if (retval < 0)
10935                 return retval;
10936
10937         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10938
10939         ut_params->op->sym->m_src = ut_params->ibuf;
10940
10941         /* Process crypto operation */
10942         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10943                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
10944         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10945                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10946                                 ut_params->op, 0, 0, 0, 0);
10947         else
10948                 TEST_ASSERT_NOT_NULL(
10949                         process_crypto_request(ts_params->valid_devs[0],
10950                         ut_params->op), "failed to process sym crypto op");
10951
10952         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10953                         "crypto op processing failed");
10954
10955         if (ut_params->op->sym->m_dst)
10956                 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
10957                                 uint8_t *);
10958         else
10959                 plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
10960                                 uint8_t *,
10961                                 ut_params->op->sym->cipher.data.offset);
10962
10963         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
10964
10965         /* Validate obuf */
10966         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10967                         plaintext,
10968                         tdata->plaintext.data,
10969                         tdata->plaintext.len,
10970                         "Plaintext data not as expected");
10971
10972         TEST_ASSERT_EQUAL(ut_params->op->status,
10973                         RTE_CRYPTO_OP_STATUS_SUCCESS,
10974                         "Authentication failed");
10975
10976         return 0;
10977 }
10978
10979 static int
10980 test_AES_GCM_authenticated_decryption_test_case_1(void)
10981 {
10982         return test_authenticated_decryption(&gcm_test_case_1);
10983 }
10984
10985 static int
10986 test_AES_GCM_authenticated_decryption_test_case_2(void)
10987 {
10988         return test_authenticated_decryption(&gcm_test_case_2);
10989 }
10990
10991 static int
10992 test_AES_GCM_authenticated_decryption_test_case_3(void)
10993 {
10994         return test_authenticated_decryption(&gcm_test_case_3);
10995 }
10996
10997 static int
10998 test_AES_GCM_authenticated_decryption_test_case_4(void)
10999 {
11000         return test_authenticated_decryption(&gcm_test_case_4);
11001 }
11002
11003 static int
11004 test_AES_GCM_authenticated_decryption_test_case_5(void)
11005 {
11006         return test_authenticated_decryption(&gcm_test_case_5);
11007 }
11008
11009 static int
11010 test_AES_GCM_authenticated_decryption_test_case_6(void)
11011 {
11012         return test_authenticated_decryption(&gcm_test_case_6);
11013 }
11014
11015 static int
11016 test_AES_GCM_authenticated_decryption_test_case_7(void)
11017 {
11018         return test_authenticated_decryption(&gcm_test_case_7);
11019 }
11020
11021 static int
11022 test_AES_GCM_authenticated_decryption_test_case_8(void)
11023 {
11024         return test_authenticated_decryption(&gcm_test_case_8);
11025 }
11026
11027 static int
11028 test_AES_GCM_J0_authenticated_decryption_test_case_1(void)
11029 {
11030         return test_authenticated_decryption(&gcm_J0_test_case_1);
11031 }
11032
11033 static int
11034 test_AES_GCM_auth_decryption_test_case_192_1(void)
11035 {
11036         return test_authenticated_decryption(&gcm_test_case_192_1);
11037 }
11038
11039 static int
11040 test_AES_GCM_auth_decryption_test_case_192_2(void)
11041 {
11042         return test_authenticated_decryption(&gcm_test_case_192_2);
11043 }
11044
11045 static int
11046 test_AES_GCM_auth_decryption_test_case_192_3(void)
11047 {
11048         return test_authenticated_decryption(&gcm_test_case_192_3);
11049 }
11050
11051 static int
11052 test_AES_GCM_auth_decryption_test_case_192_4(void)
11053 {
11054         return test_authenticated_decryption(&gcm_test_case_192_4);
11055 }
11056
11057 static int
11058 test_AES_GCM_auth_decryption_test_case_192_5(void)
11059 {
11060         return test_authenticated_decryption(&gcm_test_case_192_5);
11061 }
11062
11063 static int
11064 test_AES_GCM_auth_decryption_test_case_192_6(void)
11065 {
11066         return test_authenticated_decryption(&gcm_test_case_192_6);
11067 }
11068
11069 static int
11070 test_AES_GCM_auth_decryption_test_case_192_7(void)
11071 {
11072         return test_authenticated_decryption(&gcm_test_case_192_7);
11073 }
11074
11075 static int
11076 test_AES_GCM_auth_decryption_test_case_256_1(void)
11077 {
11078         return test_authenticated_decryption(&gcm_test_case_256_1);
11079 }
11080
11081 static int
11082 test_AES_GCM_auth_decryption_test_case_256_2(void)
11083 {
11084         return test_authenticated_decryption(&gcm_test_case_256_2);
11085 }
11086
11087 static int
11088 test_AES_GCM_auth_decryption_test_case_256_3(void)
11089 {
11090         return test_authenticated_decryption(&gcm_test_case_256_3);
11091 }
11092
11093 static int
11094 test_AES_GCM_auth_decryption_test_case_256_4(void)
11095 {
11096         return test_authenticated_decryption(&gcm_test_case_256_4);
11097 }
11098
11099 static int
11100 test_AES_GCM_auth_decryption_test_case_256_5(void)
11101 {
11102         return test_authenticated_decryption(&gcm_test_case_256_5);
11103 }
11104
11105 static int
11106 test_AES_GCM_auth_decryption_test_case_256_6(void)
11107 {
11108         return test_authenticated_decryption(&gcm_test_case_256_6);
11109 }
11110
11111 static int
11112 test_AES_GCM_auth_decryption_test_case_256_7(void)
11113 {
11114         return test_authenticated_decryption(&gcm_test_case_256_7);
11115 }
11116
11117 static int
11118 test_AES_GCM_auth_decryption_test_case_aad_1(void)
11119 {
11120         return test_authenticated_decryption(&gcm_test_case_aad_1);
11121 }
11122
11123 static int
11124 test_AES_GCM_auth_decryption_test_case_aad_2(void)
11125 {
11126         return test_authenticated_decryption(&gcm_test_case_aad_2);
11127 }
11128
11129 static int
11130 test_AES_GCM_auth_decryption_fail_iv_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.iv.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_in_data_corrupt(void)
11146 {
11147         struct aead_test_data tdata;
11148         int res;
11149
11150         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
11151         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
11152         tdata.plaintext.data[0] += 1;
11153         res = test_authenticated_decryption(&tdata);
11154         if (res == TEST_SKIPPED)
11155                 return res;
11156         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
11157         return TEST_SUCCESS;
11158 }
11159
11160 static int
11161 test_AES_GCM_auth_decryption_fail_out_data_corrupt(void)
11162 {
11163         struct aead_test_data tdata;
11164         int res;
11165
11166         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
11167         tdata.ciphertext.data[0] += 1;
11168         res = test_authenticated_decryption(&tdata);
11169         if (res == TEST_SKIPPED)
11170                 return res;
11171         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
11172         return TEST_SUCCESS;
11173 }
11174
11175 static int
11176 test_AES_GCM_auth_decryption_fail_aad_len_corrupt(void)
11177 {
11178         struct aead_test_data tdata;
11179         int res;
11180
11181         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
11182         tdata.aad.len += 1;
11183         res = test_authenticated_decryption(&tdata);
11184         if (res == TEST_SKIPPED)
11185                 return res;
11186         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
11187         return TEST_SUCCESS;
11188 }
11189
11190 static int
11191 test_AES_GCM_auth_decryption_fail_aad_corrupt(void)
11192 {
11193         struct aead_test_data tdata;
11194         uint8_t aad[gcm_test_case_7.aad.len];
11195         int res;
11196
11197         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
11198         memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
11199         aad[0] += 1;
11200         tdata.aad.data = aad;
11201         res = test_authenticated_decryption(&tdata);
11202         if (res == TEST_SKIPPED)
11203                 return res;
11204         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
11205         return TEST_SUCCESS;
11206 }
11207
11208 static int
11209 test_AES_GCM_auth_decryption_fail_tag_corrupt(void)
11210 {
11211         struct aead_test_data tdata;
11212         int res;
11213
11214         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
11215         tdata.auth_tag.data[0] += 1;
11216         res = test_authenticated_decryption(&tdata);
11217         if (res == TEST_SKIPPED)
11218                 return res;
11219         TEST_ASSERT_EQUAL(res, TEST_FAILED, "authentication not failed");
11220         return TEST_SUCCESS;
11221 }
11222
11223 static int
11224 test_authenticated_encryption_oop(const struct aead_test_data *tdata)
11225 {
11226         struct crypto_testsuite_params *ts_params = &testsuite_params;
11227         struct crypto_unittest_params *ut_params = &unittest_params;
11228
11229         int retval;
11230         uint8_t *ciphertext, *auth_tag;
11231         uint16_t plaintext_pad_len;
11232         struct rte_cryptodev_info dev_info;
11233
11234         /* Verify the capabilities */
11235         struct rte_cryptodev_sym_capability_idx cap_idx;
11236         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
11237         cap_idx.algo.aead = tdata->algo;
11238         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11239                         &cap_idx) == NULL)
11240                 return TEST_SKIPPED;
11241
11242         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11243         uint64_t feat_flags = dev_info.feature_flags;
11244
11245         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11246                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP)))
11247                 return TEST_SKIPPED;
11248
11249         /* not supported with CPU crypto */
11250         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11251                 return TEST_SKIPPED;
11252
11253         /* Create AEAD session */
11254         retval = create_aead_session(ts_params->valid_devs[0],
11255                         tdata->algo,
11256                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
11257                         tdata->key.data, tdata->key.len,
11258                         tdata->aad.len, tdata->auth_tag.len,
11259                         tdata->iv.len);
11260         if (retval < 0)
11261                 return retval;
11262
11263         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11264         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11265
11266         /* clear mbuf payload */
11267         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11268                         rte_pktmbuf_tailroom(ut_params->ibuf));
11269         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
11270                         rte_pktmbuf_tailroom(ut_params->obuf));
11271
11272         /* Create AEAD operation */
11273         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
11274         if (retval < 0)
11275                 return retval;
11276
11277         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11278
11279         ut_params->op->sym->m_src = ut_params->ibuf;
11280         ut_params->op->sym->m_dst = ut_params->obuf;
11281
11282         /* Process crypto operation */
11283         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11284                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11285                         ut_params->op, 0, 0, 0, 0);
11286         else
11287                 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
11288                         ut_params->op), "failed to process sym crypto op");
11289
11290         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11291                         "crypto op processing failed");
11292
11293         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
11294
11295         ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
11296                         ut_params->op->sym->cipher.data.offset);
11297         auth_tag = ciphertext + plaintext_pad_len;
11298
11299         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
11300         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
11301
11302         /* Validate obuf */
11303         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11304                         ciphertext,
11305                         tdata->ciphertext.data,
11306                         tdata->ciphertext.len,
11307                         "Ciphertext data not as expected");
11308
11309         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11310                         auth_tag,
11311                         tdata->auth_tag.data,
11312                         tdata->auth_tag.len,
11313                         "Generated auth tag not as expected");
11314
11315         return 0;
11316
11317 }
11318
11319 static int
11320 test_AES_GCM_authenticated_encryption_oop_test_case_1(void)
11321 {
11322         return test_authenticated_encryption_oop(&gcm_test_case_5);
11323 }
11324
11325 static int
11326 test_authenticated_decryption_oop(const struct aead_test_data *tdata)
11327 {
11328         struct crypto_testsuite_params *ts_params = &testsuite_params;
11329         struct crypto_unittest_params *ut_params = &unittest_params;
11330
11331         int retval;
11332         uint8_t *plaintext;
11333         struct rte_cryptodev_info dev_info;
11334
11335         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11336         uint64_t feat_flags = dev_info.feature_flags;
11337
11338         /* Verify the capabilities */
11339         struct rte_cryptodev_sym_capability_idx cap_idx;
11340         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
11341         cap_idx.algo.aead = tdata->algo;
11342         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11343                         &cap_idx) == NULL)
11344                 return TEST_SKIPPED;
11345
11346         /* not supported with CPU crypto and raw data-path APIs*/
11347         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO ||
11348                         global_api_test_type == CRYPTODEV_RAW_API_TEST)
11349                 return TEST_SKIPPED;
11350
11351         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11352                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11353                 printf("Device does not support RAW data-path APIs.\n");
11354                 return TEST_SKIPPED;
11355         }
11356
11357         /* Create AEAD session */
11358         retval = create_aead_session(ts_params->valid_devs[0],
11359                         tdata->algo,
11360                         RTE_CRYPTO_AEAD_OP_DECRYPT,
11361                         tdata->key.data, tdata->key.len,
11362                         tdata->aad.len, tdata->auth_tag.len,
11363                         tdata->iv.len);
11364         if (retval < 0)
11365                 return retval;
11366
11367         /* alloc mbuf and set payload */
11368         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11369         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11370
11371         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11372                         rte_pktmbuf_tailroom(ut_params->ibuf));
11373         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
11374                         rte_pktmbuf_tailroom(ut_params->obuf));
11375
11376         /* Create AEAD operation */
11377         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
11378         if (retval < 0)
11379                 return retval;
11380
11381         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11382
11383         ut_params->op->sym->m_src = ut_params->ibuf;
11384         ut_params->op->sym->m_dst = ut_params->obuf;
11385
11386         /* Process crypto operation */
11387         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11388                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11389                                 ut_params->op, 0, 0, 0, 0);
11390         else
11391                 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
11392                         ut_params->op), "failed to process sym crypto op");
11393
11394         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11395                         "crypto op processing failed");
11396
11397         plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
11398                         ut_params->op->sym->cipher.data.offset);
11399
11400         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
11401
11402         /* Validate obuf */
11403         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11404                         plaintext,
11405                         tdata->plaintext.data,
11406                         tdata->plaintext.len,
11407                         "Plaintext data not as expected");
11408
11409         TEST_ASSERT_EQUAL(ut_params->op->status,
11410                         RTE_CRYPTO_OP_STATUS_SUCCESS,
11411                         "Authentication failed");
11412         return 0;
11413 }
11414
11415 static int
11416 test_AES_GCM_authenticated_decryption_oop_test_case_1(void)
11417 {
11418         return test_authenticated_decryption_oop(&gcm_test_case_5);
11419 }
11420
11421 static int
11422 test_authenticated_encryption_sessionless(
11423                 const struct aead_test_data *tdata)
11424 {
11425         struct crypto_testsuite_params *ts_params = &testsuite_params;
11426         struct crypto_unittest_params *ut_params = &unittest_params;
11427
11428         int retval;
11429         uint8_t *ciphertext, *auth_tag;
11430         uint16_t plaintext_pad_len;
11431         uint8_t key[tdata->key.len + 1];
11432         struct rte_cryptodev_info dev_info;
11433
11434         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11435         uint64_t feat_flags = dev_info.feature_flags;
11436
11437         if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
11438                 printf("Device doesn't support Sessionless ops.\n");
11439                 return TEST_SKIPPED;
11440         }
11441
11442         /* not supported with CPU crypto */
11443         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11444                 return TEST_SKIPPED;
11445
11446         /* Verify the capabilities */
11447         struct rte_cryptodev_sym_capability_idx cap_idx;
11448         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
11449         cap_idx.algo.aead = tdata->algo;
11450         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11451                         &cap_idx) == NULL)
11452                 return TEST_SKIPPED;
11453
11454         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11455
11456         /* clear mbuf payload */
11457         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11458                         rte_pktmbuf_tailroom(ut_params->ibuf));
11459
11460         /* Create AEAD operation */
11461         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
11462         if (retval < 0)
11463                 return retval;
11464
11465         /* Create GCM xform */
11466         memcpy(key, tdata->key.data, tdata->key.len);
11467         retval = create_aead_xform(ut_params->op,
11468                         tdata->algo,
11469                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
11470                         key, tdata->key.len,
11471                         tdata->aad.len, tdata->auth_tag.len,
11472                         tdata->iv.len);
11473         if (retval < 0)
11474                 return retval;
11475
11476         ut_params->op->sym->m_src = ut_params->ibuf;
11477
11478         TEST_ASSERT_EQUAL(ut_params->op->sess_type,
11479                         RTE_CRYPTO_OP_SESSIONLESS,
11480                         "crypto op session type not sessionless");
11481
11482         /* Process crypto operation */
11483         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
11484                         ut_params->op), "failed to process sym crypto op");
11485
11486         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
11487
11488         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11489                         "crypto op status not success");
11490
11491         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
11492
11493         ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
11494                         ut_params->op->sym->cipher.data.offset);
11495         auth_tag = ciphertext + plaintext_pad_len;
11496
11497         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
11498         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
11499
11500         /* Validate obuf */
11501         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11502                         ciphertext,
11503                         tdata->ciphertext.data,
11504                         tdata->ciphertext.len,
11505                         "Ciphertext data not as expected");
11506
11507         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11508                         auth_tag,
11509                         tdata->auth_tag.data,
11510                         tdata->auth_tag.len,
11511                         "Generated auth tag not as expected");
11512
11513         return 0;
11514
11515 }
11516
11517 static int
11518 test_AES_GCM_authenticated_encryption_sessionless_test_case_1(void)
11519 {
11520         return test_authenticated_encryption_sessionless(
11521                         &gcm_test_case_5);
11522 }
11523
11524 static int
11525 test_authenticated_decryption_sessionless(
11526                 const struct aead_test_data *tdata)
11527 {
11528         struct crypto_testsuite_params *ts_params = &testsuite_params;
11529         struct crypto_unittest_params *ut_params = &unittest_params;
11530
11531         int retval;
11532         uint8_t *plaintext;
11533         uint8_t key[tdata->key.len + 1];
11534         struct rte_cryptodev_info dev_info;
11535
11536         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11537         uint64_t feat_flags = dev_info.feature_flags;
11538
11539         if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
11540                 printf("Device doesn't support Sessionless ops.\n");
11541                 return TEST_SKIPPED;
11542         }
11543
11544         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11545                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11546                 printf("Device doesn't support RAW data-path APIs.\n");
11547                 return TEST_SKIPPED;
11548         }
11549
11550         /* not supported with CPU crypto */
11551         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11552                 return TEST_SKIPPED;
11553
11554         /* Verify the capabilities */
11555         struct rte_cryptodev_sym_capability_idx cap_idx;
11556         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
11557         cap_idx.algo.aead = tdata->algo;
11558         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11559                         &cap_idx) == NULL)
11560                 return TEST_SKIPPED;
11561
11562         /* alloc mbuf and set payload */
11563         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11564
11565         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11566                         rte_pktmbuf_tailroom(ut_params->ibuf));
11567
11568         /* Create AEAD operation */
11569         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
11570         if (retval < 0)
11571                 return retval;
11572
11573         /* Create AEAD xform */
11574         memcpy(key, tdata->key.data, tdata->key.len);
11575         retval = create_aead_xform(ut_params->op,
11576                         tdata->algo,
11577                         RTE_CRYPTO_AEAD_OP_DECRYPT,
11578                         key, tdata->key.len,
11579                         tdata->aad.len, tdata->auth_tag.len,
11580                         tdata->iv.len);
11581         if (retval < 0)
11582                 return retval;
11583
11584         ut_params->op->sym->m_src = ut_params->ibuf;
11585
11586         TEST_ASSERT_EQUAL(ut_params->op->sess_type,
11587                         RTE_CRYPTO_OP_SESSIONLESS,
11588                         "crypto op session type not sessionless");
11589
11590         /* Process crypto operation */
11591         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11592                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11593                                 ut_params->op, 0, 0, 0, 0);
11594         else
11595                 TEST_ASSERT_NOT_NULL(process_crypto_request(
11596                         ts_params->valid_devs[0], ut_params->op),
11597                                 "failed to process sym crypto op");
11598
11599         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
11600
11601         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11602                         "crypto op status not success");
11603
11604         plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
11605                         ut_params->op->sym->cipher.data.offset);
11606
11607         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
11608
11609         /* Validate obuf */
11610         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11611                         plaintext,
11612                         tdata->plaintext.data,
11613                         tdata->plaintext.len,
11614                         "Plaintext data not as expected");
11615
11616         TEST_ASSERT_EQUAL(ut_params->op->status,
11617                         RTE_CRYPTO_OP_STATUS_SUCCESS,
11618                         "Authentication failed");
11619         return 0;
11620 }
11621
11622 static int
11623 test_AES_GCM_authenticated_decryption_sessionless_test_case_1(void)
11624 {
11625         return test_authenticated_decryption_sessionless(
11626                         &gcm_test_case_5);
11627 }
11628
11629 static int
11630 test_AES_CCM_authenticated_encryption_test_case_128_1(void)
11631 {
11632         return test_authenticated_encryption(&ccm_test_case_128_1);
11633 }
11634
11635 static int
11636 test_AES_CCM_authenticated_encryption_test_case_128_2(void)
11637 {
11638         return test_authenticated_encryption(&ccm_test_case_128_2);
11639 }
11640
11641 static int
11642 test_AES_CCM_authenticated_encryption_test_case_128_3(void)
11643 {
11644         return test_authenticated_encryption(&ccm_test_case_128_3);
11645 }
11646
11647 static int
11648 test_AES_CCM_authenticated_decryption_test_case_128_1(void)
11649 {
11650         return test_authenticated_decryption(&ccm_test_case_128_1);
11651 }
11652
11653 static int
11654 test_AES_CCM_authenticated_decryption_test_case_128_2(void)
11655 {
11656         return test_authenticated_decryption(&ccm_test_case_128_2);
11657 }
11658
11659 static int
11660 test_AES_CCM_authenticated_decryption_test_case_128_3(void)
11661 {
11662         return test_authenticated_decryption(&ccm_test_case_128_3);
11663 }
11664
11665 static int
11666 test_AES_CCM_authenticated_encryption_test_case_192_1(void)
11667 {
11668         return test_authenticated_encryption(&ccm_test_case_192_1);
11669 }
11670
11671 static int
11672 test_AES_CCM_authenticated_encryption_test_case_192_2(void)
11673 {
11674         return test_authenticated_encryption(&ccm_test_case_192_2);
11675 }
11676
11677 static int
11678 test_AES_CCM_authenticated_encryption_test_case_192_3(void)
11679 {
11680         return test_authenticated_encryption(&ccm_test_case_192_3);
11681 }
11682
11683 static int
11684 test_AES_CCM_authenticated_decryption_test_case_192_1(void)
11685 {
11686         return test_authenticated_decryption(&ccm_test_case_192_1);
11687 }
11688
11689 static int
11690 test_AES_CCM_authenticated_decryption_test_case_192_2(void)
11691 {
11692         return test_authenticated_decryption(&ccm_test_case_192_2);
11693 }
11694
11695 static int
11696 test_AES_CCM_authenticated_decryption_test_case_192_3(void)
11697 {
11698         return test_authenticated_decryption(&ccm_test_case_192_3);
11699 }
11700
11701 static int
11702 test_AES_CCM_authenticated_encryption_test_case_256_1(void)
11703 {
11704         return test_authenticated_encryption(&ccm_test_case_256_1);
11705 }
11706
11707 static int
11708 test_AES_CCM_authenticated_encryption_test_case_256_2(void)
11709 {
11710         return test_authenticated_encryption(&ccm_test_case_256_2);
11711 }
11712
11713 static int
11714 test_AES_CCM_authenticated_encryption_test_case_256_3(void)
11715 {
11716         return test_authenticated_encryption(&ccm_test_case_256_3);
11717 }
11718
11719 static int
11720 test_AES_CCM_authenticated_decryption_test_case_256_1(void)
11721 {
11722         return test_authenticated_decryption(&ccm_test_case_256_1);
11723 }
11724
11725 static int
11726 test_AES_CCM_authenticated_decryption_test_case_256_2(void)
11727 {
11728         return test_authenticated_decryption(&ccm_test_case_256_2);
11729 }
11730
11731 static int
11732 test_AES_CCM_authenticated_decryption_test_case_256_3(void)
11733 {
11734         return test_authenticated_decryption(&ccm_test_case_256_3);
11735 }
11736
11737 static int
11738 test_stats(void)
11739 {
11740         struct crypto_testsuite_params *ts_params = &testsuite_params;
11741         struct rte_cryptodev_stats stats;
11742
11743         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11744                 return TEST_SKIPPED;
11745
11746         /* Verify the capabilities */
11747         struct rte_cryptodev_sym_capability_idx cap_idx;
11748         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11749         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
11750         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11751                         &cap_idx) == NULL)
11752                 return TEST_SKIPPED;
11753         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11754         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
11755         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11756                         &cap_idx) == NULL)
11757                 return TEST_SKIPPED;
11758
11759         if (rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
11760                         == -ENOTSUP)
11761                 return TEST_SKIPPED;
11762
11763         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
11764         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
11765                         &stats) == -ENODEV),
11766                 "rte_cryptodev_stats_get invalid dev failed");
11767         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
11768                 "rte_cryptodev_stats_get invalid Param failed");
11769
11770         /* Test expected values */
11771         test_AES_CBC_HMAC_SHA1_encrypt_digest();
11772         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
11773                         &stats),
11774                 "rte_cryptodev_stats_get failed");
11775         TEST_ASSERT((stats.enqueued_count == 1),
11776                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11777         TEST_ASSERT((stats.dequeued_count == 1),
11778                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11779         TEST_ASSERT((stats.enqueue_err_count == 0),
11780                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11781         TEST_ASSERT((stats.dequeue_err_count == 0),
11782                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11783
11784         /* invalid device but should ignore and not reset device stats*/
11785         rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
11786         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
11787                         &stats),
11788                 "rte_cryptodev_stats_get failed");
11789         TEST_ASSERT((stats.enqueued_count == 1),
11790                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11791
11792         /* check that a valid reset clears stats */
11793         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
11794         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
11795                         &stats),
11796                                           "rte_cryptodev_stats_get failed");
11797         TEST_ASSERT((stats.enqueued_count == 0),
11798                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11799         TEST_ASSERT((stats.dequeued_count == 0),
11800                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11801
11802         return TEST_SUCCESS;
11803 }
11804
11805 static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
11806                                    struct crypto_unittest_params *ut_params,
11807                                    enum rte_crypto_auth_operation op,
11808                                    const struct HMAC_MD5_vector *test_case)
11809 {
11810         uint8_t key[64];
11811         int status;
11812
11813         memcpy(key, test_case->key.data, test_case->key.len);
11814
11815         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11816         ut_params->auth_xform.next = NULL;
11817         ut_params->auth_xform.auth.op = op;
11818
11819         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC;
11820
11821         ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN;
11822         ut_params->auth_xform.auth.key.length = test_case->key.len;
11823         ut_params->auth_xform.auth.key.data = key;
11824
11825         ut_params->sess = rte_cryptodev_sym_session_create(
11826                         ts_params->session_mpool);
11827         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
11828         if (ut_params->sess == NULL)
11829                 return TEST_FAILED;
11830
11831         status = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11832                         ut_params->sess, &ut_params->auth_xform,
11833                         ts_params->session_priv_mpool);
11834         if (status == -ENOTSUP)
11835                 return TEST_SKIPPED;
11836
11837         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11838
11839         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11840                         rte_pktmbuf_tailroom(ut_params->ibuf));
11841
11842         return 0;
11843 }
11844
11845 static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
11846                               const struct HMAC_MD5_vector *test_case,
11847                               uint8_t **plaintext)
11848 {
11849         uint16_t plaintext_pad_len;
11850
11851         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
11852
11853         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
11854                                 16);
11855
11856         *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11857                         plaintext_pad_len);
11858         memcpy(*plaintext, test_case->plaintext.data,
11859                         test_case->plaintext.len);
11860
11861         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
11862                         ut_params->ibuf, MD5_DIGEST_LEN);
11863         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
11864                         "no room to append digest");
11865         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
11866                         ut_params->ibuf, plaintext_pad_len);
11867
11868         if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
11869                 rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data,
11870                            test_case->auth_tag.len);
11871         }
11872
11873         sym_op->auth.data.offset = 0;
11874         sym_op->auth.data.length = test_case->plaintext.len;
11875
11876         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11877         ut_params->op->sym->m_src = ut_params->ibuf;
11878
11879         return 0;
11880 }
11881
11882 static int
11883 test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
11884 {
11885         uint16_t plaintext_pad_len;
11886         uint8_t *plaintext, *auth_tag;
11887
11888         struct crypto_testsuite_params *ts_params = &testsuite_params;
11889         struct crypto_unittest_params *ut_params = &unittest_params;
11890         struct rte_cryptodev_info dev_info;
11891
11892         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11893         uint64_t feat_flags = dev_info.feature_flags;
11894
11895         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11896                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11897                 printf("Device doesn't support RAW data-path APIs.\n");
11898                 return TEST_SKIPPED;
11899         }
11900
11901         /* Verify the capabilities */
11902         struct rte_cryptodev_sym_capability_idx cap_idx;
11903         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11904         cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
11905         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11906                         &cap_idx) == NULL)
11907                 return TEST_SKIPPED;
11908
11909         if (MD5_HMAC_create_session(ts_params, ut_params,
11910                         RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
11911                 return TEST_FAILED;
11912
11913         /* Generate Crypto op data structure */
11914         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11915                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11916         TEST_ASSERT_NOT_NULL(ut_params->op,
11917                         "Failed to allocate symmetric crypto operation struct");
11918
11919         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
11920                                 16);
11921
11922         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
11923                 return TEST_FAILED;
11924
11925         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11926                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11927                         ut_params->op);
11928         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11929                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11930                                 ut_params->op, 0, 1, 0, 0);
11931         else
11932                 TEST_ASSERT_NOT_NULL(
11933                         process_crypto_request(ts_params->valid_devs[0],
11934                                 ut_params->op),
11935                                 "failed to process sym crypto op");
11936
11937         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11938                         "crypto op processing failed");
11939
11940         if (ut_params->op->sym->m_dst) {
11941                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
11942                                 uint8_t *, plaintext_pad_len);
11943         } else {
11944                 auth_tag = plaintext + plaintext_pad_len;
11945         }
11946
11947         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11948                         auth_tag,
11949                         test_case->auth_tag.data,
11950                         test_case->auth_tag.len,
11951                         "HMAC_MD5 generated tag not as expected");
11952
11953         return TEST_SUCCESS;
11954 }
11955
11956 static int
11957 test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
11958 {
11959         uint8_t *plaintext;
11960
11961         struct crypto_testsuite_params *ts_params = &testsuite_params;
11962         struct crypto_unittest_params *ut_params = &unittest_params;
11963         struct rte_cryptodev_info dev_info;
11964
11965         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11966         uint64_t feat_flags = dev_info.feature_flags;
11967
11968         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11969                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11970                 printf("Device doesn't support RAW data-path APIs.\n");
11971                 return TEST_SKIPPED;
11972         }
11973
11974         /* Verify the capabilities */
11975         struct rte_cryptodev_sym_capability_idx cap_idx;
11976         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11977         cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
11978         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11979                         &cap_idx) == NULL)
11980                 return TEST_SKIPPED;
11981
11982         if (MD5_HMAC_create_session(ts_params, ut_params,
11983                         RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
11984                 return TEST_FAILED;
11985         }
11986
11987         /* Generate Crypto op data structure */
11988         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11989                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11990         TEST_ASSERT_NOT_NULL(ut_params->op,
11991                         "Failed to allocate symmetric crypto operation struct");
11992
11993         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
11994                 return TEST_FAILED;
11995
11996         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11997                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11998                         ut_params->op);
11999         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12000                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12001                                 ut_params->op, 0, 1, 0, 0);
12002         else
12003                 TEST_ASSERT_NOT_NULL(
12004                         process_crypto_request(ts_params->valid_devs[0],
12005                                 ut_params->op),
12006                                 "failed to process sym crypto op");
12007
12008         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12009                         "HMAC_MD5 crypto op processing failed");
12010
12011         return TEST_SUCCESS;
12012 }
12013
12014 static int
12015 test_MD5_HMAC_generate_case_1(void)
12016 {
12017         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1);
12018 }
12019
12020 static int
12021 test_MD5_HMAC_verify_case_1(void)
12022 {
12023         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1);
12024 }
12025
12026 static int
12027 test_MD5_HMAC_generate_case_2(void)
12028 {
12029         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2);
12030 }
12031
12032 static int
12033 test_MD5_HMAC_verify_case_2(void)
12034 {
12035         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2);
12036 }
12037
12038 static int
12039 test_multi_session(void)
12040 {
12041         struct crypto_testsuite_params *ts_params = &testsuite_params;
12042         struct crypto_unittest_params *ut_params = &unittest_params;
12043
12044         struct rte_cryptodev_info dev_info;
12045         struct rte_cryptodev_sym_session **sessions;
12046
12047         uint16_t i;
12048         int status;
12049
12050         /* Verify the capabilities */
12051         struct rte_cryptodev_sym_capability_idx cap_idx;
12052         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12053         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
12054         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12055                         &cap_idx) == NULL)
12056                 return TEST_SKIPPED;
12057         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12058         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
12059         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12060                         &cap_idx) == NULL)
12061                 return TEST_SKIPPED;
12062
12063         test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
12064                         aes_cbc_key, hmac_sha512_key);
12065
12066
12067         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12068
12069         sessions = rte_malloc(NULL,
12070                         sizeof(struct rte_cryptodev_sym_session *) *
12071                         (MAX_NB_SESSIONS + 1), 0);
12072
12073         /* Create multiple crypto sessions*/
12074         for (i = 0; i < MAX_NB_SESSIONS; i++) {
12075
12076                 sessions[i] = rte_cryptodev_sym_session_create(
12077                                 ts_params->session_mpool);
12078                 TEST_ASSERT_NOT_NULL(sessions[i],
12079                                 "Session creation failed at session number %u",
12080                                 i);
12081
12082                 status = rte_cryptodev_sym_session_init(
12083                                 ts_params->valid_devs[0],
12084                                 sessions[i], &ut_params->auth_xform,
12085                                 ts_params->session_priv_mpool);
12086                 if (status == -ENOTSUP)
12087                         return TEST_SKIPPED;
12088
12089                 /* Attempt to send a request on each session */
12090                 TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform(
12091                         sessions[i],
12092                         ut_params,
12093                         ts_params,
12094                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
12095                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
12096                         aes_cbc_iv),
12097                         "Failed to perform decrypt on request number %u.", i);
12098                 /* free crypto operation structure */
12099                 if (ut_params->op)
12100                         rte_crypto_op_free(ut_params->op);
12101
12102                 /*
12103                  * free mbuf - both obuf and ibuf are usually the same,
12104                  * so check if they point at the same address is necessary,
12105                  * to avoid freeing the mbuf twice.
12106                  */
12107                 if (ut_params->obuf) {
12108                         rte_pktmbuf_free(ut_params->obuf);
12109                         if (ut_params->ibuf == ut_params->obuf)
12110                                 ut_params->ibuf = 0;
12111                         ut_params->obuf = 0;
12112                 }
12113                 if (ut_params->ibuf) {
12114                         rte_pktmbuf_free(ut_params->ibuf);
12115                         ut_params->ibuf = 0;
12116                 }
12117         }
12118
12119         sessions[i] = NULL;
12120         /* Next session create should fail */
12121         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
12122                         sessions[i], &ut_params->auth_xform,
12123                         ts_params->session_priv_mpool);
12124         TEST_ASSERT_NULL(sessions[i],
12125                         "Session creation succeeded unexpectedly!");
12126
12127         for (i = 0; i < MAX_NB_SESSIONS; i++) {
12128                 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
12129                                 sessions[i]);
12130                 rte_cryptodev_sym_session_free(sessions[i]);
12131         }
12132
12133         rte_free(sessions);
12134
12135         return TEST_SUCCESS;
12136 }
12137
12138 struct multi_session_params {
12139         struct crypto_unittest_params ut_params;
12140         uint8_t *cipher_key;
12141         uint8_t *hmac_key;
12142         const uint8_t *cipher;
12143         const uint8_t *digest;
12144         uint8_t *iv;
12145 };
12146
12147 #define MB_SESSION_NUMBER 3
12148
12149 static int
12150 test_multi_session_random_usage(void)
12151 {
12152         struct crypto_testsuite_params *ts_params = &testsuite_params;
12153         struct rte_cryptodev_info dev_info;
12154         struct rte_cryptodev_sym_session **sessions;
12155         uint32_t i, j;
12156         struct multi_session_params ut_paramz[] = {
12157
12158                 {
12159                         .cipher_key = ms_aes_cbc_key0,
12160                         .hmac_key = ms_hmac_key0,
12161                         .cipher = ms_aes_cbc_cipher0,
12162                         .digest = ms_hmac_digest0,
12163                         .iv = ms_aes_cbc_iv0
12164                 },
12165                 {
12166                         .cipher_key = ms_aes_cbc_key1,
12167                         .hmac_key = ms_hmac_key1,
12168                         .cipher = ms_aes_cbc_cipher1,
12169                         .digest = ms_hmac_digest1,
12170                         .iv = ms_aes_cbc_iv1
12171                 },
12172                 {
12173                         .cipher_key = ms_aes_cbc_key2,
12174                         .hmac_key = ms_hmac_key2,
12175                         .cipher = ms_aes_cbc_cipher2,
12176                         .digest = ms_hmac_digest2,
12177                         .iv = ms_aes_cbc_iv2
12178                 },
12179
12180         };
12181         int status;
12182
12183         /* Verify the capabilities */
12184         struct rte_cryptodev_sym_capability_idx cap_idx;
12185         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12186         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
12187         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12188                         &cap_idx) == NULL)
12189                 return TEST_SKIPPED;
12190         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12191         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
12192         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12193                         &cap_idx) == NULL)
12194                 return TEST_SKIPPED;
12195
12196         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12197
12198         sessions = rte_malloc(NULL,
12199                         (sizeof(struct rte_cryptodev_sym_session *)
12200                                         * MAX_NB_SESSIONS) + 1, 0);
12201
12202         for (i = 0; i < MB_SESSION_NUMBER; i++) {
12203                 sessions[i] = rte_cryptodev_sym_session_create(
12204                                 ts_params->session_mpool);
12205                 TEST_ASSERT_NOT_NULL(sessions[i],
12206                                 "Session creation failed at session number %u",
12207                                 i);
12208
12209                 rte_memcpy(&ut_paramz[i].ut_params, &unittest_params,
12210                                 sizeof(struct crypto_unittest_params));
12211
12212                 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
12213                                 &ut_paramz[i].ut_params,
12214                                 ut_paramz[i].cipher_key, ut_paramz[i].hmac_key);
12215
12216                 /* Create multiple crypto sessions*/
12217                 status = rte_cryptodev_sym_session_init(
12218                                 ts_params->valid_devs[0],
12219                                 sessions[i],
12220                                 &ut_paramz[i].ut_params.auth_xform,
12221                                 ts_params->session_priv_mpool);
12222
12223                 if (status == -ENOTSUP)
12224                         return TEST_SKIPPED;
12225
12226                 TEST_ASSERT_EQUAL(status, 0, "Session init failed");
12227         }
12228
12229         srand(time(NULL));
12230         for (i = 0; i < 40000; i++) {
12231
12232                 j = rand() % MB_SESSION_NUMBER;
12233
12234                 TEST_ASSERT_SUCCESS(
12235                         test_AES_CBC_HMAC_SHA512_decrypt_perform(
12236                                         sessions[j],
12237                                         &ut_paramz[j].ut_params,
12238                                         ts_params, ut_paramz[j].cipher,
12239                                         ut_paramz[j].digest,
12240                                         ut_paramz[j].iv),
12241                         "Failed to perform decrypt on request number %u.", i);
12242
12243                 if (ut_paramz[j].ut_params.op)
12244                         rte_crypto_op_free(ut_paramz[j].ut_params.op);
12245
12246                 /*
12247                  * free mbuf - both obuf and ibuf are usually the same,
12248                  * so check if they point at the same address is necessary,
12249                  * to avoid freeing the mbuf twice.
12250                  */
12251                 if (ut_paramz[j].ut_params.obuf) {
12252                         rte_pktmbuf_free(ut_paramz[j].ut_params.obuf);
12253                         if (ut_paramz[j].ut_params.ibuf
12254                                         == ut_paramz[j].ut_params.obuf)
12255                                 ut_paramz[j].ut_params.ibuf = 0;
12256                         ut_paramz[j].ut_params.obuf = 0;
12257                 }
12258                 if (ut_paramz[j].ut_params.ibuf) {
12259                         rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf);
12260                         ut_paramz[j].ut_params.ibuf = 0;
12261                 }
12262         }
12263
12264         for (i = 0; i < MB_SESSION_NUMBER; i++) {
12265                 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
12266                                 sessions[i]);
12267                 rte_cryptodev_sym_session_free(sessions[i]);
12268         }
12269
12270         rte_free(sessions);
12271
12272         return TEST_SUCCESS;
12273 }
12274
12275 uint8_t orig_data[] = {0xab, 0xab, 0xab, 0xab,
12276                         0xab, 0xab, 0xab, 0xab,
12277                         0xab, 0xab, 0xab, 0xab,
12278                         0xab, 0xab, 0xab, 0xab};
12279
12280 static int
12281 test_null_invalid_operation(void)
12282 {
12283         struct crypto_testsuite_params *ts_params = &testsuite_params;
12284         struct crypto_unittest_params *ut_params = &unittest_params;
12285         int ret;
12286
12287         /* This test is for NULL PMD only */
12288         if (gbl_driver_id != rte_cryptodev_driver_id_get(
12289                         RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
12290                 return TEST_SKIPPED;
12291
12292         /* Setup Cipher Parameters */
12293         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12294         ut_params->cipher_xform.next = NULL;
12295
12296         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
12297         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
12298
12299         ut_params->sess = rte_cryptodev_sym_session_create(
12300                         ts_params->session_mpool);
12301
12302         /* Create Crypto session*/
12303         ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
12304                         ut_params->sess, &ut_params->cipher_xform,
12305                         ts_params->session_priv_mpool);
12306         TEST_ASSERT(ret < 0,
12307                         "Session creation succeeded unexpectedly");
12308
12309
12310         /* Setup HMAC Parameters */
12311         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12312         ut_params->auth_xform.next = NULL;
12313
12314         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
12315         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
12316
12317         ut_params->sess = rte_cryptodev_sym_session_create(
12318                         ts_params->session_mpool);
12319
12320         /* Create Crypto session*/
12321         ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
12322                         ut_params->sess, &ut_params->auth_xform,
12323                         ts_params->session_priv_mpool);
12324         TEST_ASSERT(ret < 0,
12325                         "Session creation succeeded unexpectedly");
12326
12327         return TEST_SUCCESS;
12328 }
12329
12330
12331 #define NULL_BURST_LENGTH (32)
12332
12333 static int
12334 test_null_burst_operation(void)
12335 {
12336         struct crypto_testsuite_params *ts_params = &testsuite_params;
12337         struct crypto_unittest_params *ut_params = &unittest_params;
12338         int status;
12339
12340         unsigned i, burst_len = NULL_BURST_LENGTH;
12341
12342         struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
12343         struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
12344
12345         /* This test is for NULL PMD only */
12346         if (gbl_driver_id != rte_cryptodev_driver_id_get(
12347                         RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
12348                 return TEST_SKIPPED;
12349
12350         /* Setup Cipher Parameters */
12351         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12352         ut_params->cipher_xform.next = &ut_params->auth_xform;
12353
12354         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
12355         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
12356
12357         /* Setup HMAC Parameters */
12358         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12359         ut_params->auth_xform.next = NULL;
12360
12361         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
12362         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
12363
12364         ut_params->sess = rte_cryptodev_sym_session_create(
12365                         ts_params->session_mpool);
12366         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12367
12368         /* Create Crypto session*/
12369         status = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
12370                         ut_params->sess, &ut_params->cipher_xform,
12371                         ts_params->session_priv_mpool);
12372
12373         if (status == -ENOTSUP)
12374                 return TEST_SKIPPED;
12375
12376         TEST_ASSERT_EQUAL(status, 0, "Session init failed");
12377
12378         TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
12379                         RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
12380                         burst_len, "failed to generate burst of crypto ops");
12381
12382         /* Generate an operation for each mbuf in burst */
12383         for (i = 0; i < burst_len; i++) {
12384                 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12385
12386                 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
12387
12388                 unsigned *data = (unsigned *)rte_pktmbuf_append(m,
12389                                 sizeof(unsigned));
12390                 *data = i;
12391
12392                 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
12393
12394                 burst[i]->sym->m_src = m;
12395         }
12396
12397         /* Process crypto operation */
12398         TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
12399                         0, burst, burst_len),
12400                         burst_len,
12401                         "Error enqueuing burst");
12402
12403         TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
12404                         0, burst_dequeued, burst_len),
12405                         burst_len,
12406                         "Error dequeuing burst");
12407
12408
12409         for (i = 0; i < burst_len; i++) {
12410                 TEST_ASSERT_EQUAL(
12411                         *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
12412                         *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
12413                                         uint32_t *),
12414                         "data not as expected");
12415
12416                 rte_pktmbuf_free(burst[i]->sym->m_src);
12417                 rte_crypto_op_free(burst[i]);
12418         }
12419
12420         return TEST_SUCCESS;
12421 }
12422
12423 static uint16_t
12424 test_enq_callback(uint16_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops,
12425                   uint16_t nb_ops, void *user_param)
12426 {
12427         RTE_SET_USED(dev_id);
12428         RTE_SET_USED(qp_id);
12429         RTE_SET_USED(ops);
12430         RTE_SET_USED(user_param);
12431
12432         printf("crypto enqueue callback called\n");
12433         return nb_ops;
12434 }
12435
12436 static uint16_t
12437 test_deq_callback(uint16_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops,
12438                   uint16_t nb_ops, void *user_param)
12439 {
12440         RTE_SET_USED(dev_id);
12441         RTE_SET_USED(qp_id);
12442         RTE_SET_USED(ops);
12443         RTE_SET_USED(user_param);
12444
12445         printf("crypto dequeue callback called\n");
12446         return nb_ops;
12447 }
12448
12449 /*
12450  * Thread using enqueue/dequeue callback with RCU.
12451  */
12452 static int
12453 test_enqdeq_callback_thread(void *arg)
12454 {
12455         RTE_SET_USED(arg);
12456         /* DP thread calls rte_cryptodev_enqueue_burst()/
12457          * rte_cryptodev_dequeue_burst() and invokes callback.
12458          */
12459         test_null_burst_operation();
12460         return 0;
12461 }
12462
12463 static int
12464 test_enq_callback_setup(void)
12465 {
12466         struct crypto_testsuite_params *ts_params = &testsuite_params;
12467         struct rte_cryptodev_info dev_info;
12468         struct rte_cryptodev_qp_conf qp_conf = {
12469                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
12470         };
12471
12472         struct rte_cryptodev_cb *cb;
12473         uint16_t qp_id = 0;
12474
12475         /* Stop the device in case it's started so it can be configured */
12476         rte_cryptodev_stop(ts_params->valid_devs[0]);
12477
12478         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12479
12480         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
12481                         &ts_params->conf),
12482                         "Failed to configure cryptodev %u",
12483                         ts_params->valid_devs[0]);
12484
12485         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
12486         qp_conf.mp_session = ts_params->session_mpool;
12487         qp_conf.mp_session_private = ts_params->session_priv_mpool;
12488
12489         TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
12490                         ts_params->valid_devs[0], qp_id, &qp_conf,
12491                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
12492                         "Failed test for "
12493                         "rte_cryptodev_queue_pair_setup: num_inflights "
12494                         "%u on qp %u on cryptodev %u",
12495                         qp_conf.nb_descriptors, qp_id,
12496                         ts_params->valid_devs[0]);
12497
12498         /* Test with invalid crypto device */
12499         cb = rte_cryptodev_add_enq_callback(RTE_CRYPTO_MAX_DEVS,
12500                         qp_id, test_enq_callback, NULL);
12501         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12502                         "cryptodev %u did not fail",
12503                         qp_id, RTE_CRYPTO_MAX_DEVS);
12504
12505         /* Test with invalid queue pair */
12506         cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
12507                         dev_info.max_nb_queue_pairs + 1,
12508                         test_enq_callback, NULL);
12509         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12510                         "cryptodev %u did not fail",
12511                         dev_info.max_nb_queue_pairs + 1,
12512                         ts_params->valid_devs[0]);
12513
12514         /* Test with NULL callback */
12515         cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
12516                         qp_id, NULL, NULL);
12517         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12518                         "cryptodev %u did not fail",
12519                         qp_id, ts_params->valid_devs[0]);
12520
12521         /* Test with valid configuration */
12522         cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
12523                         qp_id, test_enq_callback, NULL);
12524         TEST_ASSERT_NOT_NULL(cb, "Failed test to add callback on "
12525                         "qp %u on cryptodev %u",
12526                         qp_id, ts_params->valid_devs[0]);
12527
12528         rte_cryptodev_start(ts_params->valid_devs[0]);
12529
12530         /* Launch a thread */
12531         rte_eal_remote_launch(test_enqdeq_callback_thread, NULL,
12532                                 rte_get_next_lcore(-1, 1, 0));
12533
12534         /* Wait until reader exited. */
12535         rte_eal_mp_wait_lcore();
12536
12537         /* Test with invalid crypto device */
12538         TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
12539                         RTE_CRYPTO_MAX_DEVS, qp_id, cb),
12540                         "Expected call to fail as crypto device is invalid");
12541
12542         /* Test with invalid queue pair */
12543         TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
12544                         ts_params->valid_devs[0],
12545                         dev_info.max_nb_queue_pairs + 1, cb),
12546                         "Expected call to fail as queue pair is invalid");
12547
12548         /* Test with NULL callback */
12549         TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
12550                         ts_params->valid_devs[0], qp_id, NULL),
12551                         "Expected call to fail as callback is NULL");
12552
12553         /* Test with valid configuration */
12554         TEST_ASSERT_SUCCESS(rte_cryptodev_remove_enq_callback(
12555                         ts_params->valid_devs[0], qp_id, cb),
12556                         "Failed test to remove callback on "
12557                         "qp %u on cryptodev %u",
12558                         qp_id, ts_params->valid_devs[0]);
12559
12560         return TEST_SUCCESS;
12561 }
12562
12563 static int
12564 test_deq_callback_setup(void)
12565 {
12566         struct crypto_testsuite_params *ts_params = &testsuite_params;
12567         struct rte_cryptodev_info dev_info;
12568         struct rte_cryptodev_qp_conf qp_conf = {
12569                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
12570         };
12571
12572         struct rte_cryptodev_cb *cb;
12573         uint16_t qp_id = 0;
12574
12575         /* Stop the device in case it's started so it can be configured */
12576         rte_cryptodev_stop(ts_params->valid_devs[0]);
12577
12578         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12579
12580         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
12581                         &ts_params->conf),
12582                         "Failed to configure cryptodev %u",
12583                         ts_params->valid_devs[0]);
12584
12585         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
12586         qp_conf.mp_session = ts_params->session_mpool;
12587         qp_conf.mp_session_private = ts_params->session_priv_mpool;
12588
12589         TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
12590                         ts_params->valid_devs[0], qp_id, &qp_conf,
12591                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
12592                         "Failed test for "
12593                         "rte_cryptodev_queue_pair_setup: num_inflights "
12594                         "%u on qp %u on cryptodev %u",
12595                         qp_conf.nb_descriptors, qp_id,
12596                         ts_params->valid_devs[0]);
12597
12598         /* Test with invalid crypto device */
12599         cb = rte_cryptodev_add_deq_callback(RTE_CRYPTO_MAX_DEVS,
12600                         qp_id, test_deq_callback, NULL);
12601         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12602                         "cryptodev %u did not fail",
12603                         qp_id, RTE_CRYPTO_MAX_DEVS);
12604
12605         /* Test with invalid queue pair */
12606         cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
12607                         dev_info.max_nb_queue_pairs + 1,
12608                         test_deq_callback, NULL);
12609         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12610                         "cryptodev %u did not fail",
12611                         dev_info.max_nb_queue_pairs + 1,
12612                         ts_params->valid_devs[0]);
12613
12614         /* Test with NULL callback */
12615         cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
12616                         qp_id, NULL, NULL);
12617         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12618                         "cryptodev %u did not fail",
12619                         qp_id, ts_params->valid_devs[0]);
12620
12621         /* Test with valid configuration */
12622         cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
12623                         qp_id, test_deq_callback, NULL);
12624         TEST_ASSERT_NOT_NULL(cb, "Failed test to add callback on "
12625                         "qp %u on cryptodev %u",
12626                         qp_id, ts_params->valid_devs[0]);
12627
12628         rte_cryptodev_start(ts_params->valid_devs[0]);
12629
12630         /* Launch a thread */
12631         rte_eal_remote_launch(test_enqdeq_callback_thread, NULL,
12632                                 rte_get_next_lcore(-1, 1, 0));
12633
12634         /* Wait until reader exited. */
12635         rte_eal_mp_wait_lcore();
12636
12637         /* Test with invalid crypto device */
12638         TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
12639                         RTE_CRYPTO_MAX_DEVS, qp_id, cb),
12640                         "Expected call to fail as crypto device is invalid");
12641
12642         /* Test with invalid queue pair */
12643         TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
12644                         ts_params->valid_devs[0],
12645                         dev_info.max_nb_queue_pairs + 1, cb),
12646                         "Expected call to fail as queue pair is invalid");
12647
12648         /* Test with NULL callback */
12649         TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
12650                         ts_params->valid_devs[0], qp_id, NULL),
12651                         "Expected call to fail as callback is NULL");
12652
12653         /* Test with valid configuration */
12654         TEST_ASSERT_SUCCESS(rte_cryptodev_remove_deq_callback(
12655                         ts_params->valid_devs[0], qp_id, cb),
12656                         "Failed test to remove callback on "
12657                         "qp %u on cryptodev %u",
12658                         qp_id, ts_params->valid_devs[0]);
12659
12660         return TEST_SUCCESS;
12661 }
12662
12663 static void
12664 generate_gmac_large_plaintext(uint8_t *data)
12665 {
12666         uint16_t i;
12667
12668         for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32)
12669                 memcpy(&data[i], &data[0], 32);
12670 }
12671
12672 static int
12673 create_gmac_operation(enum rte_crypto_auth_operation op,
12674                 const struct gmac_test_data *tdata)
12675 {
12676         struct crypto_testsuite_params *ts_params = &testsuite_params;
12677         struct crypto_unittest_params *ut_params = &unittest_params;
12678         struct rte_crypto_sym_op *sym_op;
12679
12680         uint32_t plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
12681
12682         /* Generate Crypto op data structure */
12683         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12684                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12685         TEST_ASSERT_NOT_NULL(ut_params->op,
12686                         "Failed to allocate symmetric crypto operation struct");
12687
12688         sym_op = ut_params->op->sym;
12689
12690         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
12691                         ut_params->ibuf, tdata->gmac_tag.len);
12692         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
12693                         "no room to append digest");
12694
12695         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
12696                         ut_params->ibuf, plaintext_pad_len);
12697
12698         if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
12699                 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
12700                                 tdata->gmac_tag.len);
12701                 debug_hexdump(stdout, "digest:",
12702                                 sym_op->auth.digest.data,
12703                                 tdata->gmac_tag.len);
12704         }
12705
12706         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
12707                         uint8_t *, IV_OFFSET);
12708
12709         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
12710
12711         debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
12712
12713         sym_op->cipher.data.length = 0;
12714         sym_op->cipher.data.offset = 0;
12715
12716         sym_op->auth.data.offset = 0;
12717         sym_op->auth.data.length = tdata->plaintext.len;
12718
12719         return 0;
12720 }
12721
12722 static int
12723 create_gmac_operation_sgl(enum rte_crypto_auth_operation op,
12724                 const struct gmac_test_data *tdata,
12725                 void *digest_mem, uint64_t digest_phys)
12726 {
12727         struct crypto_testsuite_params *ts_params = &testsuite_params;
12728         struct crypto_unittest_params *ut_params = &unittest_params;
12729         struct rte_crypto_sym_op *sym_op;
12730
12731         /* Generate Crypto op data structure */
12732         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12733                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12734         TEST_ASSERT_NOT_NULL(ut_params->op,
12735                         "Failed to allocate symmetric crypto operation struct");
12736
12737         sym_op = ut_params->op->sym;
12738
12739         sym_op->auth.digest.data = digest_mem;
12740         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
12741                         "no room to append digest");
12742
12743         sym_op->auth.digest.phys_addr = digest_phys;
12744
12745         if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
12746                 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
12747                                 tdata->gmac_tag.len);
12748                 debug_hexdump(stdout, "digest:",
12749                                 sym_op->auth.digest.data,
12750                                 tdata->gmac_tag.len);
12751         }
12752
12753         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
12754                         uint8_t *, IV_OFFSET);
12755
12756         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
12757
12758         debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
12759
12760         sym_op->cipher.data.length = 0;
12761         sym_op->cipher.data.offset = 0;
12762
12763         sym_op->auth.data.offset = 0;
12764         sym_op->auth.data.length = tdata->plaintext.len;
12765
12766         return 0;
12767 }
12768
12769 static int create_gmac_session(uint8_t dev_id,
12770                 const struct gmac_test_data *tdata,
12771                 enum rte_crypto_auth_operation auth_op)
12772 {
12773         uint8_t auth_key[tdata->key.len];
12774         int status;
12775
12776         struct crypto_testsuite_params *ts_params = &testsuite_params;
12777         struct crypto_unittest_params *ut_params = &unittest_params;
12778
12779         memcpy(auth_key, tdata->key.data, tdata->key.len);
12780
12781         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12782         ut_params->auth_xform.next = NULL;
12783
12784         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
12785         ut_params->auth_xform.auth.op = auth_op;
12786         ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
12787         ut_params->auth_xform.auth.key.length = tdata->key.len;
12788         ut_params->auth_xform.auth.key.data = auth_key;
12789         ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
12790         ut_params->auth_xform.auth.iv.length = tdata->iv.len;
12791
12792
12793         ut_params->sess = rte_cryptodev_sym_session_create(
12794                         ts_params->session_mpool);
12795         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12796
12797         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
12798                         &ut_params->auth_xform,
12799                         ts_params->session_priv_mpool);
12800
12801         return status;
12802 }
12803
12804 static int
12805 test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
12806 {
12807         struct crypto_testsuite_params *ts_params = &testsuite_params;
12808         struct crypto_unittest_params *ut_params = &unittest_params;
12809         struct rte_cryptodev_info dev_info;
12810
12811         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12812         uint64_t feat_flags = dev_info.feature_flags;
12813
12814         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12815                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12816                 printf("Device doesn't support RAW data-path APIs.\n");
12817                 return TEST_SKIPPED;
12818         }
12819
12820         int retval;
12821
12822         uint8_t *auth_tag, *plaintext;
12823         uint16_t plaintext_pad_len;
12824
12825         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
12826                               "No GMAC length in the source data");
12827
12828         /* Verify the capabilities */
12829         struct rte_cryptodev_sym_capability_idx cap_idx;
12830         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12831         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
12832         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12833                         &cap_idx) == NULL)
12834                 return TEST_SKIPPED;
12835
12836         retval = create_gmac_session(ts_params->valid_devs[0],
12837                         tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
12838
12839         if (retval == -ENOTSUP)
12840                 return TEST_SKIPPED;
12841         if (retval < 0)
12842                 return retval;
12843
12844         if (tdata->plaintext.len > MBUF_SIZE)
12845                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
12846         else
12847                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12848         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12849                         "Failed to allocate input buffer in mempool");
12850
12851         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12852                         rte_pktmbuf_tailroom(ut_params->ibuf));
12853
12854         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
12855         /*
12856          * Runtime generate the large plain text instead of use hard code
12857          * plain text vector. It is done to avoid create huge source file
12858          * with the test vector.
12859          */
12860         if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
12861                 generate_gmac_large_plaintext(tdata->plaintext.data);
12862
12863         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12864                                 plaintext_pad_len);
12865         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12866
12867         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
12868         debug_hexdump(stdout, "plaintext:", plaintext,
12869                         tdata->plaintext.len);
12870
12871         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
12872                         tdata);
12873
12874         if (retval < 0)
12875                 return retval;
12876
12877         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12878
12879         ut_params->op->sym->m_src = ut_params->ibuf;
12880
12881         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12882                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12883                         ut_params->op);
12884         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12885                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12886                                 ut_params->op, 0, 1, 0, 0);
12887         else
12888                 TEST_ASSERT_NOT_NULL(
12889                         process_crypto_request(ts_params->valid_devs[0],
12890                         ut_params->op), "failed to process sym crypto op");
12891
12892         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12893                         "crypto op processing failed");
12894
12895         if (ut_params->op->sym->m_dst) {
12896                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
12897                                 uint8_t *, plaintext_pad_len);
12898         } else {
12899                 auth_tag = plaintext + plaintext_pad_len;
12900         }
12901
12902         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
12903
12904         TEST_ASSERT_BUFFERS_ARE_EQUAL(
12905                         auth_tag,
12906                         tdata->gmac_tag.data,
12907                         tdata->gmac_tag.len,
12908                         "GMAC Generated auth tag not as expected");
12909
12910         return 0;
12911 }
12912
12913 static int
12914 test_AES_GMAC_authentication_test_case_1(void)
12915 {
12916         return test_AES_GMAC_authentication(&gmac_test_case_1);
12917 }
12918
12919 static int
12920 test_AES_GMAC_authentication_test_case_2(void)
12921 {
12922         return test_AES_GMAC_authentication(&gmac_test_case_2);
12923 }
12924
12925 static int
12926 test_AES_GMAC_authentication_test_case_3(void)
12927 {
12928         return test_AES_GMAC_authentication(&gmac_test_case_3);
12929 }
12930
12931 static int
12932 test_AES_GMAC_authentication_test_case_4(void)
12933 {
12934         return test_AES_GMAC_authentication(&gmac_test_case_4);
12935 }
12936
12937 static int
12938 test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
12939 {
12940         struct crypto_testsuite_params *ts_params = &testsuite_params;
12941         struct crypto_unittest_params *ut_params = &unittest_params;
12942         int retval;
12943         uint32_t plaintext_pad_len;
12944         uint8_t *plaintext;
12945         struct rte_cryptodev_info dev_info;
12946
12947         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12948         uint64_t feat_flags = dev_info.feature_flags;
12949
12950         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12951                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12952                 printf("Device doesn't support RAW data-path APIs.\n");
12953                 return TEST_SKIPPED;
12954         }
12955
12956         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
12957                               "No GMAC length in the source data");
12958
12959         /* Verify the capabilities */
12960         struct rte_cryptodev_sym_capability_idx cap_idx;
12961         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12962         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
12963         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12964                         &cap_idx) == NULL)
12965                 return TEST_SKIPPED;
12966
12967         retval = create_gmac_session(ts_params->valid_devs[0],
12968                         tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
12969
12970         if (retval == -ENOTSUP)
12971                 return TEST_SKIPPED;
12972         if (retval < 0)
12973                 return retval;
12974
12975         if (tdata->plaintext.len > MBUF_SIZE)
12976                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
12977         else
12978                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12979         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12980                         "Failed to allocate input buffer in mempool");
12981
12982         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12983                         rte_pktmbuf_tailroom(ut_params->ibuf));
12984
12985         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
12986
12987         /*
12988          * Runtime generate the large plain text instead of use hard code
12989          * plain text vector. It is done to avoid create huge source file
12990          * with the test vector.
12991          */
12992         if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
12993                 generate_gmac_large_plaintext(tdata->plaintext.data);
12994
12995         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12996                                 plaintext_pad_len);
12997         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12998
12999         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
13000         debug_hexdump(stdout, "plaintext:", plaintext,
13001                         tdata->plaintext.len);
13002
13003         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
13004                         tdata);
13005
13006         if (retval < 0)
13007                 return retval;
13008
13009         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
13010
13011         ut_params->op->sym->m_src = ut_params->ibuf;
13012
13013         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13014                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13015                         ut_params->op);
13016         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13017                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13018                                 ut_params->op, 0, 1, 0, 0);
13019         else
13020                 TEST_ASSERT_NOT_NULL(
13021                         process_crypto_request(ts_params->valid_devs[0],
13022                         ut_params->op), "failed to process sym crypto op");
13023
13024         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
13025                         "crypto op processing failed");
13026
13027         return 0;
13028
13029 }
13030
13031 static int
13032 test_AES_GMAC_authentication_verify_test_case_1(void)
13033 {
13034         return test_AES_GMAC_authentication_verify(&gmac_test_case_1);
13035 }
13036
13037 static int
13038 test_AES_GMAC_authentication_verify_test_case_2(void)
13039 {
13040         return test_AES_GMAC_authentication_verify(&gmac_test_case_2);
13041 }
13042
13043 static int
13044 test_AES_GMAC_authentication_verify_test_case_3(void)
13045 {
13046         return test_AES_GMAC_authentication_verify(&gmac_test_case_3);
13047 }
13048
13049 static int
13050 test_AES_GMAC_authentication_verify_test_case_4(void)
13051 {
13052         return test_AES_GMAC_authentication_verify(&gmac_test_case_4);
13053 }
13054
13055 static int
13056 test_AES_GMAC_authentication_SGL(const struct gmac_test_data *tdata,
13057                                 uint32_t fragsz)
13058 {
13059         struct crypto_testsuite_params *ts_params = &testsuite_params;
13060         struct crypto_unittest_params *ut_params = &unittest_params;
13061         struct rte_cryptodev_info dev_info;
13062         uint64_t feature_flags;
13063         unsigned int trn_data = 0;
13064         void *digest_mem = NULL;
13065         uint32_t segs = 1;
13066         unsigned int to_trn = 0;
13067         struct rte_mbuf *buf = NULL;
13068         uint8_t *auth_tag, *plaintext;
13069         int retval;
13070
13071         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
13072                               "No GMAC length in the source data");
13073
13074         /* Verify the capabilities */
13075         struct rte_cryptodev_sym_capability_idx cap_idx;
13076         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13077         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
13078         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13079                         &cap_idx) == NULL)
13080                 return TEST_SKIPPED;
13081
13082         /* Check for any input SGL support */
13083         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13084         feature_flags = dev_info.feature_flags;
13085
13086         if ((!(feature_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) ||
13087                         (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT)) ||
13088                         (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)))
13089                 return TEST_SKIPPED;
13090
13091         if (fragsz > tdata->plaintext.len)
13092                 fragsz = tdata->plaintext.len;
13093
13094         uint16_t plaintext_len = fragsz;
13095
13096         retval = create_gmac_session(ts_params->valid_devs[0],
13097                         tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
13098
13099         if (retval == -ENOTSUP)
13100                 return TEST_SKIPPED;
13101         if (retval < 0)
13102                 return retval;
13103
13104         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13105         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13106                         "Failed to allocate input buffer in mempool");
13107
13108         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13109                         rte_pktmbuf_tailroom(ut_params->ibuf));
13110
13111         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13112                                 plaintext_len);
13113         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
13114
13115         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
13116
13117         trn_data += plaintext_len;
13118
13119         buf = ut_params->ibuf;
13120
13121         /*
13122          * Loop until no more fragments
13123          */
13124
13125         while (trn_data < tdata->plaintext.len) {
13126                 ++segs;
13127                 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
13128                                 (tdata->plaintext.len - trn_data) : fragsz;
13129
13130                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13131                 buf = buf->next;
13132
13133                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
13134                                 rte_pktmbuf_tailroom(buf));
13135
13136                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
13137                                 to_trn);
13138
13139                 memcpy(plaintext, tdata->plaintext.data + trn_data,
13140                                 to_trn);
13141                 trn_data += to_trn;
13142                 if (trn_data  == tdata->plaintext.len)
13143                         digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
13144                                         tdata->gmac_tag.len);
13145         }
13146         ut_params->ibuf->nb_segs = segs;
13147
13148         /*
13149          * Place digest at the end of the last buffer
13150          */
13151         uint64_t digest_phys = rte_pktmbuf_iova(buf) + to_trn;
13152
13153         if (!digest_mem) {
13154                 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13155                                 + tdata->gmac_tag.len);
13156                 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
13157                                 tdata->plaintext.len);
13158         }
13159
13160         retval = create_gmac_operation_sgl(RTE_CRYPTO_AUTH_OP_GENERATE,
13161                         tdata, digest_mem, digest_phys);
13162
13163         if (retval < 0)
13164                 return retval;
13165
13166         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
13167
13168         ut_params->op->sym->m_src = ut_params->ibuf;
13169
13170         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13171                 return TEST_SKIPPED;
13172
13173         TEST_ASSERT_NOT_NULL(
13174                 process_crypto_request(ts_params->valid_devs[0],
13175                 ut_params->op), "failed to process sym crypto op");
13176
13177         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
13178                         "crypto op processing failed");
13179
13180         auth_tag = digest_mem;
13181         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
13182         TEST_ASSERT_BUFFERS_ARE_EQUAL(
13183                         auth_tag,
13184                         tdata->gmac_tag.data,
13185                         tdata->gmac_tag.len,
13186                         "GMAC Generated auth tag not as expected");
13187
13188         return 0;
13189 }
13190
13191 /* Segment size not multiple of block size (16B) */
13192 static int
13193 test_AES_GMAC_authentication_SGL_40B(void)
13194 {
13195         return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 40);
13196 }
13197
13198 static int
13199 test_AES_GMAC_authentication_SGL_80B(void)
13200 {
13201         return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 80);
13202 }
13203
13204 static int
13205 test_AES_GMAC_authentication_SGL_2048B(void)
13206 {
13207         return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2048);
13208 }
13209
13210 /* Segment size not multiple of block size (16B) */
13211 static int
13212 test_AES_GMAC_authentication_SGL_2047B(void)
13213 {
13214         return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2047);
13215 }
13216
13217 struct test_crypto_vector {
13218         enum rte_crypto_cipher_algorithm crypto_algo;
13219         unsigned int cipher_offset;
13220         unsigned int cipher_len;
13221
13222         struct {
13223                 uint8_t data[64];
13224                 unsigned int len;
13225         } cipher_key;
13226
13227         struct {
13228                 uint8_t data[64];
13229                 unsigned int len;
13230         } iv;
13231
13232         struct {
13233                 const uint8_t *data;
13234                 unsigned int len;
13235         } plaintext;
13236
13237         struct {
13238                 const uint8_t *data;
13239                 unsigned int len;
13240         } ciphertext;
13241
13242         enum rte_crypto_auth_algorithm auth_algo;
13243         unsigned int auth_offset;
13244
13245         struct {
13246                 uint8_t data[128];
13247                 unsigned int len;
13248         } auth_key;
13249
13250         struct {
13251                 const uint8_t *data;
13252                 unsigned int len;
13253         } aad;
13254
13255         struct {
13256                 uint8_t data[128];
13257                 unsigned int len;
13258         } digest;
13259 };
13260
13261 static const struct test_crypto_vector
13262 hmac_sha1_test_crypto_vector = {
13263         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
13264         .plaintext = {
13265                 .data = plaintext_hash,
13266                 .len = 512
13267         },
13268         .auth_key = {
13269                 .data = {
13270                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
13271                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
13272                         0xDE, 0xF4, 0xDE, 0xAD
13273                 },
13274                 .len = 20
13275         },
13276         .digest = {
13277                 .data = {
13278                         0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
13279                         0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
13280                         0x3F, 0x91, 0x64, 0x59
13281                 },
13282                 .len = 20
13283         }
13284 };
13285
13286 static const struct test_crypto_vector
13287 aes128_gmac_test_vector = {
13288         .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
13289         .plaintext = {
13290                 .data = plaintext_hash,
13291                 .len = 512
13292         },
13293         .iv = {
13294                 .data = {
13295                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
13296                         0x08, 0x09, 0x0A, 0x0B
13297                 },
13298                 .len = 12
13299         },
13300         .auth_key = {
13301                 .data = {
13302                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
13303                         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
13304                 },
13305                 .len = 16
13306         },
13307         .digest = {
13308                 .data = {
13309                         0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56,
13310                         0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A
13311                 },
13312                 .len = 16
13313         }
13314 };
13315
13316 static const struct test_crypto_vector
13317 aes128cbc_hmac_sha1_test_vector = {
13318         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
13319         .cipher_offset = 0,
13320         .cipher_len = 512,
13321         .cipher_key = {
13322                 .data = {
13323                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
13324                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
13325                 },
13326                 .len = 16
13327         },
13328         .iv = {
13329                 .data = {
13330                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
13331                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
13332                 },
13333                 .len = 16
13334         },
13335         .plaintext = {
13336                 .data = plaintext_hash,
13337                 .len = 512
13338         },
13339         .ciphertext = {
13340                 .data = ciphertext512_aes128cbc,
13341                 .len = 512
13342         },
13343         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
13344         .auth_offset = 0,
13345         .auth_key = {
13346                 .data = {
13347                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
13348                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
13349                         0xDE, 0xF4, 0xDE, 0xAD
13350                 },
13351                 .len = 20
13352         },
13353         .digest = {
13354                 .data = {
13355                         0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
13356                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
13357                         0x18, 0x8C, 0x1D, 0x32
13358                 },
13359                 .len = 20
13360         }
13361 };
13362
13363 static const struct test_crypto_vector
13364 aes128cbc_hmac_sha1_aad_test_vector = {
13365         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
13366         .cipher_offset = 8,
13367         .cipher_len = 496,
13368         .cipher_key = {
13369                 .data = {
13370                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
13371                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
13372                 },
13373                 .len = 16
13374         },
13375         .iv = {
13376                 .data = {
13377                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
13378                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
13379                 },
13380                 .len = 16
13381         },
13382         .plaintext = {
13383                 .data = plaintext_hash,
13384                 .len = 512
13385         },
13386         .ciphertext = {
13387                 .data = ciphertext512_aes128cbc_aad,
13388                 .len = 512
13389         },
13390         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
13391         .auth_offset = 0,
13392         .auth_key = {
13393                 .data = {
13394                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
13395                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
13396                         0xDE, 0xF4, 0xDE, 0xAD
13397                 },
13398                 .len = 20
13399         },
13400         .digest = {
13401                 .data = {
13402                         0x6D, 0xF3, 0x50, 0x79, 0x7A, 0x2A, 0xAC, 0x7F,
13403                         0xA6, 0xF0, 0xC6, 0x38, 0x1F, 0xA4, 0xDD, 0x9B,
13404                         0x62, 0x0F, 0xFB, 0x10
13405                 },
13406                 .len = 20
13407         }
13408 };
13409
13410 static void
13411 data_corruption(uint8_t *data)
13412 {
13413         data[0] += 1;
13414 }
13415
13416 static void
13417 tag_corruption(uint8_t *data, unsigned int tag_offset)
13418 {
13419         data[tag_offset] += 1;
13420 }
13421
13422 static int
13423 create_auth_session(struct crypto_unittest_params *ut_params,
13424                 uint8_t dev_id,
13425                 const struct test_crypto_vector *reference,
13426                 enum rte_crypto_auth_operation auth_op)
13427 {
13428         struct crypto_testsuite_params *ts_params = &testsuite_params;
13429         uint8_t auth_key[reference->auth_key.len + 1];
13430         int status;
13431
13432         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
13433
13434         /* Setup Authentication Parameters */
13435         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13436         ut_params->auth_xform.auth.op = auth_op;
13437         ut_params->auth_xform.next = NULL;
13438         ut_params->auth_xform.auth.algo = reference->auth_algo;
13439         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
13440         ut_params->auth_xform.auth.key.data = auth_key;
13441         ut_params->auth_xform.auth.digest_length = reference->digest.len;
13442
13443         /* Create Crypto session*/
13444         ut_params->sess = rte_cryptodev_sym_session_create(
13445                         ts_params->session_mpool);
13446         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
13447
13448         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
13449                                 &ut_params->auth_xform,
13450                                 ts_params->session_priv_mpool);
13451
13452         return status;
13453 }
13454
13455 static int
13456 create_auth_cipher_session(struct crypto_unittest_params *ut_params,
13457                 uint8_t dev_id,
13458                 const struct test_crypto_vector *reference,
13459                 enum rte_crypto_auth_operation auth_op,
13460                 enum rte_crypto_cipher_operation cipher_op)
13461 {
13462         struct crypto_testsuite_params *ts_params = &testsuite_params;
13463         uint8_t cipher_key[reference->cipher_key.len + 1];
13464         uint8_t auth_key[reference->auth_key.len + 1];
13465         int status;
13466
13467         memcpy(cipher_key, reference->cipher_key.data,
13468                         reference->cipher_key.len);
13469         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
13470
13471         /* Setup Authentication Parameters */
13472         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13473         ut_params->auth_xform.auth.op = auth_op;
13474         ut_params->auth_xform.auth.algo = reference->auth_algo;
13475         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
13476         ut_params->auth_xform.auth.key.data = auth_key;
13477         ut_params->auth_xform.auth.digest_length = reference->digest.len;
13478
13479         if (reference->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) {
13480                 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
13481                 ut_params->auth_xform.auth.iv.length = reference->iv.len;
13482         } else {
13483                 ut_params->auth_xform.next = &ut_params->cipher_xform;
13484
13485                 /* Setup Cipher Parameters */
13486                 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13487                 ut_params->cipher_xform.next = NULL;
13488                 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
13489                 ut_params->cipher_xform.cipher.op = cipher_op;
13490                 ut_params->cipher_xform.cipher.key.data = cipher_key;
13491                 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
13492                 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
13493                 ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
13494         }
13495
13496         /* Create Crypto session*/
13497         ut_params->sess = rte_cryptodev_sym_session_create(
13498                         ts_params->session_mpool);
13499         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
13500
13501         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
13502                                 &ut_params->auth_xform,
13503                                 ts_params->session_priv_mpool);
13504
13505         return status;
13506 }
13507
13508 static int
13509 create_auth_operation(struct crypto_testsuite_params *ts_params,
13510                 struct crypto_unittest_params *ut_params,
13511                 const struct test_crypto_vector *reference,
13512                 unsigned int auth_generate)
13513 {
13514         /* Generate Crypto op data structure */
13515         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
13516                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
13517         TEST_ASSERT_NOT_NULL(ut_params->op,
13518                         "Failed to allocate pktmbuf offload");
13519
13520         /* Set crypto operation data parameters */
13521         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
13522
13523         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
13524
13525         /* set crypto operation source mbuf */
13526         sym_op->m_src = ut_params->ibuf;
13527
13528         /* digest */
13529         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
13530                         ut_params->ibuf, reference->digest.len);
13531
13532         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
13533                         "no room to append auth tag");
13534
13535         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
13536                         ut_params->ibuf, reference->plaintext.len);
13537
13538         if (auth_generate)
13539                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
13540         else
13541                 memcpy(sym_op->auth.digest.data,
13542                                 reference->digest.data,
13543                                 reference->digest.len);
13544
13545         debug_hexdump(stdout, "digest:",
13546                         sym_op->auth.digest.data,
13547                         reference->digest.len);
13548
13549         sym_op->auth.data.length = reference->plaintext.len;
13550         sym_op->auth.data.offset = 0;
13551
13552         return 0;
13553 }
13554
13555 static int
13556 create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
13557                 struct crypto_unittest_params *ut_params,
13558                 const struct test_crypto_vector *reference,
13559                 unsigned int auth_generate)
13560 {
13561         /* Generate Crypto op data structure */
13562         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
13563                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
13564         TEST_ASSERT_NOT_NULL(ut_params->op,
13565                         "Failed to allocate pktmbuf offload");
13566
13567         /* Set crypto operation data parameters */
13568         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
13569
13570         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
13571
13572         /* set crypto operation source mbuf */
13573         sym_op->m_src = ut_params->ibuf;
13574
13575         /* digest */
13576         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
13577                         ut_params->ibuf, reference->digest.len);
13578
13579         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
13580                         "no room to append auth tag");
13581
13582         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
13583                         ut_params->ibuf, reference->ciphertext.len);
13584
13585         if (auth_generate)
13586                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
13587         else
13588                 memcpy(sym_op->auth.digest.data,
13589                                 reference->digest.data,
13590                                 reference->digest.len);
13591
13592         debug_hexdump(stdout, "digest:",
13593                         sym_op->auth.digest.data,
13594                         reference->digest.len);
13595
13596         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
13597                         reference->iv.data, reference->iv.len);
13598
13599         sym_op->cipher.data.length = 0;
13600         sym_op->cipher.data.offset = 0;
13601
13602         sym_op->auth.data.length = reference->plaintext.len;
13603         sym_op->auth.data.offset = 0;
13604
13605         return 0;
13606 }
13607
13608 static int
13609 create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
13610                 struct crypto_unittest_params *ut_params,
13611                 const struct test_crypto_vector *reference,
13612                 unsigned int auth_generate)
13613 {
13614         /* Generate Crypto op data structure */
13615         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
13616                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
13617         TEST_ASSERT_NOT_NULL(ut_params->op,
13618                         "Failed to allocate pktmbuf offload");
13619
13620         /* Set crypto operation data parameters */
13621         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
13622
13623         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
13624
13625         /* set crypto operation source mbuf */
13626         sym_op->m_src = ut_params->ibuf;
13627
13628         /* digest */
13629         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
13630                         ut_params->ibuf, reference->digest.len);
13631
13632         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
13633                         "no room to append auth tag");
13634
13635         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
13636                         ut_params->ibuf, reference->ciphertext.len);
13637
13638         if (auth_generate)
13639                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
13640         else
13641                 memcpy(sym_op->auth.digest.data,
13642                                 reference->digest.data,
13643                                 reference->digest.len);
13644
13645         debug_hexdump(stdout, "digest:",
13646                         sym_op->auth.digest.data,
13647                         reference->digest.len);
13648
13649         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
13650                         reference->iv.data, reference->iv.len);
13651
13652         sym_op->cipher.data.length = reference->cipher_len;
13653         sym_op->cipher.data.offset = reference->cipher_offset;
13654
13655         sym_op->auth.data.length = reference->plaintext.len;
13656         sym_op->auth.data.offset = reference->auth_offset;
13657
13658         return 0;
13659 }
13660
13661 static int
13662 create_auth_verify_operation(struct crypto_testsuite_params *ts_params,
13663                 struct crypto_unittest_params *ut_params,
13664                 const struct test_crypto_vector *reference)
13665 {
13666         return create_auth_operation(ts_params, ut_params, reference, 0);
13667 }
13668
13669 static int
13670 create_auth_verify_GMAC_operation(
13671                 struct crypto_testsuite_params *ts_params,
13672                 struct crypto_unittest_params *ut_params,
13673                 const struct test_crypto_vector *reference)
13674 {
13675         return create_auth_GMAC_operation(ts_params, ut_params, reference, 0);
13676 }
13677
13678 static int
13679 create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params,
13680                 struct crypto_unittest_params *ut_params,
13681                 const struct test_crypto_vector *reference)
13682 {
13683         return create_cipher_auth_operation(ts_params, ut_params, reference, 0);
13684 }
13685
13686 static int
13687 test_authentication_verify_fail_when_data_corruption(
13688                 struct crypto_testsuite_params *ts_params,
13689                 struct crypto_unittest_params *ut_params,
13690                 const struct test_crypto_vector *reference,
13691                 unsigned int data_corrupted)
13692 {
13693         int retval;
13694
13695         uint8_t *plaintext;
13696         struct rte_cryptodev_info dev_info;
13697
13698         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13699         uint64_t feat_flags = dev_info.feature_flags;
13700
13701         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13702                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13703                 printf("Device doesn't support RAW data-path APIs.\n");
13704                 return TEST_SKIPPED;
13705         }
13706
13707         /* Verify the capabilities */
13708         struct rte_cryptodev_sym_capability_idx cap_idx;
13709         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13710         cap_idx.algo.auth = reference->auth_algo;
13711         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13712                         &cap_idx) == NULL)
13713                 return TEST_SKIPPED;
13714
13715
13716         /* Create session */
13717         retval = create_auth_session(ut_params,
13718                         ts_params->valid_devs[0],
13719                         reference,
13720                         RTE_CRYPTO_AUTH_OP_VERIFY);
13721
13722         if (retval == -ENOTSUP)
13723                 return TEST_SKIPPED;
13724         if (retval < 0)
13725                 return retval;
13726
13727         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13728         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13729                         "Failed to allocate input buffer in mempool");
13730
13731         /* clear mbuf payload */
13732         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13733                         rte_pktmbuf_tailroom(ut_params->ibuf));
13734
13735         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13736                         reference->plaintext.len);
13737         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
13738         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
13739
13740         debug_hexdump(stdout, "plaintext:", plaintext,
13741                 reference->plaintext.len);
13742
13743         /* Create operation */
13744         retval = create_auth_verify_operation(ts_params, ut_params, reference);
13745
13746         if (retval < 0)
13747                 return retval;
13748
13749         if (data_corrupted)
13750                 data_corruption(plaintext);
13751         else
13752                 tag_corruption(plaintext, reference->plaintext.len);
13753
13754         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
13755                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13756                         ut_params->op);
13757                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
13758                         RTE_CRYPTO_OP_STATUS_SUCCESS,
13759                         "authentication not failed");
13760         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13761                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13762                                 ut_params->op, 0, 1, 0, 0);
13763         else {
13764                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13765                         ut_params->op);
13766         }
13767         if (ut_params->op == NULL)
13768                 return 0;
13769         else if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS)
13770                 return 0;
13771
13772         return -1;
13773 }
13774
13775 static int
13776 test_authentication_verify_GMAC_fail_when_corruption(
13777                 struct crypto_testsuite_params *ts_params,
13778                 struct crypto_unittest_params *ut_params,
13779                 const struct test_crypto_vector *reference,
13780                 unsigned int data_corrupted)
13781 {
13782         int retval;
13783         uint8_t *plaintext;
13784         struct rte_cryptodev_info dev_info;
13785
13786         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13787         uint64_t feat_flags = dev_info.feature_flags;
13788
13789         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13790                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13791                 printf("Device doesn't support RAW data-path APIs.\n");
13792                 return TEST_SKIPPED;
13793         }
13794
13795         /* Verify the capabilities */
13796         struct rte_cryptodev_sym_capability_idx cap_idx;
13797         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13798         cap_idx.algo.auth = reference->auth_algo;
13799         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13800                         &cap_idx) == NULL)
13801                 return TEST_SKIPPED;
13802
13803         /* Create session */
13804         retval = create_auth_cipher_session(ut_params,
13805                         ts_params->valid_devs[0],
13806                         reference,
13807                         RTE_CRYPTO_AUTH_OP_VERIFY,
13808                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
13809         if (retval < 0)
13810                 return retval;
13811
13812         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13813         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13814                         "Failed to allocate input buffer in mempool");
13815
13816         /* clear mbuf payload */
13817         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13818                         rte_pktmbuf_tailroom(ut_params->ibuf));
13819
13820         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13821                         reference->plaintext.len);
13822         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
13823         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
13824
13825         debug_hexdump(stdout, "plaintext:", plaintext,
13826                 reference->plaintext.len);
13827
13828         /* Create operation */
13829         retval = create_auth_verify_GMAC_operation(ts_params,
13830                         ut_params,
13831                         reference);
13832
13833         if (retval < 0)
13834                 return retval;
13835
13836         if (data_corrupted)
13837                 data_corruption(plaintext);
13838         else
13839                 tag_corruption(plaintext, reference->aad.len);
13840
13841         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
13842                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13843                         ut_params->op);
13844                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
13845                         RTE_CRYPTO_OP_STATUS_SUCCESS,
13846                         "authentication not failed");
13847         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13848                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13849                                 ut_params->op, 0, 1, 0, 0);
13850         else {
13851                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13852                         ut_params->op);
13853                 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
13854         }
13855
13856         return 0;
13857 }
13858
13859 static int
13860 test_authenticated_decryption_fail_when_corruption(
13861                 struct crypto_testsuite_params *ts_params,
13862                 struct crypto_unittest_params *ut_params,
13863                 const struct test_crypto_vector *reference,
13864                 unsigned int data_corrupted)
13865 {
13866         int retval;
13867
13868         uint8_t *ciphertext;
13869         struct rte_cryptodev_info dev_info;
13870
13871         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13872         uint64_t feat_flags = dev_info.feature_flags;
13873
13874         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13875                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13876                 printf("Device doesn't support RAW data-path APIs.\n");
13877                 return TEST_SKIPPED;
13878         }
13879
13880         /* Verify the capabilities */
13881         struct rte_cryptodev_sym_capability_idx cap_idx;
13882         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13883         cap_idx.algo.auth = reference->auth_algo;
13884         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13885                         &cap_idx) == NULL)
13886                 return TEST_SKIPPED;
13887         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13888         cap_idx.algo.cipher = reference->crypto_algo;
13889         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13890                         &cap_idx) == NULL)
13891                 return TEST_SKIPPED;
13892
13893         /* Create session */
13894         retval = create_auth_cipher_session(ut_params,
13895                         ts_params->valid_devs[0],
13896                         reference,
13897                         RTE_CRYPTO_AUTH_OP_VERIFY,
13898                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
13899
13900         if (retval == -ENOTSUP)
13901                 return TEST_SKIPPED;
13902         if (retval < 0)
13903                 return retval;
13904
13905         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13906         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13907                         "Failed to allocate input buffer in mempool");
13908
13909         /* clear mbuf payload */
13910         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13911                         rte_pktmbuf_tailroom(ut_params->ibuf));
13912
13913         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13914                         reference->ciphertext.len);
13915         TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
13916         memcpy(ciphertext, reference->ciphertext.data,
13917                         reference->ciphertext.len);
13918
13919         /* Create operation */
13920         retval = create_cipher_auth_verify_operation(ts_params,
13921                         ut_params,
13922                         reference);
13923
13924         if (retval < 0)
13925                 return retval;
13926
13927         if (data_corrupted)
13928                 data_corruption(ciphertext);
13929         else
13930                 tag_corruption(ciphertext, reference->ciphertext.len);
13931
13932         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
13933                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13934                         ut_params->op);
13935                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
13936                         RTE_CRYPTO_OP_STATUS_SUCCESS,
13937                         "authentication not failed");
13938         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13939                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13940                                 ut_params->op, 1, 1, 0, 0);
13941         else {
13942                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13943                         ut_params->op);
13944                 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
13945         }
13946
13947         return 0;
13948 }
13949
13950 static int
13951 test_authenticated_encrypt_with_esn(
13952                 struct crypto_testsuite_params *ts_params,
13953                 struct crypto_unittest_params *ut_params,
13954                 const struct test_crypto_vector *reference)
13955 {
13956         int retval;
13957
13958         uint8_t *authciphertext, *plaintext, *auth_tag;
13959         uint16_t plaintext_pad_len;
13960         uint8_t cipher_key[reference->cipher_key.len + 1];
13961         uint8_t auth_key[reference->auth_key.len + 1];
13962         struct rte_cryptodev_info dev_info;
13963         int status;
13964
13965         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13966         uint64_t feat_flags = dev_info.feature_flags;
13967
13968         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13969                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13970                 printf("Device doesn't support RAW data-path APIs.\n");
13971                 return TEST_SKIPPED;
13972         }
13973
13974         /* Verify the capabilities */
13975         struct rte_cryptodev_sym_capability_idx cap_idx;
13976         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13977         cap_idx.algo.auth = reference->auth_algo;
13978         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13979                         &cap_idx) == NULL)
13980                 return TEST_SKIPPED;
13981         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13982         cap_idx.algo.cipher = reference->crypto_algo;
13983         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13984                         &cap_idx) == NULL)
13985                 return TEST_SKIPPED;
13986
13987         /* Create session */
13988         memcpy(cipher_key, reference->cipher_key.data,
13989                         reference->cipher_key.len);
13990         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
13991
13992         /* Setup Cipher Parameters */
13993         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13994         ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
13995         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
13996         ut_params->cipher_xform.cipher.key.data = cipher_key;
13997         ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
13998         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
13999         ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
14000
14001         ut_params->cipher_xform.next = &ut_params->auth_xform;
14002
14003         /* Setup Authentication Parameters */
14004         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
14005         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
14006         ut_params->auth_xform.auth.algo = reference->auth_algo;
14007         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
14008         ut_params->auth_xform.auth.key.data = auth_key;
14009         ut_params->auth_xform.auth.digest_length = reference->digest.len;
14010         ut_params->auth_xform.next = NULL;
14011
14012         /* Create Crypto session*/
14013         ut_params->sess = rte_cryptodev_sym_session_create(
14014                         ts_params->session_mpool);
14015         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
14016
14017         status = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
14018                                 ut_params->sess,
14019                                 &ut_params->cipher_xform,
14020                                 ts_params->session_priv_mpool);
14021
14022         if (status == -ENOTSUP)
14023                 return TEST_SKIPPED;
14024
14025         TEST_ASSERT_EQUAL(status, 0, "Session init failed");
14026
14027         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
14028         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
14029                         "Failed to allocate input buffer in mempool");
14030
14031         /* clear mbuf payload */
14032         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
14033                         rte_pktmbuf_tailroom(ut_params->ibuf));
14034
14035         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
14036                         reference->plaintext.len);
14037         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
14038         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
14039
14040         /* Create operation */
14041         retval = create_cipher_auth_operation(ts_params,
14042                         ut_params,
14043                         reference, 0);
14044
14045         if (retval < 0)
14046                 return retval;
14047
14048         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
14049                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
14050                         ut_params->op);
14051         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
14052                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
14053                                 ut_params->op, 1, 1, 0, 0);
14054         else
14055                 ut_params->op = process_crypto_request(
14056                         ts_params->valid_devs[0], ut_params->op);
14057
14058         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
14059
14060         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
14061                         "crypto op processing failed");
14062
14063         plaintext_pad_len = RTE_ALIGN_CEIL(reference->plaintext.len, 16);
14064
14065         authciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
14066                         ut_params->op->sym->auth.data.offset);
14067         auth_tag = authciphertext + plaintext_pad_len;
14068         debug_hexdump(stdout, "ciphertext:", authciphertext,
14069                         reference->ciphertext.len);
14070         debug_hexdump(stdout, "auth tag:", auth_tag, reference->digest.len);
14071
14072         /* Validate obuf */
14073         TEST_ASSERT_BUFFERS_ARE_EQUAL(
14074                         authciphertext,
14075                         reference->ciphertext.data,
14076                         reference->ciphertext.len,
14077                         "Ciphertext data not as expected");
14078
14079         TEST_ASSERT_BUFFERS_ARE_EQUAL(
14080                         auth_tag,
14081                         reference->digest.data,
14082                         reference->digest.len,
14083                         "Generated digest not as expected");
14084
14085         return TEST_SUCCESS;
14086
14087 }
14088
14089 static int
14090 test_authenticated_decrypt_with_esn(
14091                 struct crypto_testsuite_params *ts_params,
14092                 struct crypto_unittest_params *ut_params,
14093                 const struct test_crypto_vector *reference)
14094 {
14095         int retval;
14096
14097         uint8_t *ciphertext;
14098         uint8_t cipher_key[reference->cipher_key.len + 1];
14099         uint8_t auth_key[reference->auth_key.len + 1];
14100         struct rte_cryptodev_info dev_info;
14101
14102         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
14103         uint64_t feat_flags = dev_info.feature_flags;
14104
14105         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
14106                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
14107                 printf("Device doesn't support RAW data-path APIs.\n");
14108                 return TEST_SKIPPED;
14109         }
14110
14111         /* Verify the capabilities */
14112         struct rte_cryptodev_sym_capability_idx cap_idx;
14113         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
14114         cap_idx.algo.auth = reference->auth_algo;
14115         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
14116                         &cap_idx) == NULL)
14117                 return TEST_SKIPPED;
14118         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
14119         cap_idx.algo.cipher = reference->crypto_algo;
14120         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
14121                         &cap_idx) == NULL)
14122                 return TEST_SKIPPED;
14123
14124         /* Create session */
14125         memcpy(cipher_key, reference->cipher_key.data,
14126                         reference->cipher_key.len);
14127         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
14128
14129         /* Setup Authentication Parameters */
14130         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
14131         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
14132         ut_params->auth_xform.auth.algo = reference->auth_algo;
14133         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
14134         ut_params->auth_xform.auth.key.data = auth_key;
14135         ut_params->auth_xform.auth.digest_length = reference->digest.len;
14136         ut_params->auth_xform.next = &ut_params->cipher_xform;
14137
14138         /* Setup Cipher Parameters */
14139         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
14140         ut_params->cipher_xform.next = NULL;
14141         ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
14142         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
14143         ut_params->cipher_xform.cipher.key.data = cipher_key;
14144         ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
14145         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
14146         ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
14147
14148         /* Create Crypto session*/
14149         ut_params->sess = rte_cryptodev_sym_session_create(
14150                         ts_params->session_mpool);
14151         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
14152
14153         retval = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
14154                                 ut_params->sess,
14155                                 &ut_params->auth_xform,
14156                                 ts_params->session_priv_mpool);
14157
14158         if (retval == -ENOTSUP)
14159                 return TEST_SKIPPED;
14160
14161         TEST_ASSERT_EQUAL(retval, 0, "Session init failed");
14162
14163         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
14164         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
14165                         "Failed to allocate input buffer in mempool");
14166
14167         /* clear mbuf payload */
14168         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
14169                         rte_pktmbuf_tailroom(ut_params->ibuf));
14170
14171         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
14172                         reference->ciphertext.len);
14173         TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
14174         memcpy(ciphertext, reference->ciphertext.data,
14175                         reference->ciphertext.len);
14176
14177         /* Create operation */
14178         retval = create_cipher_auth_verify_operation(ts_params,
14179                         ut_params,
14180                         reference);
14181
14182         if (retval < 0)
14183                 return retval;
14184
14185         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
14186                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
14187                         ut_params->op);
14188         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
14189                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
14190                                 ut_params->op, 1, 1, 0, 0);
14191         else
14192                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
14193                         ut_params->op);
14194
14195         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
14196         TEST_ASSERT_EQUAL(ut_params->op->status,
14197                         RTE_CRYPTO_OP_STATUS_SUCCESS,
14198                         "crypto op processing passed");
14199
14200         ut_params->obuf = ut_params->op->sym->m_src;
14201         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
14202
14203         return 0;
14204 }
14205
14206 static int
14207 create_aead_operation_SGL(enum rte_crypto_aead_operation op,
14208                 const struct aead_test_data *tdata,
14209                 void *digest_mem, uint64_t digest_phys)
14210 {
14211         struct crypto_testsuite_params *ts_params = &testsuite_params;
14212         struct crypto_unittest_params *ut_params = &unittest_params;
14213
14214         const unsigned int auth_tag_len = tdata->auth_tag.len;
14215         const unsigned int iv_len = tdata->iv.len;
14216         unsigned int aad_len = tdata->aad.len;
14217         unsigned int aad_len_pad = 0;
14218
14219         /* Generate Crypto op data structure */
14220         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
14221                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
14222         TEST_ASSERT_NOT_NULL(ut_params->op,
14223                 "Failed to allocate symmetric crypto operation struct");
14224
14225         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
14226
14227         sym_op->aead.digest.data = digest_mem;
14228
14229         TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
14230                         "no room to append digest");
14231
14232         sym_op->aead.digest.phys_addr = digest_phys;
14233
14234         if (op == RTE_CRYPTO_AEAD_OP_DECRYPT) {
14235                 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
14236                                 auth_tag_len);
14237                 debug_hexdump(stdout, "digest:",
14238                                 sym_op->aead.digest.data,
14239                                 auth_tag_len);
14240         }
14241
14242         /* Append aad data */
14243         if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
14244                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
14245                                 uint8_t *, IV_OFFSET);
14246
14247                 /* Copy IV 1 byte after the IV pointer, according to the API */
14248                 rte_memcpy(iv_ptr + 1, tdata->iv.data, iv_len);
14249
14250                 aad_len = RTE_ALIGN_CEIL(aad_len + 18, 16);
14251
14252                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
14253                                 ut_params->ibuf, aad_len);
14254                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
14255                                 "no room to prepend aad");
14256                 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
14257                                 ut_params->ibuf);
14258
14259                 memset(sym_op->aead.aad.data, 0, aad_len);
14260                 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
14261                 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
14262
14263                 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
14264                 debug_hexdump(stdout, "aad:",
14265                                 sym_op->aead.aad.data, aad_len);
14266         } else {
14267                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
14268                                 uint8_t *, IV_OFFSET);
14269
14270                 rte_memcpy(iv_ptr, tdata->iv.data, iv_len);
14271
14272                 aad_len_pad = RTE_ALIGN_CEIL(aad_len, 16);
14273
14274                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
14275                                 ut_params->ibuf, aad_len_pad);
14276                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
14277                                 "no room to prepend aad");
14278                 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
14279                                 ut_params->ibuf);
14280
14281                 memset(sym_op->aead.aad.data, 0, aad_len);
14282                 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
14283
14284                 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
14285                 debug_hexdump(stdout, "aad:",
14286                                 sym_op->aead.aad.data, aad_len);
14287         }
14288
14289         sym_op->aead.data.length = tdata->plaintext.len;
14290         sym_op->aead.data.offset = aad_len_pad;
14291
14292         return 0;
14293 }
14294
14295 #define SGL_MAX_NO      16
14296
14297 static int
14298 test_authenticated_encryption_SGL(const struct aead_test_data *tdata,
14299                 const int oop, uint32_t fragsz, uint32_t fragsz_oop)
14300 {
14301         struct crypto_testsuite_params *ts_params = &testsuite_params;
14302         struct crypto_unittest_params *ut_params = &unittest_params;
14303         struct rte_mbuf *buf, *buf_oop = NULL, *buf_last_oop = NULL;
14304         int retval;
14305         int to_trn = 0;
14306         int to_trn_tbl[SGL_MAX_NO];
14307         int segs = 1;
14308         unsigned int trn_data = 0;
14309         uint8_t *plaintext, *ciphertext, *auth_tag;
14310         struct rte_cryptodev_info dev_info;
14311
14312         /* Verify the capabilities */
14313         struct rte_cryptodev_sym_capability_idx cap_idx;
14314         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
14315         cap_idx.algo.aead = tdata->algo;
14316         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
14317                         &cap_idx) == NULL)
14318                 return TEST_SKIPPED;
14319
14320         /* OOP not supported with CPU crypto */
14321         if (oop && gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
14322                 return TEST_SKIPPED;
14323
14324         /* Detailed check for the particular SGL support flag */
14325         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
14326         if (!oop) {
14327                 unsigned int sgl_in = fragsz < tdata->plaintext.len;
14328                 if (sgl_in && (!(dev_info.feature_flags &
14329                                 RTE_CRYPTODEV_FF_IN_PLACE_SGL)))
14330                         return TEST_SKIPPED;
14331
14332                 uint64_t feat_flags = dev_info.feature_flags;
14333
14334                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
14335                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
14336                         printf("Device doesn't support RAW data-path APIs.\n");
14337                         return TEST_SKIPPED;
14338                 }
14339         } else {
14340                 unsigned int sgl_in = fragsz < tdata->plaintext.len;
14341                 unsigned int sgl_out = (fragsz_oop ? fragsz_oop : fragsz) <
14342                                 tdata->plaintext.len;
14343                 /* Raw data path API does not support OOP */
14344                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
14345                         return TEST_SKIPPED;
14346                 if (sgl_in && !sgl_out) {
14347                         if (!(dev_info.feature_flags &
14348                                         RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT))
14349                                 return TEST_SKIPPED;
14350                 } else if (!sgl_in && sgl_out) {
14351                         if (!(dev_info.feature_flags &
14352                                         RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT))
14353                                 return TEST_SKIPPED;
14354                 } else if (sgl_in && sgl_out) {
14355                         if (!(dev_info.feature_flags &
14356                                         RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT))
14357                                 return TEST_SKIPPED;
14358                 }
14359         }
14360
14361         if (fragsz > tdata->plaintext.len)
14362                 fragsz = tdata->plaintext.len;
14363
14364         uint16_t plaintext_len = fragsz;
14365         uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
14366
14367         if (fragsz_oop > tdata->plaintext.len)
14368                 frag_size_oop = tdata->plaintext.len;
14369
14370         int ecx = 0;
14371         void *digest_mem = NULL;
14372
14373         uint32_t prepend_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
14374
14375         if (tdata->plaintext.len % fragsz != 0) {
14376                 if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO)
14377                         return 1;
14378         }       else {
14379                 if (tdata->plaintext.len / fragsz > SGL_MAX_NO)
14380                         return 1;
14381         }
14382
14383         /*
14384          * For out-op-place we need to alloc another mbuf
14385          */
14386         if (oop) {
14387                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
14388                 rte_pktmbuf_append(ut_params->obuf,
14389                                 frag_size_oop + prepend_len);
14390                 buf_oop = ut_params->obuf;
14391         }
14392
14393         /* Create AEAD session */
14394         retval = create_aead_session(ts_params->valid_devs[0],
14395                         tdata->algo,
14396                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
14397                         tdata->key.data, tdata->key.len,
14398                         tdata->aad.len, tdata->auth_tag.len,
14399                         tdata->iv.len);
14400         if (retval < 0)
14401                 return retval;
14402
14403         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
14404
14405         /* clear mbuf payload */
14406         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
14407                         rte_pktmbuf_tailroom(ut_params->ibuf));
14408
14409         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
14410                         plaintext_len);
14411
14412         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
14413
14414         trn_data += plaintext_len;
14415
14416         buf = ut_params->ibuf;
14417
14418         /*
14419          * Loop until no more fragments
14420          */
14421
14422         while (trn_data < tdata->plaintext.len) {
14423                 ++segs;
14424                 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
14425                                 (tdata->plaintext.len - trn_data) : fragsz;
14426
14427                 to_trn_tbl[ecx++] = to_trn;
14428
14429                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
14430                 buf = buf->next;
14431
14432                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
14433                                 rte_pktmbuf_tailroom(buf));
14434
14435                 /* OOP */
14436                 if (oop && !fragsz_oop) {
14437                         buf_last_oop = buf_oop->next =
14438                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
14439                         buf_oop = buf_oop->next;
14440                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
14441                                         0, rte_pktmbuf_tailroom(buf_oop));
14442                         rte_pktmbuf_append(buf_oop, to_trn);
14443                 }
14444
14445                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
14446                                 to_trn);
14447
14448                 memcpy(plaintext, tdata->plaintext.data + trn_data,
14449                                 to_trn);
14450                 trn_data += to_trn;
14451                 if (trn_data  == tdata->plaintext.len) {
14452                         if (oop) {
14453                                 if (!fragsz_oop)
14454                                         digest_mem = rte_pktmbuf_append(buf_oop,
14455                                                 tdata->auth_tag.len);
14456                         } else
14457                                 digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
14458                                         tdata->auth_tag.len);
14459                 }
14460         }
14461
14462         uint64_t digest_phys = 0;
14463
14464         ut_params->ibuf->nb_segs = segs;
14465
14466         segs = 1;
14467         if (fragsz_oop && oop) {
14468                 to_trn = 0;
14469                 ecx = 0;
14470
14471                 if (frag_size_oop == tdata->plaintext.len) {
14472                         digest_mem = rte_pktmbuf_append(ut_params->obuf,
14473                                 tdata->auth_tag.len);
14474
14475                         digest_phys = rte_pktmbuf_iova_offset(
14476                                         ut_params->obuf,
14477                                         tdata->plaintext.len + prepend_len);
14478                 }
14479
14480                 trn_data = frag_size_oop;
14481                 while (trn_data < tdata->plaintext.len) {
14482                         ++segs;
14483                         to_trn =
14484                                 (tdata->plaintext.len - trn_data <
14485                                                 frag_size_oop) ?
14486                                 (tdata->plaintext.len - trn_data) :
14487                                                 frag_size_oop;
14488
14489                         to_trn_tbl[ecx++] = to_trn;
14490
14491                         buf_last_oop = buf_oop->next =
14492                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
14493                         buf_oop = buf_oop->next;
14494                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
14495                                         0, rte_pktmbuf_tailroom(buf_oop));
14496                         rte_pktmbuf_append(buf_oop, to_trn);
14497
14498                         trn_data += to_trn;
14499
14500                         if (trn_data  == tdata->plaintext.len) {
14501                                 digest_mem = rte_pktmbuf_append(buf_oop,
14502                                         tdata->auth_tag.len);
14503                         }
14504                 }
14505
14506                 ut_params->obuf->nb_segs = segs;
14507         }
14508
14509         /*
14510          * Place digest at the end of the last buffer
14511          */
14512         if (!digest_phys)
14513                 digest_phys = rte_pktmbuf_iova(buf) + to_trn;
14514         if (oop && buf_last_oop)
14515                 digest_phys = rte_pktmbuf_iova(buf_last_oop) + to_trn;
14516
14517         if (!digest_mem && !oop) {
14518                 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
14519                                 + tdata->auth_tag.len);
14520                 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
14521                                 tdata->plaintext.len);
14522         }
14523
14524         /* Create AEAD operation */
14525         retval = create_aead_operation_SGL(RTE_CRYPTO_AEAD_OP_ENCRYPT,
14526                         tdata, digest_mem, digest_phys);
14527
14528         if (retval < 0)
14529                 return retval;
14530
14531         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
14532
14533         ut_params->op->sym->m_src = ut_params->ibuf;
14534         if (oop)
14535                 ut_params->op->sym->m_dst = ut_params->obuf;
14536
14537         /* Process crypto operation */
14538         if (oop == IN_PLACE &&
14539                         gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
14540                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
14541         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
14542                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
14543                                 ut_params->op, 0, 0, 0, 0);
14544         else
14545                 TEST_ASSERT_NOT_NULL(
14546                         process_crypto_request(ts_params->valid_devs[0],
14547                         ut_params->op), "failed to process sym crypto op");
14548
14549         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
14550                         "crypto op processing failed");
14551
14552
14553         ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
14554                         uint8_t *, prepend_len);
14555         if (oop) {
14556                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
14557                                 uint8_t *, prepend_len);
14558         }
14559
14560         if (fragsz_oop)
14561                 fragsz = fragsz_oop;
14562
14563         TEST_ASSERT_BUFFERS_ARE_EQUAL(
14564                         ciphertext,
14565                         tdata->ciphertext.data,
14566                         fragsz,
14567                         "Ciphertext data not as expected");
14568
14569         buf = ut_params->op->sym->m_src->next;
14570         if (oop)
14571                 buf = ut_params->op->sym->m_dst->next;
14572
14573         unsigned int off = fragsz;
14574
14575         ecx = 0;
14576         while (buf) {
14577                 ciphertext = rte_pktmbuf_mtod(buf,
14578                                 uint8_t *);
14579
14580                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
14581                                 ciphertext,
14582                                 tdata->ciphertext.data + off,
14583                                 to_trn_tbl[ecx],
14584                                 "Ciphertext data not as expected");
14585
14586                 off += to_trn_tbl[ecx++];
14587                 buf = buf->next;
14588         }
14589
14590         auth_tag = digest_mem;
14591         TEST_ASSERT_BUFFERS_ARE_EQUAL(
14592                         auth_tag,
14593                         tdata->auth_tag.data,
14594                         tdata->auth_tag.len,
14595                         "Generated auth tag not as expected");
14596
14597         return 0;
14598 }
14599
14600 static int
14601 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void)
14602 {
14603         return test_authenticated_encryption_SGL(
14604                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 400, 400);
14605 }
14606
14607 static int
14608 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B(void)
14609 {
14610         return test_authenticated_encryption_SGL(
14611                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 1500, 2000);
14612 }
14613
14614 static int
14615 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void)
14616 {
14617         return test_authenticated_encryption_SGL(
14618                         &gcm_test_case_8, OUT_OF_PLACE, 400,
14619                         gcm_test_case_8.plaintext.len);
14620 }
14621
14622 static int
14623 test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void)
14624 {
14625         /* This test is not for OPENSSL PMD */
14626         if (gbl_driver_id == rte_cryptodev_driver_id_get(
14627                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)))
14628                 return TEST_SKIPPED;
14629
14630         return test_authenticated_encryption_SGL(
14631                         &gcm_test_case_SGL_1, IN_PLACE, 1500, 0);
14632 }
14633
14634 static int
14635 test_authentication_verify_fail_when_data_corrupted(
14636                 struct crypto_testsuite_params *ts_params,
14637                 struct crypto_unittest_params *ut_params,
14638                 const struct test_crypto_vector *reference)
14639 {
14640         return test_authentication_verify_fail_when_data_corruption(
14641                         ts_params, ut_params, reference, 1);
14642 }
14643
14644 static int
14645 test_authentication_verify_fail_when_tag_corrupted(
14646                 struct crypto_testsuite_params *ts_params,
14647                 struct crypto_unittest_params *ut_params,
14648                 const struct test_crypto_vector *reference)
14649 {
14650         return test_authentication_verify_fail_when_data_corruption(
14651                         ts_params, ut_params, reference, 0);
14652 }
14653
14654 static int
14655 test_authentication_verify_GMAC_fail_when_data_corrupted(
14656                 struct crypto_testsuite_params *ts_params,
14657                 struct crypto_unittest_params *ut_params,
14658                 const struct test_crypto_vector *reference)
14659 {
14660         return test_authentication_verify_GMAC_fail_when_corruption(
14661                         ts_params, ut_params, reference, 1);
14662 }
14663
14664 static int
14665 test_authentication_verify_GMAC_fail_when_tag_corrupted(
14666                 struct crypto_testsuite_params *ts_params,
14667                 struct crypto_unittest_params *ut_params,
14668                 const struct test_crypto_vector *reference)
14669 {
14670         return test_authentication_verify_GMAC_fail_when_corruption(
14671                         ts_params, ut_params, reference, 0);
14672 }
14673
14674 static int
14675 test_authenticated_decryption_fail_when_data_corrupted(
14676                 struct crypto_testsuite_params *ts_params,
14677                 struct crypto_unittest_params *ut_params,
14678                 const struct test_crypto_vector *reference)
14679 {
14680         return test_authenticated_decryption_fail_when_corruption(
14681                         ts_params, ut_params, reference, 1);
14682 }
14683
14684 static int
14685 test_authenticated_decryption_fail_when_tag_corrupted(
14686                 struct crypto_testsuite_params *ts_params,
14687                 struct crypto_unittest_params *ut_params,
14688                 const struct test_crypto_vector *reference)
14689 {
14690         return test_authenticated_decryption_fail_when_corruption(
14691                         ts_params, ut_params, reference, 0);
14692 }
14693
14694 static int
14695 authentication_verify_HMAC_SHA1_fail_data_corrupt(void)
14696 {
14697         return test_authentication_verify_fail_when_data_corrupted(
14698                         &testsuite_params, &unittest_params,
14699                         &hmac_sha1_test_crypto_vector);
14700 }
14701
14702 static int
14703 authentication_verify_HMAC_SHA1_fail_tag_corrupt(void)
14704 {
14705         return test_authentication_verify_fail_when_tag_corrupted(
14706                         &testsuite_params, &unittest_params,
14707                         &hmac_sha1_test_crypto_vector);
14708 }
14709
14710 static int
14711 authentication_verify_AES128_GMAC_fail_data_corrupt(void)
14712 {
14713         return test_authentication_verify_GMAC_fail_when_data_corrupted(
14714                         &testsuite_params, &unittest_params,
14715                         &aes128_gmac_test_vector);
14716 }
14717
14718 static int
14719 authentication_verify_AES128_GMAC_fail_tag_corrupt(void)
14720 {
14721         return test_authentication_verify_GMAC_fail_when_tag_corrupted(
14722                         &testsuite_params, &unittest_params,
14723                         &aes128_gmac_test_vector);
14724 }
14725
14726 static int
14727 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void)
14728 {
14729         return test_authenticated_decryption_fail_when_data_corrupted(
14730                         &testsuite_params,
14731                         &unittest_params,
14732                         &aes128cbc_hmac_sha1_test_vector);
14733 }
14734
14735 static int
14736 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void)
14737 {
14738         return test_authenticated_decryption_fail_when_tag_corrupted(
14739                         &testsuite_params,
14740                         &unittest_params,
14741                         &aes128cbc_hmac_sha1_test_vector);
14742 }
14743
14744 static int
14745 auth_encrypt_AES128CBC_HMAC_SHA1_esn_check(void)
14746 {
14747         return test_authenticated_encrypt_with_esn(
14748                         &testsuite_params,
14749                         &unittest_params,
14750                         &aes128cbc_hmac_sha1_aad_test_vector);
14751 }
14752
14753 static int
14754 auth_decrypt_AES128CBC_HMAC_SHA1_esn_check(void)
14755 {
14756         return test_authenticated_decrypt_with_esn(
14757                         &testsuite_params,
14758                         &unittest_params,
14759                         &aes128cbc_hmac_sha1_aad_test_vector);
14760 }
14761
14762 static int
14763 test_chacha20_poly1305_encrypt_test_case_rfc8439(void)
14764 {
14765         return test_authenticated_encryption(&chacha20_poly1305_case_rfc8439);
14766 }
14767
14768 static int
14769 test_chacha20_poly1305_decrypt_test_case_rfc8439(void)
14770 {
14771         return test_authenticated_decryption(&chacha20_poly1305_case_rfc8439);
14772 }
14773
14774 static int
14775 test_chacha20_poly1305_encrypt_SGL_out_of_place(void)
14776 {
14777         return test_authenticated_encryption_SGL(
14778                 &chacha20_poly1305_case_2, OUT_OF_PLACE, 32,
14779                 chacha20_poly1305_case_2.plaintext.len);
14780 }
14781
14782 #ifdef RTE_CRYPTO_SCHEDULER
14783
14784 /* global AESNI worker IDs for the scheduler test */
14785 uint8_t aesni_ids[2];
14786
14787 static int
14788 scheduler_testsuite_setup(void)
14789 {
14790         uint32_t i = 0;
14791         int32_t nb_devs, ret;
14792         char vdev_args[VDEV_ARGS_SIZE] = {""};
14793         char temp_str[VDEV_ARGS_SIZE] = {"mode=multi-core,"
14794                 "ordering=enable,name=cryptodev_test_scheduler,corelist="};
14795         uint16_t worker_core_count = 0;
14796         uint16_t socket_id = 0;
14797
14798         if (gbl_driver_id == rte_cryptodev_driver_id_get(
14799                         RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD))) {
14800
14801                 /* Identify the Worker Cores
14802                  * Use 2 worker cores for the device args
14803                  */
14804                 RTE_LCORE_FOREACH_WORKER(i) {
14805                         if (worker_core_count > 1)
14806                                 break;
14807                         snprintf(vdev_args, sizeof(vdev_args),
14808                                         "%s%d", temp_str, i);
14809                         strcpy(temp_str, vdev_args);
14810                         strlcat(temp_str, ";", sizeof(temp_str));
14811                         worker_core_count++;
14812                         socket_id = rte_lcore_to_socket_id(i);
14813                 }
14814                 if (worker_core_count != 2) {
14815                         RTE_LOG(ERR, USER1,
14816                                 "Cryptodev scheduler test require at least "
14817                                 "two worker cores to run. "
14818                                 "Please use the correct coremask.\n");
14819                         return TEST_FAILED;
14820                 }
14821                 strcpy(temp_str, vdev_args);
14822                 snprintf(vdev_args, sizeof(vdev_args), "%s,socket_id=%d",
14823                                 temp_str, socket_id);
14824                 RTE_LOG(DEBUG, USER1, "vdev_args: %s\n", vdev_args);
14825                 nb_devs = rte_cryptodev_device_count_by_driver(
14826                                 rte_cryptodev_driver_id_get(
14827                                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)));
14828                 if (nb_devs < 1) {
14829                         ret = rte_vdev_init(
14830                                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),
14831                                         vdev_args);
14832                         TEST_ASSERT(ret == 0,
14833                                 "Failed to create instance %u of pmd : %s",
14834                                 i, RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
14835                 }
14836         }
14837         return testsuite_setup();
14838 }
14839
14840 static int
14841 test_scheduler_attach_worker_op(void)
14842 {
14843         struct crypto_testsuite_params *ts_params = &testsuite_params;
14844         uint8_t sched_id = ts_params->valid_devs[0];
14845         uint32_t i, nb_devs_attached = 0;
14846         int ret;
14847         char vdev_name[32];
14848         unsigned int count = rte_cryptodev_count();
14849
14850         /* create 2 AESNI_MB vdevs on top of existing devices */
14851         for (i = count; i < count + 2; i++) {
14852                 snprintf(vdev_name, sizeof(vdev_name), "%s_%u",
14853                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD),
14854                                 i);
14855                 ret = rte_vdev_init(vdev_name, NULL);
14856
14857                 TEST_ASSERT(ret == 0,
14858                         "Failed to create instance %u of"
14859                         " pmd : %s",
14860                         i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
14861
14862                 if (ret < 0) {
14863                         RTE_LOG(ERR, USER1,
14864                                 "Failed to create 2 AESNI MB PMDs.\n");
14865                         return TEST_SKIPPED;
14866                 }
14867         }
14868
14869         /* attach 2 AESNI_MB cdevs */
14870         for (i = count; i < count + 2; i++) {
14871                 struct rte_cryptodev_info info;
14872                 unsigned int session_size;
14873
14874                 rte_cryptodev_info_get(i, &info);
14875                 if (info.driver_id != rte_cryptodev_driver_id_get(
14876                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)))
14877                         continue;
14878
14879                 session_size = rte_cryptodev_sym_get_private_session_size(i);
14880                 /*
14881                  * Create the session mempool again, since now there are new devices
14882                  * to use the mempool.
14883                  */
14884                 if (ts_params->session_mpool) {
14885                         rte_mempool_free(ts_params->session_mpool);
14886                         ts_params->session_mpool = NULL;
14887                 }
14888                 if (ts_params->session_priv_mpool) {
14889                         rte_mempool_free(ts_params->session_priv_mpool);
14890                         ts_params->session_priv_mpool = NULL;
14891                 }
14892
14893                 if (info.sym.max_nb_sessions != 0 &&
14894                                 info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
14895                         RTE_LOG(ERR, USER1,
14896                                         "Device does not support "
14897                                         "at least %u sessions\n",
14898                                         MAX_NB_SESSIONS);
14899                         return TEST_FAILED;
14900                 }
14901                 /*
14902                  * Create mempool with maximum number of sessions,
14903                  * to include the session headers
14904                  */
14905                 if (ts_params->session_mpool == NULL) {
14906                         ts_params->session_mpool =
14907                                 rte_cryptodev_sym_session_pool_create(
14908                                                 "test_sess_mp",
14909                                                 MAX_NB_SESSIONS, 0, 0, 0,
14910                                                 SOCKET_ID_ANY);
14911                         TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
14912                                         "session mempool allocation failed");
14913                 }
14914
14915                 /*
14916                  * Create mempool with maximum number of sessions,
14917                  * to include device specific session private data
14918                  */
14919                 if (ts_params->session_priv_mpool == NULL) {
14920                         ts_params->session_priv_mpool = rte_mempool_create(
14921                                         "test_sess_mp_priv",
14922                                         MAX_NB_SESSIONS,
14923                                         session_size,
14924                                         0, 0, NULL, NULL, NULL,
14925                                         NULL, SOCKET_ID_ANY,
14926                                         0);
14927
14928                         TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
14929                                         "session mempool allocation failed");
14930                 }
14931
14932                 ts_params->qp_conf.mp_session = ts_params->session_mpool;
14933                 ts_params->qp_conf.mp_session_private =
14934                                 ts_params->session_priv_mpool;
14935
14936                 ret = rte_cryptodev_scheduler_worker_attach(sched_id,
14937                                 (uint8_t)i);
14938
14939                 TEST_ASSERT(ret == 0,
14940                         "Failed to attach device %u of pmd : %s", i,
14941                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
14942
14943                 aesni_ids[nb_devs_attached] = (uint8_t)i;
14944
14945                 nb_devs_attached++;
14946         }
14947
14948         return 0;
14949 }
14950
14951 static int
14952 test_scheduler_detach_worker_op(void)
14953 {
14954         struct crypto_testsuite_params *ts_params = &testsuite_params;
14955         uint8_t sched_id = ts_params->valid_devs[0];
14956         uint32_t i;
14957         int ret;
14958
14959         for (i = 0; i < 2; i++) {
14960                 ret = rte_cryptodev_scheduler_worker_detach(sched_id,
14961                                 aesni_ids[i]);
14962                 TEST_ASSERT(ret == 0,
14963                         "Failed to detach device %u", aesni_ids[i]);
14964         }
14965
14966         return 0;
14967 }
14968
14969 static int
14970 test_scheduler_mode_op(enum rte_cryptodev_scheduler_mode scheduler_mode)
14971 {
14972         struct crypto_testsuite_params *ts_params = &testsuite_params;
14973         uint8_t sched_id = ts_params->valid_devs[0];
14974         /* set mode */
14975         return rte_cryptodev_scheduler_mode_set(sched_id,
14976                 scheduler_mode);
14977 }
14978
14979 static int
14980 test_scheduler_mode_roundrobin_op(void)
14981 {
14982         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) ==
14983                         0, "Failed to set roundrobin mode");
14984         return 0;
14985
14986 }
14987
14988 static int
14989 test_scheduler_mode_multicore_op(void)
14990 {
14991         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) ==
14992                         0, "Failed to set multicore mode");
14993
14994         return 0;
14995 }
14996
14997 static int
14998 test_scheduler_mode_failover_op(void)
14999 {
15000         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) ==
15001                         0, "Failed to set failover mode");
15002
15003         return 0;
15004 }
15005
15006 static int
15007 test_scheduler_mode_pkt_size_distr_op(void)
15008 {
15009         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) ==
15010                         0, "Failed to set pktsize mode");
15011
15012         return 0;
15013 }
15014
15015 static int
15016 scheduler_multicore_testsuite_setup(void)
15017 {
15018         if (test_scheduler_attach_worker_op() < 0)
15019                 return TEST_SKIPPED;
15020         if (test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) < 0)
15021                 return TEST_SKIPPED;
15022         return 0;
15023 }
15024
15025 static int
15026 scheduler_roundrobin_testsuite_setup(void)
15027 {
15028         if (test_scheduler_attach_worker_op() < 0)
15029                 return TEST_SKIPPED;
15030         if (test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) < 0)
15031                 return TEST_SKIPPED;
15032         return 0;
15033 }
15034
15035 static int
15036 scheduler_failover_testsuite_setup(void)
15037 {
15038         if (test_scheduler_attach_worker_op() < 0)
15039                 return TEST_SKIPPED;
15040         if (test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) < 0)
15041                 return TEST_SKIPPED;
15042         return 0;
15043 }
15044
15045 static int
15046 scheduler_pkt_size_distr_testsuite_setup(void)
15047 {
15048         if (test_scheduler_attach_worker_op() < 0)
15049                 return TEST_SKIPPED;
15050         if (test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) < 0)
15051                 return TEST_SKIPPED;
15052         return 0;
15053 }
15054
15055 static void
15056 scheduler_mode_testsuite_teardown(void)
15057 {
15058         test_scheduler_detach_worker_op();
15059 }
15060
15061 #endif /* RTE_CRYPTO_SCHEDULER */
15062
15063 static struct unit_test_suite end_testsuite = {
15064         .suite_name = NULL,
15065         .setup = NULL,
15066         .teardown = NULL,
15067         .unit_test_suites = NULL
15068 };
15069
15070 #ifdef RTE_LIB_SECURITY
15071 static struct unit_test_suite ipsec_proto_testsuite  = {
15072         .suite_name = "IPsec Proto Unit Test Suite",
15073         .setup = ipsec_proto_testsuite_setup,
15074         .unit_test_cases = {
15075                 TEST_CASE_NAMED_WITH_DATA(
15076                         "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 128)",
15077                         ut_setup_security, ut_teardown,
15078                         test_ipsec_proto_known_vec, &pkt_aes_128_gcm),
15079                 TEST_CASE_NAMED_WITH_DATA(
15080                         "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 192)",
15081                         ut_setup_security, ut_teardown,
15082                         test_ipsec_proto_known_vec, &pkt_aes_192_gcm),
15083                 TEST_CASE_NAMED_WITH_DATA(
15084                         "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 256)",
15085                         ut_setup_security, ut_teardown,
15086                         test_ipsec_proto_known_vec, &pkt_aes_256_gcm),
15087                 TEST_CASE_NAMED_WITH_DATA(
15088                         "Outbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA256 [16B ICV])",
15089                         ut_setup_security, ut_teardown,
15090                         test_ipsec_proto_known_vec,
15091                         &pkt_aes_128_cbc_hmac_sha256),
15092                 TEST_CASE_NAMED_WITH_DATA(
15093                         "Outbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA384 [24B ICV])",
15094                         ut_setup_security, ut_teardown,
15095                         test_ipsec_proto_known_vec,
15096                         &pkt_aes_128_cbc_hmac_sha384),
15097                 TEST_CASE_NAMED_WITH_DATA(
15098                         "Outbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA512 [32B ICV])",
15099                         ut_setup_security, ut_teardown,
15100                         test_ipsec_proto_known_vec,
15101                         &pkt_aes_128_cbc_hmac_sha512),
15102                 TEST_CASE_NAMED_WITH_DATA(
15103                         "Outbound known vector (ESP tunnel mode IPv6 AES-GCM 128)",
15104                         ut_setup_security, ut_teardown,
15105                         test_ipsec_proto_known_vec, &pkt_aes_256_gcm_v6),
15106                 TEST_CASE_NAMED_WITH_DATA(
15107                         "Outbound known vector (ESP tunnel mode IPv6 AES-CBC 128 HMAC-SHA256 [16B ICV])",
15108                         ut_setup_security, ut_teardown,
15109                         test_ipsec_proto_known_vec,
15110                         &pkt_aes_128_cbc_hmac_sha256_v6),
15111                 TEST_CASE_NAMED_WITH_DATA(
15112                         "Outbound known vector (ESP tunnel mode IPv4 NULL AES-XCBC-MAC [12B ICV])",
15113                         ut_setup_security, ut_teardown,
15114                         test_ipsec_proto_known_vec,
15115                         &pkt_null_aes_xcbc),
15116                 TEST_CASE_NAMED_WITH_DATA(
15117                         "Outbound known vector (AH tunnel mode IPv4 HMAC-SHA256)",
15118                         ut_setup_security, ut_teardown,
15119                         test_ipsec_proto_known_vec,
15120                         &pkt_ah_tunnel_sha256),
15121                 TEST_CASE_NAMED_WITH_DATA(
15122                         "Outbound known vector (AH transport mode IPv4 HMAC-SHA256)",
15123                         ut_setup_security, ut_teardown,
15124                         test_ipsec_proto_known_vec,
15125                         &pkt_ah_transport_sha256),
15126                 TEST_CASE_NAMED_WITH_DATA(
15127                         "Outbound known vector (AH transport mode IPv4 AES-GMAC 128)",
15128                         ut_setup_security, ut_teardown,
15129                         test_ipsec_proto_known_vec,
15130                         &pkt_ah_ipv4_aes_gmac_128),
15131                 TEST_CASE_NAMED_WITH_DATA(
15132                         "Outbound fragmented packet",
15133                         ut_setup_security, ut_teardown,
15134                         test_ipsec_proto_known_vec_fragmented,
15135                         &pkt_aes_128_gcm_frag),
15136                 TEST_CASE_NAMED_WITH_DATA(
15137                         "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 128)",
15138                         ut_setup_security, ut_teardown,
15139                         test_ipsec_proto_known_vec_inb, &pkt_aes_128_gcm),
15140                 TEST_CASE_NAMED_WITH_DATA(
15141                         "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 192)",
15142                         ut_setup_security, ut_teardown,
15143                         test_ipsec_proto_known_vec_inb, &pkt_aes_192_gcm),
15144                 TEST_CASE_NAMED_WITH_DATA(
15145                         "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 256)",
15146                         ut_setup_security, ut_teardown,
15147                         test_ipsec_proto_known_vec_inb, &pkt_aes_256_gcm),
15148                 TEST_CASE_NAMED_WITH_DATA(
15149                         "Inbound known vector (ESP tunnel mode IPv4 AES-CBC 128)",
15150                         ut_setup_security, ut_teardown,
15151                         test_ipsec_proto_known_vec_inb, &pkt_aes_128_cbc_null),
15152                 TEST_CASE_NAMED_WITH_DATA(
15153                         "Inbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA256 [16B ICV])",
15154                         ut_setup_security, ut_teardown,
15155                         test_ipsec_proto_known_vec_inb,
15156                         &pkt_aes_128_cbc_hmac_sha256),
15157                 TEST_CASE_NAMED_WITH_DATA(
15158                         "Inbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA384 [24B ICV])",
15159                         ut_setup_security, ut_teardown,
15160                         test_ipsec_proto_known_vec_inb,
15161                         &pkt_aes_128_cbc_hmac_sha384),
15162                 TEST_CASE_NAMED_WITH_DATA(
15163                         "Inbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA512 [32B ICV])",
15164                         ut_setup_security, ut_teardown,
15165                         test_ipsec_proto_known_vec_inb,
15166                         &pkt_aes_128_cbc_hmac_sha512),
15167                 TEST_CASE_NAMED_WITH_DATA(
15168                         "Inbound known vector (ESP tunnel mode IPv6 AES-GCM 128)",
15169                         ut_setup_security, ut_teardown,
15170                         test_ipsec_proto_known_vec_inb, &pkt_aes_256_gcm_v6),
15171                 TEST_CASE_NAMED_WITH_DATA(
15172                         "Inbound known vector (ESP tunnel mode IPv6 AES-CBC 128 HMAC-SHA256 [16B ICV])",
15173                         ut_setup_security, ut_teardown,
15174                         test_ipsec_proto_known_vec_inb,
15175                         &pkt_aes_128_cbc_hmac_sha256_v6),
15176                 TEST_CASE_NAMED_WITH_DATA(
15177                         "Inbound known vector (ESP tunnel mode IPv4 NULL AES-XCBC-MAC [12B ICV])",
15178                         ut_setup_security, ut_teardown,
15179                         test_ipsec_proto_known_vec_inb,
15180                         &pkt_null_aes_xcbc),
15181                 TEST_CASE_NAMED_WITH_DATA(
15182                         "Inbound known vector (AH tunnel mode IPv4 HMAC-SHA256)",
15183                         ut_setup_security, ut_teardown,
15184                         test_ipsec_proto_known_vec_inb,
15185                         &pkt_ah_tunnel_sha256),
15186                 TEST_CASE_NAMED_WITH_DATA(
15187                         "Inbound known vector (AH transport mode IPv4 HMAC-SHA256)",
15188                         ut_setup_security, ut_teardown,
15189                         test_ipsec_proto_known_vec_inb,
15190                         &pkt_ah_transport_sha256),
15191                 TEST_CASE_NAMED_WITH_DATA(
15192                         "Inbound known vector (AH transport mode IPv4 AES-GMAC 128)",
15193                         ut_setup_security, ut_teardown,
15194                         test_ipsec_proto_known_vec_inb,
15195                         &pkt_ah_ipv4_aes_gmac_128),
15196                 TEST_CASE_NAMED_ST(
15197                         "Combined test alg list",
15198                         ut_setup_security, ut_teardown,
15199                         test_ipsec_proto_display_list),
15200                 TEST_CASE_NAMED_ST(
15201                         "Combined test alg list (AH)",
15202                         ut_setup_security, ut_teardown,
15203                         test_ipsec_proto_ah_tunnel_ipv4),
15204                 TEST_CASE_NAMED_ST(
15205                         "IV generation",
15206                         ut_setup_security, ut_teardown,
15207                         test_ipsec_proto_iv_gen),
15208                 TEST_CASE_NAMED_ST(
15209                         "UDP encapsulation",
15210                         ut_setup_security, ut_teardown,
15211                         test_ipsec_proto_udp_encap),
15212                 TEST_CASE_NAMED_ST(
15213                         "UDP encapsulation ports verification test",
15214                         ut_setup_security, ut_teardown,
15215                         test_ipsec_proto_udp_ports_verify),
15216                 TEST_CASE_NAMED_ST(
15217                         "SA expiry packets soft",
15218                         ut_setup_security, ut_teardown,
15219                         test_ipsec_proto_sa_exp_pkts_soft),
15220                 TEST_CASE_NAMED_ST(
15221                         "SA expiry packets hard",
15222                         ut_setup_security, ut_teardown,
15223                         test_ipsec_proto_sa_exp_pkts_hard),
15224                 TEST_CASE_NAMED_ST(
15225                         "Negative test: ICV corruption",
15226                         ut_setup_security, ut_teardown,
15227                         test_ipsec_proto_err_icv_corrupt),
15228                 TEST_CASE_NAMED_ST(
15229                         "Tunnel dst addr verification",
15230                         ut_setup_security, ut_teardown,
15231                         test_ipsec_proto_tunnel_dst_addr_verify),
15232                 TEST_CASE_NAMED_ST(
15233                         "Tunnel src and dst addr verification",
15234                         ut_setup_security, ut_teardown,
15235                         test_ipsec_proto_tunnel_src_dst_addr_verify),
15236                 TEST_CASE_NAMED_ST(
15237                         "Inner IP checksum",
15238                         ut_setup_security, ut_teardown,
15239                         test_ipsec_proto_inner_ip_csum),
15240                 TEST_CASE_NAMED_ST(
15241                         "Inner L4 checksum",
15242                         ut_setup_security, ut_teardown,
15243                         test_ipsec_proto_inner_l4_csum),
15244                 TEST_CASE_NAMED_ST(
15245                         "Tunnel IPv4 in IPv4",
15246                         ut_setup_security, ut_teardown,
15247                         test_ipsec_proto_tunnel_v4_in_v4),
15248                 TEST_CASE_NAMED_ST(
15249                         "Tunnel IPv6 in IPv6",
15250                         ut_setup_security, ut_teardown,
15251                         test_ipsec_proto_tunnel_v6_in_v6),
15252                 TEST_CASE_NAMED_ST(
15253                         "Tunnel IPv4 in IPv6",
15254                         ut_setup_security, ut_teardown,
15255                         test_ipsec_proto_tunnel_v4_in_v6),
15256                 TEST_CASE_NAMED_ST(
15257                         "Tunnel IPv6 in IPv4",
15258                         ut_setup_security, ut_teardown,
15259                         test_ipsec_proto_tunnel_v6_in_v4),
15260                 TEST_CASE_NAMED_ST(
15261                         "Transport IPv4",
15262                         ut_setup_security, ut_teardown,
15263                         test_ipsec_proto_transport_v4),
15264                 TEST_CASE_NAMED_ST(
15265                         "AH transport IPv4",
15266                         ut_setup_security, ut_teardown,
15267                         test_ipsec_proto_ah_transport_ipv4),
15268                 TEST_CASE_NAMED_ST(
15269                         "Transport l4 checksum",
15270                         ut_setup_security, ut_teardown,
15271                         test_ipsec_proto_transport_l4_csum),
15272                 TEST_CASE_NAMED_ST(
15273                         "Statistics: success",
15274                         ut_setup_security, ut_teardown,
15275                         test_ipsec_proto_stats),
15276                 TEST_CASE_NAMED_ST(
15277                         "Fragmented packet",
15278                         ut_setup_security, ut_teardown,
15279                         test_ipsec_proto_pkt_fragment),
15280                 TEST_CASE_NAMED_ST(
15281                         "Tunnel header copy DF (inner 0)",
15282                         ut_setup_security, ut_teardown,
15283                         test_ipsec_proto_copy_df_inner_0),
15284                 TEST_CASE_NAMED_ST(
15285                         "Tunnel header copy DF (inner 1)",
15286                         ut_setup_security, ut_teardown,
15287                         test_ipsec_proto_copy_df_inner_1),
15288                 TEST_CASE_NAMED_ST(
15289                         "Tunnel header set DF 0 (inner 1)",
15290                         ut_setup_security, ut_teardown,
15291                         test_ipsec_proto_set_df_0_inner_1),
15292                 TEST_CASE_NAMED_ST(
15293                         "Tunnel header set DF 1 (inner 0)",
15294                         ut_setup_security, ut_teardown,
15295                         test_ipsec_proto_set_df_1_inner_0),
15296                 TEST_CASE_NAMED_ST(
15297                         "Tunnel header IPv4 copy DSCP (inner 0)",
15298                         ut_setup_security, ut_teardown,
15299                         test_ipsec_proto_ipv4_copy_dscp_inner_0),
15300                 TEST_CASE_NAMED_ST(
15301                         "Tunnel header IPv4 copy DSCP (inner 1)",
15302                         ut_setup_security, ut_teardown,
15303                         test_ipsec_proto_ipv4_copy_dscp_inner_1),
15304                 TEST_CASE_NAMED_ST(
15305                         "Tunnel header IPv4 set DSCP 0 (inner 1)",
15306                         ut_setup_security, ut_teardown,
15307                         test_ipsec_proto_ipv4_set_dscp_0_inner_1),
15308                 TEST_CASE_NAMED_ST(
15309                         "Tunnel header IPv4 set DSCP 1 (inner 0)",
15310                         ut_setup_security, ut_teardown,
15311                         test_ipsec_proto_ipv4_set_dscp_1_inner_0),
15312                 TEST_CASE_NAMED_ST(
15313                         "Tunnel header IPv6 copy DSCP (inner 0)",
15314                         ut_setup_security, ut_teardown,
15315                         test_ipsec_proto_ipv6_copy_dscp_inner_0),
15316                 TEST_CASE_NAMED_ST(
15317                         "Tunnel header IPv6 copy DSCP (inner 1)",
15318                         ut_setup_security, ut_teardown,
15319                         test_ipsec_proto_ipv6_copy_dscp_inner_1),
15320                 TEST_CASE_NAMED_ST(
15321                         "Tunnel header IPv6 set DSCP 0 (inner 1)",
15322                         ut_setup_security, ut_teardown,
15323                         test_ipsec_proto_ipv6_set_dscp_0_inner_1),
15324                 TEST_CASE_NAMED_ST(
15325                         "Tunnel header IPv6 set DSCP 1 (inner 0)",
15326                         ut_setup_security, ut_teardown,
15327                         test_ipsec_proto_ipv6_set_dscp_1_inner_0),
15328                 TEST_CASE_NAMED_WITH_DATA(
15329                         "Antireplay with window size 1024",
15330                         ut_setup_security, ut_teardown,
15331                         test_ipsec_proto_pkt_antireplay1024, &pkt_aes_128_gcm),
15332                 TEST_CASE_NAMED_WITH_DATA(
15333                         "Antireplay with window size 2048",
15334                         ut_setup_security, ut_teardown,
15335                         test_ipsec_proto_pkt_antireplay2048, &pkt_aes_128_gcm),
15336                 TEST_CASE_NAMED_WITH_DATA(
15337                         "Antireplay with window size 4096",
15338                         ut_setup_security, ut_teardown,
15339                         test_ipsec_proto_pkt_antireplay4096, &pkt_aes_128_gcm),
15340                 TEST_CASE_NAMED_WITH_DATA(
15341                         "ESN and Antireplay with window size 1024",
15342                         ut_setup_security, ut_teardown,
15343                         test_ipsec_proto_pkt_esn_antireplay1024,
15344                         &pkt_aes_128_gcm),
15345                 TEST_CASE_NAMED_WITH_DATA(
15346                         "ESN and Antireplay with window size 2048",
15347                         ut_setup_security, ut_teardown,
15348                         test_ipsec_proto_pkt_esn_antireplay2048,
15349                         &pkt_aes_128_gcm),
15350                 TEST_CASE_NAMED_WITH_DATA(
15351                         "ESN and Antireplay with window size 4096",
15352                         ut_setup_security, ut_teardown,
15353                         test_ipsec_proto_pkt_esn_antireplay4096,
15354                         &pkt_aes_128_gcm),
15355                 TEST_CASE_NAMED_ST(
15356                         "Tunnel header IPv4 decrement inner TTL",
15357                         ut_setup_security, ut_teardown,
15358                         test_ipsec_proto_ipv4_ttl_decrement),
15359                 TEST_CASE_NAMED_ST(
15360                         "Tunnel header IPv6 decrement inner hop limit",
15361                         ut_setup_security, ut_teardown,
15362                         test_ipsec_proto_ipv6_hop_limit_decrement),
15363                 TEST_CASES_END() /**< NULL terminate unit test array */
15364         }
15365 };
15366
15367 static struct unit_test_suite pdcp_proto_testsuite  = {
15368         .suite_name = "PDCP Proto Unit Test Suite",
15369         .setup = pdcp_proto_testsuite_setup,
15370         .unit_test_cases = {
15371                 TEST_CASE_ST(ut_setup_security, ut_teardown,
15372                         test_PDCP_PROTO_all),
15373                 TEST_CASES_END() /**< NULL terminate unit test array */
15374         }
15375 };
15376
15377 #define ADD_UPLINK_TESTCASE(data)                                               \
15378         TEST_CASE_NAMED_WITH_DATA(data.test_descr_uplink, ut_setup_security,    \
15379         ut_teardown, test_docsis_proto_uplink, (const void *) &data),           \
15380
15381 #define ADD_DOWNLINK_TESTCASE(data)                                             \
15382         TEST_CASE_NAMED_WITH_DATA(data.test_descr_downlink, ut_setup_security,  \
15383         ut_teardown, test_docsis_proto_downlink, (const void *) &data),         \
15384
15385 static struct unit_test_suite docsis_proto_testsuite  = {
15386         .suite_name = "DOCSIS Proto Unit Test Suite",
15387         .setup = docsis_proto_testsuite_setup,
15388         .unit_test_cases = {
15389                 /* Uplink */
15390                 ADD_UPLINK_TESTCASE(docsis_test_case_1)
15391                 ADD_UPLINK_TESTCASE(docsis_test_case_2)
15392                 ADD_UPLINK_TESTCASE(docsis_test_case_3)
15393                 ADD_UPLINK_TESTCASE(docsis_test_case_4)
15394                 ADD_UPLINK_TESTCASE(docsis_test_case_5)
15395                 ADD_UPLINK_TESTCASE(docsis_test_case_6)
15396                 ADD_UPLINK_TESTCASE(docsis_test_case_7)
15397                 ADD_UPLINK_TESTCASE(docsis_test_case_8)
15398                 ADD_UPLINK_TESTCASE(docsis_test_case_9)
15399                 ADD_UPLINK_TESTCASE(docsis_test_case_10)
15400                 ADD_UPLINK_TESTCASE(docsis_test_case_11)
15401                 ADD_UPLINK_TESTCASE(docsis_test_case_12)
15402                 ADD_UPLINK_TESTCASE(docsis_test_case_13)
15403                 ADD_UPLINK_TESTCASE(docsis_test_case_14)
15404                 ADD_UPLINK_TESTCASE(docsis_test_case_15)
15405                 ADD_UPLINK_TESTCASE(docsis_test_case_16)
15406                 ADD_UPLINK_TESTCASE(docsis_test_case_17)
15407                 ADD_UPLINK_TESTCASE(docsis_test_case_18)
15408                 ADD_UPLINK_TESTCASE(docsis_test_case_19)
15409                 ADD_UPLINK_TESTCASE(docsis_test_case_20)
15410                 ADD_UPLINK_TESTCASE(docsis_test_case_21)
15411                 ADD_UPLINK_TESTCASE(docsis_test_case_22)
15412                 ADD_UPLINK_TESTCASE(docsis_test_case_23)
15413                 ADD_UPLINK_TESTCASE(docsis_test_case_24)
15414                 ADD_UPLINK_TESTCASE(docsis_test_case_25)
15415                 ADD_UPLINK_TESTCASE(docsis_test_case_26)
15416                 /* Downlink */
15417                 ADD_DOWNLINK_TESTCASE(docsis_test_case_1)
15418                 ADD_DOWNLINK_TESTCASE(docsis_test_case_2)
15419                 ADD_DOWNLINK_TESTCASE(docsis_test_case_3)
15420                 ADD_DOWNLINK_TESTCASE(docsis_test_case_4)
15421                 ADD_DOWNLINK_TESTCASE(docsis_test_case_5)
15422                 ADD_DOWNLINK_TESTCASE(docsis_test_case_6)
15423                 ADD_DOWNLINK_TESTCASE(docsis_test_case_7)
15424                 ADD_DOWNLINK_TESTCASE(docsis_test_case_8)
15425                 ADD_DOWNLINK_TESTCASE(docsis_test_case_9)
15426                 ADD_DOWNLINK_TESTCASE(docsis_test_case_10)
15427                 ADD_DOWNLINK_TESTCASE(docsis_test_case_11)
15428                 ADD_DOWNLINK_TESTCASE(docsis_test_case_12)
15429                 ADD_DOWNLINK_TESTCASE(docsis_test_case_13)
15430                 ADD_DOWNLINK_TESTCASE(docsis_test_case_14)
15431                 ADD_DOWNLINK_TESTCASE(docsis_test_case_15)
15432                 ADD_DOWNLINK_TESTCASE(docsis_test_case_16)
15433                 ADD_DOWNLINK_TESTCASE(docsis_test_case_17)
15434                 ADD_DOWNLINK_TESTCASE(docsis_test_case_18)
15435                 ADD_DOWNLINK_TESTCASE(docsis_test_case_19)
15436                 ADD_DOWNLINK_TESTCASE(docsis_test_case_20)
15437                 ADD_DOWNLINK_TESTCASE(docsis_test_case_21)
15438                 ADD_DOWNLINK_TESTCASE(docsis_test_case_22)
15439                 ADD_DOWNLINK_TESTCASE(docsis_test_case_23)
15440                 ADD_DOWNLINK_TESTCASE(docsis_test_case_24)
15441                 ADD_DOWNLINK_TESTCASE(docsis_test_case_25)
15442                 ADD_DOWNLINK_TESTCASE(docsis_test_case_26)
15443                 TEST_CASES_END() /**< NULL terminate unit test array */
15444         }
15445 };
15446 #endif
15447
15448 static struct unit_test_suite cryptodev_gen_testsuite  = {
15449         .suite_name = "Crypto General Unit Test Suite",
15450         .setup = crypto_gen_testsuite_setup,
15451         .unit_test_cases = {
15452                 TEST_CASE_ST(ut_setup, ut_teardown,
15453                                 test_device_configure_invalid_dev_id),
15454                 TEST_CASE_ST(ut_setup, ut_teardown,
15455                                 test_queue_pair_descriptor_setup),
15456                 TEST_CASE_ST(ut_setup, ut_teardown,
15457                                 test_device_configure_invalid_queue_pair_ids),
15458                 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
15459                 TEST_CASE_ST(ut_setup, ut_teardown, test_enq_callback_setup),
15460                 TEST_CASE_ST(ut_setup, ut_teardown, test_deq_callback_setup),
15461                 TEST_CASES_END() /**< NULL terminate unit test array */
15462         }
15463 };
15464
15465 static struct unit_test_suite cryptodev_negative_hmac_sha1_testsuite = {
15466         .suite_name = "Negative HMAC SHA1 Unit Test Suite",
15467         .setup = negative_hmac_sha1_testsuite_setup,
15468         .unit_test_cases = {
15469                 /** Negative tests */
15470                 TEST_CASE_ST(ut_setup, ut_teardown,
15471                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
15472                 TEST_CASE_ST(ut_setup, ut_teardown,
15473                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
15474                 TEST_CASE_ST(ut_setup, ut_teardown,
15475                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
15476                 TEST_CASE_ST(ut_setup, ut_teardown,
15477                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
15478
15479                 TEST_CASES_END() /**< NULL terminate unit test array */
15480         }
15481 };
15482
15483 static struct unit_test_suite cryptodev_multi_session_testsuite = {
15484         .suite_name = "Multi Session Unit Test Suite",
15485         .setup = multi_session_testsuite_setup,
15486         .unit_test_cases = {
15487                 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
15488                 TEST_CASE_ST(ut_setup, ut_teardown,
15489                                 test_multi_session_random_usage),
15490
15491                 TEST_CASES_END() /**< NULL terminate unit test array */
15492         }
15493 };
15494
15495 static struct unit_test_suite cryptodev_null_testsuite  = {
15496         .suite_name = "NULL Test Suite",
15497         .setup = null_testsuite_setup,
15498         .unit_test_cases = {
15499                 TEST_CASE_ST(ut_setup, ut_teardown,
15500                         test_null_invalid_operation),
15501                 TEST_CASE_ST(ut_setup, ut_teardown, test_null_burst_operation),
15502                 TEST_CASES_END()
15503         }
15504 };
15505
15506 static struct unit_test_suite cryptodev_aes_ccm_auth_testsuite  = {
15507         .suite_name = "AES CCM Authenticated Test Suite",
15508         .setup = aes_ccm_auth_testsuite_setup,
15509         .unit_test_cases = {
15510                 /** AES CCM Authenticated Encryption 128 bits key*/
15511                 TEST_CASE_ST(ut_setup, ut_teardown,
15512                         test_AES_CCM_authenticated_encryption_test_case_128_1),
15513                 TEST_CASE_ST(ut_setup, ut_teardown,
15514                         test_AES_CCM_authenticated_encryption_test_case_128_2),
15515                 TEST_CASE_ST(ut_setup, ut_teardown,
15516                         test_AES_CCM_authenticated_encryption_test_case_128_3),
15517
15518                 /** AES CCM Authenticated Decryption 128 bits key*/
15519                 TEST_CASE_ST(ut_setup, ut_teardown,
15520                         test_AES_CCM_authenticated_decryption_test_case_128_1),
15521                 TEST_CASE_ST(ut_setup, ut_teardown,
15522                         test_AES_CCM_authenticated_decryption_test_case_128_2),
15523                 TEST_CASE_ST(ut_setup, ut_teardown,
15524                         test_AES_CCM_authenticated_decryption_test_case_128_3),
15525
15526                 /** AES CCM Authenticated Encryption 192 bits key */
15527                 TEST_CASE_ST(ut_setup, ut_teardown,
15528                         test_AES_CCM_authenticated_encryption_test_case_192_1),
15529                 TEST_CASE_ST(ut_setup, ut_teardown,
15530                         test_AES_CCM_authenticated_encryption_test_case_192_2),
15531                 TEST_CASE_ST(ut_setup, ut_teardown,
15532                         test_AES_CCM_authenticated_encryption_test_case_192_3),
15533
15534                 /** AES CCM Authenticated Decryption 192 bits key*/
15535                 TEST_CASE_ST(ut_setup, ut_teardown,
15536                         test_AES_CCM_authenticated_decryption_test_case_192_1),
15537                 TEST_CASE_ST(ut_setup, ut_teardown,
15538                         test_AES_CCM_authenticated_decryption_test_case_192_2),
15539                 TEST_CASE_ST(ut_setup, ut_teardown,
15540                         test_AES_CCM_authenticated_decryption_test_case_192_3),
15541
15542                 /** AES CCM Authenticated Encryption 256 bits key */
15543                 TEST_CASE_ST(ut_setup, ut_teardown,
15544                         test_AES_CCM_authenticated_encryption_test_case_256_1),
15545                 TEST_CASE_ST(ut_setup, ut_teardown,
15546                         test_AES_CCM_authenticated_encryption_test_case_256_2),
15547                 TEST_CASE_ST(ut_setup, ut_teardown,
15548                         test_AES_CCM_authenticated_encryption_test_case_256_3),
15549
15550                 /** AES CCM Authenticated Decryption 256 bits key*/
15551                 TEST_CASE_ST(ut_setup, ut_teardown,
15552                         test_AES_CCM_authenticated_decryption_test_case_256_1),
15553                 TEST_CASE_ST(ut_setup, ut_teardown,
15554                         test_AES_CCM_authenticated_decryption_test_case_256_2),
15555                 TEST_CASE_ST(ut_setup, ut_teardown,
15556                         test_AES_CCM_authenticated_decryption_test_case_256_3),
15557                 TEST_CASES_END()
15558         }
15559 };
15560
15561 static struct unit_test_suite cryptodev_aes_gcm_auth_testsuite  = {
15562         .suite_name = "AES GCM Authenticated Test Suite",
15563         .setup = aes_gcm_auth_testsuite_setup,
15564         .unit_test_cases = {
15565                 /** AES GCM Authenticated Encryption */
15566                 TEST_CASE_ST(ut_setup, ut_teardown,
15567                         test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
15568                 TEST_CASE_ST(ut_setup, ut_teardown,
15569                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
15570                 TEST_CASE_ST(ut_setup, ut_teardown,
15571                         test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
15572                 TEST_CASE_ST(ut_setup, ut_teardown,
15573                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
15574                 TEST_CASE_ST(ut_setup, ut_teardown,
15575                         test_AES_GCM_authenticated_encryption_test_case_1),
15576                 TEST_CASE_ST(ut_setup, ut_teardown,
15577                         test_AES_GCM_authenticated_encryption_test_case_2),
15578                 TEST_CASE_ST(ut_setup, ut_teardown,
15579                         test_AES_GCM_authenticated_encryption_test_case_3),
15580                 TEST_CASE_ST(ut_setup, ut_teardown,
15581                         test_AES_GCM_authenticated_encryption_test_case_4),
15582                 TEST_CASE_ST(ut_setup, ut_teardown,
15583                         test_AES_GCM_authenticated_encryption_test_case_5),
15584                 TEST_CASE_ST(ut_setup, ut_teardown,
15585                         test_AES_GCM_authenticated_encryption_test_case_6),
15586                 TEST_CASE_ST(ut_setup, ut_teardown,
15587                         test_AES_GCM_authenticated_encryption_test_case_7),
15588                 TEST_CASE_ST(ut_setup, ut_teardown,
15589                         test_AES_GCM_authenticated_encryption_test_case_8),
15590                 TEST_CASE_ST(ut_setup, ut_teardown,
15591                         test_AES_GCM_J0_authenticated_encryption_test_case_1),
15592
15593                 /** AES GCM Authenticated Decryption */
15594                 TEST_CASE_ST(ut_setup, ut_teardown,
15595                         test_AES_GCM_authenticated_decryption_test_case_1),
15596                 TEST_CASE_ST(ut_setup, ut_teardown,
15597                         test_AES_GCM_authenticated_decryption_test_case_2),
15598                 TEST_CASE_ST(ut_setup, ut_teardown,
15599                         test_AES_GCM_authenticated_decryption_test_case_3),
15600                 TEST_CASE_ST(ut_setup, ut_teardown,
15601                         test_AES_GCM_authenticated_decryption_test_case_4),
15602                 TEST_CASE_ST(ut_setup, ut_teardown,
15603                         test_AES_GCM_authenticated_decryption_test_case_5),
15604                 TEST_CASE_ST(ut_setup, ut_teardown,
15605                         test_AES_GCM_authenticated_decryption_test_case_6),
15606                 TEST_CASE_ST(ut_setup, ut_teardown,
15607                         test_AES_GCM_authenticated_decryption_test_case_7),
15608                 TEST_CASE_ST(ut_setup, ut_teardown,
15609                         test_AES_GCM_authenticated_decryption_test_case_8),
15610                 TEST_CASE_ST(ut_setup, ut_teardown,
15611                         test_AES_GCM_J0_authenticated_decryption_test_case_1),
15612
15613                 /** AES GCM Authenticated Encryption 192 bits key */
15614                 TEST_CASE_ST(ut_setup, ut_teardown,
15615                         test_AES_GCM_auth_encryption_test_case_192_1),
15616                 TEST_CASE_ST(ut_setup, ut_teardown,
15617                         test_AES_GCM_auth_encryption_test_case_192_2),
15618                 TEST_CASE_ST(ut_setup, ut_teardown,
15619                         test_AES_GCM_auth_encryption_test_case_192_3),
15620                 TEST_CASE_ST(ut_setup, ut_teardown,
15621                         test_AES_GCM_auth_encryption_test_case_192_4),
15622                 TEST_CASE_ST(ut_setup, ut_teardown,
15623                         test_AES_GCM_auth_encryption_test_case_192_5),
15624                 TEST_CASE_ST(ut_setup, ut_teardown,
15625                         test_AES_GCM_auth_encryption_test_case_192_6),
15626                 TEST_CASE_ST(ut_setup, ut_teardown,
15627                         test_AES_GCM_auth_encryption_test_case_192_7),
15628
15629                 /** AES GCM Authenticated Decryption 192 bits key */
15630                 TEST_CASE_ST(ut_setup, ut_teardown,
15631                         test_AES_GCM_auth_decryption_test_case_192_1),
15632                 TEST_CASE_ST(ut_setup, ut_teardown,
15633                         test_AES_GCM_auth_decryption_test_case_192_2),
15634                 TEST_CASE_ST(ut_setup, ut_teardown,
15635                         test_AES_GCM_auth_decryption_test_case_192_3),
15636                 TEST_CASE_ST(ut_setup, ut_teardown,
15637                         test_AES_GCM_auth_decryption_test_case_192_4),
15638                 TEST_CASE_ST(ut_setup, ut_teardown,
15639                         test_AES_GCM_auth_decryption_test_case_192_5),
15640                 TEST_CASE_ST(ut_setup, ut_teardown,
15641                         test_AES_GCM_auth_decryption_test_case_192_6),
15642                 TEST_CASE_ST(ut_setup, ut_teardown,
15643                         test_AES_GCM_auth_decryption_test_case_192_7),
15644
15645                 /** AES GCM Authenticated Encryption 256 bits key */
15646                 TEST_CASE_ST(ut_setup, ut_teardown,
15647                         test_AES_GCM_auth_encryption_test_case_256_1),
15648                 TEST_CASE_ST(ut_setup, ut_teardown,
15649                         test_AES_GCM_auth_encryption_test_case_256_2),
15650                 TEST_CASE_ST(ut_setup, ut_teardown,
15651                         test_AES_GCM_auth_encryption_test_case_256_3),
15652                 TEST_CASE_ST(ut_setup, ut_teardown,
15653                         test_AES_GCM_auth_encryption_test_case_256_4),
15654                 TEST_CASE_ST(ut_setup, ut_teardown,
15655                         test_AES_GCM_auth_encryption_test_case_256_5),
15656                 TEST_CASE_ST(ut_setup, ut_teardown,
15657                         test_AES_GCM_auth_encryption_test_case_256_6),
15658                 TEST_CASE_ST(ut_setup, ut_teardown,
15659                         test_AES_GCM_auth_encryption_test_case_256_7),
15660
15661                 /** AES GCM Authenticated Decryption 256 bits key */
15662                 TEST_CASE_ST(ut_setup, ut_teardown,
15663                         test_AES_GCM_auth_decryption_test_case_256_1),
15664                 TEST_CASE_ST(ut_setup, ut_teardown,
15665                         test_AES_GCM_auth_decryption_test_case_256_2),
15666                 TEST_CASE_ST(ut_setup, ut_teardown,
15667                         test_AES_GCM_auth_decryption_test_case_256_3),
15668                 TEST_CASE_ST(ut_setup, ut_teardown,
15669                         test_AES_GCM_auth_decryption_test_case_256_4),
15670                 TEST_CASE_ST(ut_setup, ut_teardown,
15671                         test_AES_GCM_auth_decryption_test_case_256_5),
15672                 TEST_CASE_ST(ut_setup, ut_teardown,
15673                         test_AES_GCM_auth_decryption_test_case_256_6),
15674                 TEST_CASE_ST(ut_setup, ut_teardown,
15675                         test_AES_GCM_auth_decryption_test_case_256_7),
15676
15677                 /** AES GCM Authenticated Encryption big aad size */
15678                 TEST_CASE_ST(ut_setup, ut_teardown,
15679                         test_AES_GCM_auth_encryption_test_case_aad_1),
15680                 TEST_CASE_ST(ut_setup, ut_teardown,
15681                         test_AES_GCM_auth_encryption_test_case_aad_2),
15682
15683                 /** AES GCM Authenticated Decryption big aad size */
15684                 TEST_CASE_ST(ut_setup, ut_teardown,
15685                         test_AES_GCM_auth_decryption_test_case_aad_1),
15686                 TEST_CASE_ST(ut_setup, ut_teardown,
15687                         test_AES_GCM_auth_decryption_test_case_aad_2),
15688
15689                 /** Out of place tests */
15690                 TEST_CASE_ST(ut_setup, ut_teardown,
15691                         test_AES_GCM_authenticated_encryption_oop_test_case_1),
15692                 TEST_CASE_ST(ut_setup, ut_teardown,
15693                         test_AES_GCM_authenticated_decryption_oop_test_case_1),
15694
15695                 /** Session-less tests */
15696                 TEST_CASE_ST(ut_setup, ut_teardown,
15697                         test_AES_GCM_authenticated_encryption_sessionless_test_case_1),
15698                 TEST_CASE_ST(ut_setup, ut_teardown,
15699                         test_AES_GCM_authenticated_decryption_sessionless_test_case_1),
15700
15701                 TEST_CASES_END()
15702         }
15703 };
15704
15705 static struct unit_test_suite cryptodev_aes_gmac_auth_testsuite  = {
15706         .suite_name = "AES GMAC Authentication Test Suite",
15707         .setup = aes_gmac_auth_testsuite_setup,
15708         .unit_test_cases = {
15709                 TEST_CASE_ST(ut_setup, ut_teardown,
15710                         test_AES_GMAC_authentication_test_case_1),
15711                 TEST_CASE_ST(ut_setup, ut_teardown,
15712                         test_AES_GMAC_authentication_verify_test_case_1),
15713                 TEST_CASE_ST(ut_setup, ut_teardown,
15714                         test_AES_GMAC_authentication_test_case_2),
15715                 TEST_CASE_ST(ut_setup, ut_teardown,
15716                         test_AES_GMAC_authentication_verify_test_case_2),
15717                 TEST_CASE_ST(ut_setup, ut_teardown,
15718                         test_AES_GMAC_authentication_test_case_3),
15719                 TEST_CASE_ST(ut_setup, ut_teardown,
15720                         test_AES_GMAC_authentication_verify_test_case_3),
15721                 TEST_CASE_ST(ut_setup, ut_teardown,
15722                         test_AES_GMAC_authentication_test_case_4),
15723                 TEST_CASE_ST(ut_setup, ut_teardown,
15724                         test_AES_GMAC_authentication_verify_test_case_4),
15725                 TEST_CASE_ST(ut_setup, ut_teardown,
15726                         test_AES_GMAC_authentication_SGL_40B),
15727                 TEST_CASE_ST(ut_setup, ut_teardown,
15728                         test_AES_GMAC_authentication_SGL_80B),
15729                 TEST_CASE_ST(ut_setup, ut_teardown,
15730                         test_AES_GMAC_authentication_SGL_2048B),
15731                 TEST_CASE_ST(ut_setup, ut_teardown,
15732                         test_AES_GMAC_authentication_SGL_2047B),
15733
15734                 TEST_CASES_END()
15735         }
15736 };
15737
15738 static struct unit_test_suite cryptodev_chacha20_poly1305_testsuite  = {
15739         .suite_name = "Chacha20-Poly1305 Test Suite",
15740         .setup = chacha20_poly1305_testsuite_setup,
15741         .unit_test_cases = {
15742                 TEST_CASE_ST(ut_setup, ut_teardown,
15743                         test_chacha20_poly1305_encrypt_test_case_rfc8439),
15744                 TEST_CASE_ST(ut_setup, ut_teardown,
15745                         test_chacha20_poly1305_decrypt_test_case_rfc8439),
15746                 TEST_CASE_ST(ut_setup, ut_teardown,
15747                         test_chacha20_poly1305_encrypt_SGL_out_of_place),
15748                 TEST_CASES_END()
15749         }
15750 };
15751
15752 static struct unit_test_suite cryptodev_snow3g_testsuite  = {
15753         .suite_name = "SNOW 3G Test Suite",
15754         .setup = snow3g_testsuite_setup,
15755         .unit_test_cases = {
15756                 /** SNOW 3G encrypt only (UEA2) */
15757                 TEST_CASE_ST(ut_setup, ut_teardown,
15758                         test_snow3g_encryption_test_case_1),
15759                 TEST_CASE_ST(ut_setup, ut_teardown,
15760                         test_snow3g_encryption_test_case_2),
15761                 TEST_CASE_ST(ut_setup, ut_teardown,
15762                         test_snow3g_encryption_test_case_3),
15763                 TEST_CASE_ST(ut_setup, ut_teardown,
15764                         test_snow3g_encryption_test_case_4),
15765                 TEST_CASE_ST(ut_setup, ut_teardown,
15766                         test_snow3g_encryption_test_case_5),
15767
15768                 TEST_CASE_ST(ut_setup, ut_teardown,
15769                         test_snow3g_encryption_test_case_1_oop),
15770                 TEST_CASE_ST(ut_setup, ut_teardown,
15771                         test_snow3g_encryption_test_case_1_oop_sgl),
15772                 TEST_CASE_ST(ut_setup, ut_teardown,
15773                         test_snow3g_encryption_test_case_1_offset_oop),
15774                 TEST_CASE_ST(ut_setup, ut_teardown,
15775                         test_snow3g_decryption_test_case_1_oop),
15776
15777                 /** SNOW 3G generate auth, then encrypt (UEA2) */
15778                 TEST_CASE_ST(ut_setup, ut_teardown,
15779                         test_snow3g_auth_cipher_test_case_1),
15780                 TEST_CASE_ST(ut_setup, ut_teardown,
15781                         test_snow3g_auth_cipher_test_case_2),
15782                 TEST_CASE_ST(ut_setup, ut_teardown,
15783                         test_snow3g_auth_cipher_test_case_2_oop),
15784                 TEST_CASE_ST(ut_setup, ut_teardown,
15785                         test_snow3g_auth_cipher_part_digest_enc),
15786                 TEST_CASE_ST(ut_setup, ut_teardown,
15787                         test_snow3g_auth_cipher_part_digest_enc_oop),
15788                 TEST_CASE_ST(ut_setup, ut_teardown,
15789                         test_snow3g_auth_cipher_test_case_3_sgl),
15790                 TEST_CASE_ST(ut_setup, ut_teardown,
15791                         test_snow3g_auth_cipher_test_case_3_oop_sgl),
15792                 TEST_CASE_ST(ut_setup, ut_teardown,
15793                         test_snow3g_auth_cipher_part_digest_enc_sgl),
15794                 TEST_CASE_ST(ut_setup, ut_teardown,
15795                         test_snow3g_auth_cipher_part_digest_enc_oop_sgl),
15796
15797                 /** SNOW 3G decrypt (UEA2), then verify auth */
15798                 TEST_CASE_ST(ut_setup, ut_teardown,
15799                         test_snow3g_auth_cipher_verify_test_case_1),
15800                 TEST_CASE_ST(ut_setup, ut_teardown,
15801                         test_snow3g_auth_cipher_verify_test_case_2),
15802                 TEST_CASE_ST(ut_setup, ut_teardown,
15803                         test_snow3g_auth_cipher_verify_test_case_2_oop),
15804                 TEST_CASE_ST(ut_setup, ut_teardown,
15805                         test_snow3g_auth_cipher_verify_part_digest_enc),
15806                 TEST_CASE_ST(ut_setup, ut_teardown,
15807                         test_snow3g_auth_cipher_verify_part_digest_enc_oop),
15808                 TEST_CASE_ST(ut_setup, ut_teardown,
15809                         test_snow3g_auth_cipher_verify_test_case_3_sgl),
15810                 TEST_CASE_ST(ut_setup, ut_teardown,
15811                         test_snow3g_auth_cipher_verify_test_case_3_oop_sgl),
15812                 TEST_CASE_ST(ut_setup, ut_teardown,
15813                         test_snow3g_auth_cipher_verify_part_digest_enc_sgl),
15814                 TEST_CASE_ST(ut_setup, ut_teardown,
15815                         test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl),
15816
15817                 /** SNOW 3G decrypt only (UEA2) */
15818                 TEST_CASE_ST(ut_setup, ut_teardown,
15819                         test_snow3g_decryption_test_case_1),
15820                 TEST_CASE_ST(ut_setup, ut_teardown,
15821                         test_snow3g_decryption_test_case_2),
15822                 TEST_CASE_ST(ut_setup, ut_teardown,
15823                         test_snow3g_decryption_test_case_3),
15824                 TEST_CASE_ST(ut_setup, ut_teardown,
15825                         test_snow3g_decryption_test_case_4),
15826                 TEST_CASE_ST(ut_setup, ut_teardown,
15827                         test_snow3g_decryption_test_case_5),
15828                 TEST_CASE_ST(ut_setup, ut_teardown,
15829                         test_snow3g_decryption_with_digest_test_case_1),
15830                 TEST_CASE_ST(ut_setup, ut_teardown,
15831                         test_snow3g_hash_generate_test_case_1),
15832                 TEST_CASE_ST(ut_setup, ut_teardown,
15833                         test_snow3g_hash_generate_test_case_2),
15834                 TEST_CASE_ST(ut_setup, ut_teardown,
15835                         test_snow3g_hash_generate_test_case_3),
15836
15837                 /* Tests with buffers which length is not byte-aligned */
15838                 TEST_CASE_ST(ut_setup, ut_teardown,
15839                         test_snow3g_hash_generate_test_case_4),
15840                 TEST_CASE_ST(ut_setup, ut_teardown,
15841                         test_snow3g_hash_generate_test_case_5),
15842                 TEST_CASE_ST(ut_setup, ut_teardown,
15843                         test_snow3g_hash_generate_test_case_6),
15844                 TEST_CASE_ST(ut_setup, ut_teardown,
15845                         test_snow3g_hash_verify_test_case_1),
15846                 TEST_CASE_ST(ut_setup, ut_teardown,
15847                         test_snow3g_hash_verify_test_case_2),
15848                 TEST_CASE_ST(ut_setup, ut_teardown,
15849                         test_snow3g_hash_verify_test_case_3),
15850
15851                 /* Tests with buffers which length is not byte-aligned */
15852                 TEST_CASE_ST(ut_setup, ut_teardown,
15853                         test_snow3g_hash_verify_test_case_4),
15854                 TEST_CASE_ST(ut_setup, ut_teardown,
15855                         test_snow3g_hash_verify_test_case_5),
15856                 TEST_CASE_ST(ut_setup, ut_teardown,
15857                         test_snow3g_hash_verify_test_case_6),
15858                 TEST_CASE_ST(ut_setup, ut_teardown,
15859                         test_snow3g_cipher_auth_test_case_1),
15860                 TEST_CASE_ST(ut_setup, ut_teardown,
15861                         test_snow3g_auth_cipher_with_digest_test_case_1),
15862                 TEST_CASES_END()
15863         }
15864 };
15865
15866 static struct unit_test_suite cryptodev_zuc_testsuite  = {
15867         .suite_name = "ZUC Test Suite",
15868         .setup = zuc_testsuite_setup,
15869         .unit_test_cases = {
15870                 /** ZUC encrypt only (EEA3) */
15871                 TEST_CASE_ST(ut_setup, ut_teardown,
15872                         test_zuc_encryption_test_case_1),
15873                 TEST_CASE_ST(ut_setup, ut_teardown,
15874                         test_zuc_encryption_test_case_2),
15875                 TEST_CASE_ST(ut_setup, ut_teardown,
15876                         test_zuc_encryption_test_case_3),
15877                 TEST_CASE_ST(ut_setup, ut_teardown,
15878                         test_zuc_encryption_test_case_4),
15879                 TEST_CASE_ST(ut_setup, ut_teardown,
15880                         test_zuc_encryption_test_case_5),
15881                 TEST_CASE_ST(ut_setup, ut_teardown,
15882                         test_zuc_encryption_test_case_6_sgl),
15883
15884                 /** ZUC authenticate (EIA3) */
15885                 TEST_CASE_ST(ut_setup, ut_teardown,
15886                         test_zuc_hash_generate_test_case_1),
15887                 TEST_CASE_ST(ut_setup, ut_teardown,
15888                         test_zuc_hash_generate_test_case_2),
15889                 TEST_CASE_ST(ut_setup, ut_teardown,
15890                         test_zuc_hash_generate_test_case_3),
15891                 TEST_CASE_ST(ut_setup, ut_teardown,
15892                         test_zuc_hash_generate_test_case_4),
15893                 TEST_CASE_ST(ut_setup, ut_teardown,
15894                         test_zuc_hash_generate_test_case_5),
15895                 TEST_CASE_ST(ut_setup, ut_teardown,
15896                         test_zuc_hash_generate_test_case_6),
15897                 TEST_CASE_ST(ut_setup, ut_teardown,
15898                         test_zuc_hash_generate_test_case_7),
15899                 TEST_CASE_ST(ut_setup, ut_teardown,
15900                         test_zuc_hash_generate_test_case_8),
15901                 TEST_CASE_ST(ut_setup, ut_teardown,
15902                         test_zuc_hash_generate_test_case_9),
15903                 TEST_CASE_ST(ut_setup, ut_teardown,
15904                         test_zuc_hash_generate_test_case_10),
15905                 TEST_CASE_ST(ut_setup, ut_teardown,
15906                         test_zuc_hash_generate_test_case_11),
15907
15908
15909                 /** ZUC alg-chain (EEA3/EIA3) */
15910                 TEST_CASE_ST(ut_setup, ut_teardown,
15911                         test_zuc_cipher_auth_test_case_1),
15912                 TEST_CASE_ST(ut_setup, ut_teardown,
15913                         test_zuc_cipher_auth_test_case_2),
15914
15915                 /** ZUC generate auth, then encrypt (EEA3) */
15916                 TEST_CASE_ST(ut_setup, ut_teardown,
15917                         test_zuc_auth_cipher_test_case_1),
15918                 TEST_CASE_ST(ut_setup, ut_teardown,
15919                         test_zuc_auth_cipher_test_case_1_oop),
15920                 TEST_CASE_ST(ut_setup, ut_teardown,
15921                         test_zuc_auth_cipher_test_case_1_sgl),
15922                 TEST_CASE_ST(ut_setup, ut_teardown,
15923                         test_zuc_auth_cipher_test_case_1_oop_sgl),
15924
15925                 /** ZUC decrypt (EEA3), then verify auth */
15926                 TEST_CASE_ST(ut_setup, ut_teardown,
15927                         test_zuc_auth_cipher_verify_test_case_1),
15928                 TEST_CASE_ST(ut_setup, ut_teardown,
15929                         test_zuc_auth_cipher_verify_test_case_1_oop),
15930                 TEST_CASE_ST(ut_setup, ut_teardown,
15931                         test_zuc_auth_cipher_verify_test_case_1_sgl),
15932                 TEST_CASE_ST(ut_setup, ut_teardown,
15933                         test_zuc_auth_cipher_verify_test_case_1_oop_sgl),
15934
15935                 /** ZUC-256 encrypt only **/
15936                 TEST_CASE_ST(ut_setup, ut_teardown,
15937                         test_zuc256_encryption_test_case_1),
15938                 TEST_CASE_ST(ut_setup, ut_teardown,
15939                         test_zuc256_encryption_test_case_2),
15940
15941                 /** ZUC-256 authentication only **/
15942                 TEST_CASE_ST(ut_setup, ut_teardown,
15943                         test_zuc256_authentication_test_case_1),
15944                 TEST_CASE_ST(ut_setup, ut_teardown,
15945                         test_zuc256_authentication_test_case_2),
15946
15947                 TEST_CASES_END()
15948         }
15949 };
15950
15951 static struct unit_test_suite cryptodev_hmac_md5_auth_testsuite  = {
15952         .suite_name = "HMAC_MD5 Authentication Test Suite",
15953         .setup = hmac_md5_auth_testsuite_setup,
15954         .unit_test_cases = {
15955                 TEST_CASE_ST(ut_setup, ut_teardown,
15956                         test_MD5_HMAC_generate_case_1),
15957                 TEST_CASE_ST(ut_setup, ut_teardown,
15958                         test_MD5_HMAC_verify_case_1),
15959                 TEST_CASE_ST(ut_setup, ut_teardown,
15960                         test_MD5_HMAC_generate_case_2),
15961                 TEST_CASE_ST(ut_setup, ut_teardown,
15962                         test_MD5_HMAC_verify_case_2),
15963                 TEST_CASES_END()
15964         }
15965 };
15966
15967 static struct unit_test_suite cryptodev_kasumi_testsuite  = {
15968         .suite_name = "Kasumi Test Suite",
15969         .setup = kasumi_testsuite_setup,
15970         .unit_test_cases = {
15971                 /** KASUMI hash only (UIA1) */
15972                 TEST_CASE_ST(ut_setup, ut_teardown,
15973                         test_kasumi_hash_generate_test_case_1),
15974                 TEST_CASE_ST(ut_setup, ut_teardown,
15975                         test_kasumi_hash_generate_test_case_2),
15976                 TEST_CASE_ST(ut_setup, ut_teardown,
15977                         test_kasumi_hash_generate_test_case_3),
15978                 TEST_CASE_ST(ut_setup, ut_teardown,
15979                         test_kasumi_hash_generate_test_case_4),
15980                 TEST_CASE_ST(ut_setup, ut_teardown,
15981                         test_kasumi_hash_generate_test_case_5),
15982                 TEST_CASE_ST(ut_setup, ut_teardown,
15983                         test_kasumi_hash_generate_test_case_6),
15984
15985                 TEST_CASE_ST(ut_setup, ut_teardown,
15986                         test_kasumi_hash_verify_test_case_1),
15987                 TEST_CASE_ST(ut_setup, ut_teardown,
15988                         test_kasumi_hash_verify_test_case_2),
15989                 TEST_CASE_ST(ut_setup, ut_teardown,
15990                         test_kasumi_hash_verify_test_case_3),
15991                 TEST_CASE_ST(ut_setup, ut_teardown,
15992                         test_kasumi_hash_verify_test_case_4),
15993                 TEST_CASE_ST(ut_setup, ut_teardown,
15994                         test_kasumi_hash_verify_test_case_5),
15995
15996                 /** KASUMI encrypt only (UEA1) */
15997                 TEST_CASE_ST(ut_setup, ut_teardown,
15998                         test_kasumi_encryption_test_case_1),
15999                 TEST_CASE_ST(ut_setup, ut_teardown,
16000                         test_kasumi_encryption_test_case_1_sgl),
16001                 TEST_CASE_ST(ut_setup, ut_teardown,
16002                         test_kasumi_encryption_test_case_1_oop),
16003                 TEST_CASE_ST(ut_setup, ut_teardown,
16004                         test_kasumi_encryption_test_case_1_oop_sgl),
16005                 TEST_CASE_ST(ut_setup, ut_teardown,
16006                         test_kasumi_encryption_test_case_2),
16007                 TEST_CASE_ST(ut_setup, ut_teardown,
16008                         test_kasumi_encryption_test_case_3),
16009                 TEST_CASE_ST(ut_setup, ut_teardown,
16010                         test_kasumi_encryption_test_case_4),
16011                 TEST_CASE_ST(ut_setup, ut_teardown,
16012                         test_kasumi_encryption_test_case_5),
16013
16014                 /** KASUMI decrypt only (UEA1) */
16015                 TEST_CASE_ST(ut_setup, ut_teardown,
16016                         test_kasumi_decryption_test_case_1),
16017                 TEST_CASE_ST(ut_setup, ut_teardown,
16018                         test_kasumi_decryption_test_case_2),
16019                 TEST_CASE_ST(ut_setup, ut_teardown,
16020                         test_kasumi_decryption_test_case_3),
16021                 TEST_CASE_ST(ut_setup, ut_teardown,
16022                         test_kasumi_decryption_test_case_4),
16023                 TEST_CASE_ST(ut_setup, ut_teardown,
16024                         test_kasumi_decryption_test_case_5),
16025                 TEST_CASE_ST(ut_setup, ut_teardown,
16026                         test_kasumi_decryption_test_case_1_oop),
16027                 TEST_CASE_ST(ut_setup, ut_teardown,
16028                         test_kasumi_cipher_auth_test_case_1),
16029
16030                 /** KASUMI generate auth, then encrypt (F8) */
16031                 TEST_CASE_ST(ut_setup, ut_teardown,
16032                         test_kasumi_auth_cipher_test_case_1),
16033                 TEST_CASE_ST(ut_setup, ut_teardown,
16034                         test_kasumi_auth_cipher_test_case_2),
16035                 TEST_CASE_ST(ut_setup, ut_teardown,
16036                         test_kasumi_auth_cipher_test_case_2_oop),
16037                 TEST_CASE_ST(ut_setup, ut_teardown,
16038                         test_kasumi_auth_cipher_test_case_2_sgl),
16039                 TEST_CASE_ST(ut_setup, ut_teardown,
16040                         test_kasumi_auth_cipher_test_case_2_oop_sgl),
16041
16042                 /** KASUMI decrypt (F8), then verify auth */
16043                 TEST_CASE_ST(ut_setup, ut_teardown,
16044                         test_kasumi_auth_cipher_verify_test_case_1),
16045                 TEST_CASE_ST(ut_setup, ut_teardown,
16046                         test_kasumi_auth_cipher_verify_test_case_2),
16047                 TEST_CASE_ST(ut_setup, ut_teardown,
16048                         test_kasumi_auth_cipher_verify_test_case_2_oop),
16049                 TEST_CASE_ST(ut_setup, ut_teardown,
16050                         test_kasumi_auth_cipher_verify_test_case_2_sgl),
16051                 TEST_CASE_ST(ut_setup, ut_teardown,
16052                         test_kasumi_auth_cipher_verify_test_case_2_oop_sgl),
16053
16054                 TEST_CASES_END()
16055         }
16056 };
16057
16058 static struct unit_test_suite cryptodev_esn_testsuite  = {
16059         .suite_name = "ESN Test Suite",
16060         .setup = esn_testsuite_setup,
16061         .unit_test_cases = {
16062                 TEST_CASE_ST(ut_setup, ut_teardown,
16063                         auth_encrypt_AES128CBC_HMAC_SHA1_esn_check),
16064                 TEST_CASE_ST(ut_setup, ut_teardown,
16065                         auth_decrypt_AES128CBC_HMAC_SHA1_esn_check),
16066                 TEST_CASES_END()
16067         }
16068 };
16069
16070 static struct unit_test_suite cryptodev_negative_aes_gcm_testsuite  = {
16071         .suite_name = "Negative AES GCM Test Suite",
16072         .setup = negative_aes_gcm_testsuite_setup,
16073         .unit_test_cases = {
16074                 TEST_CASE_ST(ut_setup, ut_teardown,
16075                         test_AES_GCM_auth_encryption_fail_iv_corrupt),
16076                 TEST_CASE_ST(ut_setup, ut_teardown,
16077                         test_AES_GCM_auth_encryption_fail_in_data_corrupt),
16078                 TEST_CASE_ST(ut_setup, ut_teardown,
16079                         test_AES_GCM_auth_encryption_fail_out_data_corrupt),
16080                 TEST_CASE_ST(ut_setup, ut_teardown,
16081                         test_AES_GCM_auth_encryption_fail_aad_len_corrupt),
16082                 TEST_CASE_ST(ut_setup, ut_teardown,
16083                         test_AES_GCM_auth_encryption_fail_aad_corrupt),
16084                 TEST_CASE_ST(ut_setup, ut_teardown,
16085                         test_AES_GCM_auth_encryption_fail_tag_corrupt),
16086                 TEST_CASE_ST(ut_setup, ut_teardown,
16087                         test_AES_GCM_auth_decryption_fail_iv_corrupt),
16088                 TEST_CASE_ST(ut_setup, ut_teardown,
16089                         test_AES_GCM_auth_decryption_fail_in_data_corrupt),
16090                 TEST_CASE_ST(ut_setup, ut_teardown,
16091                         test_AES_GCM_auth_decryption_fail_out_data_corrupt),
16092                 TEST_CASE_ST(ut_setup, ut_teardown,
16093                         test_AES_GCM_auth_decryption_fail_aad_len_corrupt),
16094                 TEST_CASE_ST(ut_setup, ut_teardown,
16095                         test_AES_GCM_auth_decryption_fail_aad_corrupt),
16096                 TEST_CASE_ST(ut_setup, ut_teardown,
16097                         test_AES_GCM_auth_decryption_fail_tag_corrupt),
16098
16099                 TEST_CASES_END()
16100         }
16101 };
16102
16103 static struct unit_test_suite cryptodev_negative_aes_gmac_testsuite  = {
16104         .suite_name = "Negative AES GMAC Test Suite",
16105         .setup = negative_aes_gmac_testsuite_setup,
16106         .unit_test_cases = {
16107                 TEST_CASE_ST(ut_setup, ut_teardown,
16108                         authentication_verify_AES128_GMAC_fail_data_corrupt),
16109                 TEST_CASE_ST(ut_setup, ut_teardown,
16110                         authentication_verify_AES128_GMAC_fail_tag_corrupt),
16111
16112                 TEST_CASES_END()
16113         }
16114 };
16115
16116 static struct unit_test_suite cryptodev_mixed_cipher_hash_testsuite  = {
16117         .suite_name = "Mixed CIPHER + HASH algorithms Test Suite",
16118         .setup = mixed_cipher_hash_testsuite_setup,
16119         .unit_test_cases = {
16120                 /** AUTH AES CMAC + CIPHER AES CTR */
16121                 TEST_CASE_ST(ut_setup, ut_teardown,
16122                         test_aes_cmac_aes_ctr_digest_enc_test_case_1),
16123                 TEST_CASE_ST(ut_setup, ut_teardown,
16124                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
16125                 TEST_CASE_ST(ut_setup, ut_teardown,
16126                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
16127                 TEST_CASE_ST(ut_setup, ut_teardown,
16128                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
16129                 TEST_CASE_ST(ut_setup, ut_teardown,
16130                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1),
16131                 TEST_CASE_ST(ut_setup, ut_teardown,
16132                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
16133                 TEST_CASE_ST(ut_setup, ut_teardown,
16134                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
16135                 TEST_CASE_ST(ut_setup, ut_teardown,
16136                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
16137
16138                 /** AUTH ZUC + CIPHER SNOW3G */
16139                 TEST_CASE_ST(ut_setup, ut_teardown,
16140                         test_auth_zuc_cipher_snow_test_case_1),
16141                 TEST_CASE_ST(ut_setup, ut_teardown,
16142                         test_verify_auth_zuc_cipher_snow_test_case_1),
16143                 /** AUTH AES CMAC + CIPHER SNOW3G */
16144                 TEST_CASE_ST(ut_setup, ut_teardown,
16145                         test_auth_aes_cmac_cipher_snow_test_case_1),
16146                 TEST_CASE_ST(ut_setup, ut_teardown,
16147                         test_verify_auth_aes_cmac_cipher_snow_test_case_1),
16148                 /** AUTH ZUC + CIPHER AES CTR */
16149                 TEST_CASE_ST(ut_setup, ut_teardown,
16150                         test_auth_zuc_cipher_aes_ctr_test_case_1),
16151                 TEST_CASE_ST(ut_setup, ut_teardown,
16152                         test_verify_auth_zuc_cipher_aes_ctr_test_case_1),
16153                 /** AUTH SNOW3G + CIPHER AES CTR */
16154                 TEST_CASE_ST(ut_setup, ut_teardown,
16155                         test_auth_snow_cipher_aes_ctr_test_case_1),
16156                 TEST_CASE_ST(ut_setup, ut_teardown,
16157                         test_verify_auth_snow_cipher_aes_ctr_test_case_1),
16158                 /** AUTH SNOW3G + CIPHER ZUC */
16159                 TEST_CASE_ST(ut_setup, ut_teardown,
16160                         test_auth_snow_cipher_zuc_test_case_1),
16161                 TEST_CASE_ST(ut_setup, ut_teardown,
16162                         test_verify_auth_snow_cipher_zuc_test_case_1),
16163                 /** AUTH AES CMAC + CIPHER ZUC */
16164                 TEST_CASE_ST(ut_setup, ut_teardown,
16165                         test_auth_aes_cmac_cipher_zuc_test_case_1),
16166                 TEST_CASE_ST(ut_setup, ut_teardown,
16167                         test_verify_auth_aes_cmac_cipher_zuc_test_case_1),
16168
16169                 /** AUTH NULL + CIPHER SNOW3G */
16170                 TEST_CASE_ST(ut_setup, ut_teardown,
16171                         test_auth_null_cipher_snow_test_case_1),
16172                 TEST_CASE_ST(ut_setup, ut_teardown,
16173                         test_verify_auth_null_cipher_snow_test_case_1),
16174                 /** AUTH NULL + CIPHER ZUC */
16175                 TEST_CASE_ST(ut_setup, ut_teardown,
16176                         test_auth_null_cipher_zuc_test_case_1),
16177                 TEST_CASE_ST(ut_setup, ut_teardown,
16178                         test_verify_auth_null_cipher_zuc_test_case_1),
16179                 /** AUTH SNOW3G + CIPHER NULL */
16180                 TEST_CASE_ST(ut_setup, ut_teardown,
16181                         test_auth_snow_cipher_null_test_case_1),
16182                 TEST_CASE_ST(ut_setup, ut_teardown,
16183                         test_verify_auth_snow_cipher_null_test_case_1),
16184                 /** AUTH ZUC + CIPHER NULL */
16185                 TEST_CASE_ST(ut_setup, ut_teardown,
16186                         test_auth_zuc_cipher_null_test_case_1),
16187                 TEST_CASE_ST(ut_setup, ut_teardown,
16188                         test_verify_auth_zuc_cipher_null_test_case_1),
16189                 /** AUTH NULL + CIPHER AES CTR */
16190                 TEST_CASE_ST(ut_setup, ut_teardown,
16191                         test_auth_null_cipher_aes_ctr_test_case_1),
16192                 TEST_CASE_ST(ut_setup, ut_teardown,
16193                         test_verify_auth_null_cipher_aes_ctr_test_case_1),
16194                 /** AUTH AES CMAC + CIPHER NULL */
16195                 TEST_CASE_ST(ut_setup, ut_teardown,
16196                         test_auth_aes_cmac_cipher_null_test_case_1),
16197                 TEST_CASE_ST(ut_setup, ut_teardown,
16198                         test_verify_auth_aes_cmac_cipher_null_test_case_1),
16199                 TEST_CASES_END()
16200         }
16201 };
16202
16203 static int
16204 run_cryptodev_testsuite(const char *pmd_name)
16205 {
16206         uint8_t ret, j, i = 0, blk_start_idx = 0;
16207         const enum blockcipher_test_type blk_suites[] = {
16208                 BLKCIPHER_AES_CHAIN_TYPE,
16209                 BLKCIPHER_AES_CIPHERONLY_TYPE,
16210                 BLKCIPHER_AES_DOCSIS_TYPE,
16211                 BLKCIPHER_3DES_CHAIN_TYPE,
16212                 BLKCIPHER_3DES_CIPHERONLY_TYPE,
16213                 BLKCIPHER_DES_CIPHERONLY_TYPE,
16214                 BLKCIPHER_DES_DOCSIS_TYPE,
16215                 BLKCIPHER_AUTHONLY_TYPE};
16216         struct unit_test_suite *static_suites[] = {
16217                 &cryptodev_multi_session_testsuite,
16218                 &cryptodev_null_testsuite,
16219                 &cryptodev_aes_ccm_auth_testsuite,
16220                 &cryptodev_aes_gcm_auth_testsuite,
16221                 &cryptodev_aes_gmac_auth_testsuite,
16222                 &cryptodev_snow3g_testsuite,
16223                 &cryptodev_chacha20_poly1305_testsuite,
16224                 &cryptodev_zuc_testsuite,
16225                 &cryptodev_hmac_md5_auth_testsuite,
16226                 &cryptodev_kasumi_testsuite,
16227                 &cryptodev_esn_testsuite,
16228                 &cryptodev_negative_aes_gcm_testsuite,
16229                 &cryptodev_negative_aes_gmac_testsuite,
16230                 &cryptodev_mixed_cipher_hash_testsuite,
16231                 &cryptodev_negative_hmac_sha1_testsuite,
16232                 &cryptodev_gen_testsuite,
16233 #ifdef RTE_LIB_SECURITY
16234                 &ipsec_proto_testsuite,
16235                 &pdcp_proto_testsuite,
16236                 &docsis_proto_testsuite,
16237 #endif
16238                 &end_testsuite
16239         };
16240         static struct unit_test_suite ts = {
16241                 .suite_name = "Cryptodev Unit Test Suite",
16242                 .setup = testsuite_setup,
16243                 .teardown = testsuite_teardown,
16244                 .unit_test_cases = {TEST_CASES_END()}
16245         };
16246
16247         gbl_driver_id = rte_cryptodev_driver_id_get(pmd_name);
16248
16249         if (gbl_driver_id == -1) {
16250                 RTE_LOG(ERR, USER1, "%s PMD must be loaded.\n", pmd_name);
16251                 return TEST_SKIPPED;
16252         }
16253
16254         ts.unit_test_suites = malloc(sizeof(struct unit_test_suite *) *
16255                         (RTE_DIM(blk_suites) + RTE_DIM(static_suites)));
16256
16257         ADD_BLOCKCIPHER_TESTSUITE(i, ts, blk_suites, RTE_DIM(blk_suites));
16258         ADD_STATIC_TESTSUITE(i, ts, static_suites, RTE_DIM(static_suites));
16259         ret = unit_test_suite_runner(&ts);
16260
16261         FREE_BLOCKCIPHER_TESTSUITE(blk_start_idx, ts, RTE_DIM(blk_suites));
16262         free(ts.unit_test_suites);
16263         return ret;
16264 }
16265
16266 static int
16267 require_feature_flag(const char *pmd_name, uint64_t flag, const char *flag_name)
16268 {
16269         struct rte_cryptodev_info dev_info;
16270         uint8_t i, nb_devs;
16271         int driver_id;
16272
16273         driver_id = rte_cryptodev_driver_id_get(pmd_name);
16274         if (driver_id == -1) {
16275                 RTE_LOG(WARNING, USER1, "%s PMD must be loaded.\n", pmd_name);
16276                 return TEST_SKIPPED;
16277         }
16278
16279         nb_devs = rte_cryptodev_count();
16280         if (nb_devs < 1) {
16281                 RTE_LOG(WARNING, USER1, "No crypto devices found?\n");
16282                 return TEST_SKIPPED;
16283         }
16284
16285         for (i = 0; i < nb_devs; i++) {
16286                 rte_cryptodev_info_get(i, &dev_info);
16287                 if (dev_info.driver_id == driver_id) {
16288                         if (!(dev_info.feature_flags & flag)) {
16289                                 RTE_LOG(INFO, USER1, "%s not supported\n",
16290                                                 flag_name);
16291                                 return TEST_SKIPPED;
16292                         }
16293                         return 0; /* found */
16294                 }
16295         }
16296
16297         RTE_LOG(INFO, USER1, "%s not supported\n", flag_name);
16298         return TEST_SKIPPED;
16299 }
16300
16301 static int
16302 test_cryptodev_qat(void)
16303 {
16304         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
16305 }
16306
16307 static int
16308 test_cryptodev_virtio(void)
16309 {
16310         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD));
16311 }
16312
16313 static int
16314 test_cryptodev_aesni_mb(void)
16315 {
16316         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
16317 }
16318
16319 static int
16320 test_cryptodev_cpu_aesni_mb(void)
16321 {
16322         int32_t rc;
16323         enum rte_security_session_action_type at = gbl_action_type;
16324         gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
16325         rc = run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
16326         gbl_action_type = at;
16327         return rc;
16328 }
16329
16330 static int
16331 test_cryptodev_chacha_poly_mb(void)
16332 {
16333         int32_t rc;
16334         enum rte_security_session_action_type at = gbl_action_type;
16335         rc = run_cryptodev_testsuite(
16336                         RTE_STR(CRYPTODEV_NAME_CHACHA20_POLY1305_PMD));
16337         gbl_action_type = at;
16338         return rc;
16339 }
16340
16341 static int
16342 test_cryptodev_openssl(void)
16343 {
16344         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
16345 }
16346
16347 static int
16348 test_cryptodev_aesni_gcm(void)
16349 {
16350         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
16351 }
16352
16353 static int
16354 test_cryptodev_cpu_aesni_gcm(void)
16355 {
16356         int32_t rc;
16357         enum rte_security_session_action_type at = gbl_action_type;
16358         gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
16359         rc  = run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
16360         gbl_action_type = at;
16361         return rc;
16362 }
16363
16364 static int
16365 test_cryptodev_mlx5(void)
16366 {
16367         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_MLX5_PMD));
16368 }
16369
16370 static int
16371 test_cryptodev_null(void)
16372 {
16373         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_NULL_PMD));
16374 }
16375
16376 static int
16377 test_cryptodev_sw_snow3g(void)
16378 {
16379         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
16380 }
16381
16382 static int
16383 test_cryptodev_sw_kasumi(void)
16384 {
16385         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
16386 }
16387
16388 static int
16389 test_cryptodev_sw_zuc(void)
16390 {
16391         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
16392 }
16393
16394 static int
16395 test_cryptodev_armv8(void)
16396 {
16397         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
16398 }
16399
16400 static int
16401 test_cryptodev_mrvl(void)
16402 {
16403         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
16404 }
16405
16406 #ifdef RTE_CRYPTO_SCHEDULER
16407
16408 static int
16409 test_cryptodev_scheduler(void)
16410 {
16411         uint8_t ret, sched_i, j, i = 0, blk_start_idx = 0;
16412         const enum blockcipher_test_type blk_suites[] = {
16413                 BLKCIPHER_AES_CHAIN_TYPE,
16414                 BLKCIPHER_AES_CIPHERONLY_TYPE,
16415                 BLKCIPHER_AUTHONLY_TYPE
16416         };
16417         static struct unit_test_suite scheduler_multicore = {
16418                 .suite_name = "Scheduler Multicore Unit Test Suite",
16419                 .setup = scheduler_multicore_testsuite_setup,
16420                 .teardown = scheduler_mode_testsuite_teardown,
16421                 .unit_test_cases = {TEST_CASES_END()}
16422         };
16423         static struct unit_test_suite scheduler_round_robin = {
16424                 .suite_name = "Scheduler Round Robin Unit Test Suite",
16425                 .setup = scheduler_roundrobin_testsuite_setup,
16426                 .teardown = scheduler_mode_testsuite_teardown,
16427                 .unit_test_cases = {TEST_CASES_END()}
16428         };
16429         static struct unit_test_suite scheduler_failover = {
16430                 .suite_name = "Scheduler Failover Unit Test Suite",
16431                 .setup = scheduler_failover_testsuite_setup,
16432                 .teardown = scheduler_mode_testsuite_teardown,
16433                 .unit_test_cases = {TEST_CASES_END()}
16434         };
16435         static struct unit_test_suite scheduler_pkt_size_distr = {
16436                 .suite_name = "Scheduler Pkt Size Distr Unit Test Suite",
16437                 .setup = scheduler_pkt_size_distr_testsuite_setup,
16438                 .teardown = scheduler_mode_testsuite_teardown,
16439                 .unit_test_cases = {TEST_CASES_END()}
16440         };
16441         struct unit_test_suite *sched_mode_suites[] = {
16442                 &scheduler_multicore,
16443                 &scheduler_round_robin,
16444                 &scheduler_failover,
16445                 &scheduler_pkt_size_distr
16446         };
16447         static struct unit_test_suite scheduler_config = {
16448                 .suite_name = "Crypto Device Scheduler Config Unit Test Suite",
16449                 .unit_test_cases = {
16450                         TEST_CASE(test_scheduler_attach_worker_op),
16451                         TEST_CASE(test_scheduler_mode_multicore_op),
16452                         TEST_CASE(test_scheduler_mode_roundrobin_op),
16453                         TEST_CASE(test_scheduler_mode_failover_op),
16454                         TEST_CASE(test_scheduler_mode_pkt_size_distr_op),
16455                         TEST_CASE(test_scheduler_detach_worker_op),
16456
16457                         TEST_CASES_END() /**< NULL terminate array */
16458                 }
16459         };
16460         struct unit_test_suite *static_suites[] = {
16461                 &scheduler_config,
16462                 &end_testsuite
16463         };
16464         static struct unit_test_suite ts = {
16465                 .suite_name = "Scheduler Unit Test Suite",
16466                 .setup = scheduler_testsuite_setup,
16467                 .teardown = testsuite_teardown,
16468                 .unit_test_cases = {TEST_CASES_END()}
16469         };
16470
16471         gbl_driver_id = rte_cryptodev_driver_id_get(
16472                         RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
16473
16474         if (gbl_driver_id == -1) {
16475                 RTE_LOG(ERR, USER1, "SCHEDULER PMD must be loaded.\n");
16476                 return TEST_SKIPPED;
16477         }
16478
16479         if (rte_cryptodev_driver_id_get(
16480                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) == -1) {
16481                 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded.\n");
16482                 return TEST_SKIPPED;
16483         }
16484
16485         for (sched_i = 0; sched_i < RTE_DIM(sched_mode_suites); sched_i++) {
16486                 uint8_t blk_i = 0;
16487                 sched_mode_suites[sched_i]->unit_test_suites = malloc(sizeof
16488                                 (struct unit_test_suite *) *
16489                                 (RTE_DIM(blk_suites) + 1));
16490                 ADD_BLOCKCIPHER_TESTSUITE(blk_i, (*sched_mode_suites[sched_i]),
16491                                 blk_suites, RTE_DIM(blk_suites));
16492                 sched_mode_suites[sched_i]->unit_test_suites[blk_i] = &end_testsuite;
16493         }
16494
16495         ts.unit_test_suites = malloc(sizeof(struct unit_test_suite *) *
16496                         (RTE_DIM(static_suites) + RTE_DIM(sched_mode_suites)));
16497         ADD_STATIC_TESTSUITE(i, ts, sched_mode_suites,
16498                         RTE_DIM(sched_mode_suites));
16499         ADD_STATIC_TESTSUITE(i, ts, static_suites, RTE_DIM(static_suites));
16500         ret = unit_test_suite_runner(&ts);
16501
16502         for (sched_i = 0; sched_i < RTE_DIM(sched_mode_suites); sched_i++) {
16503                 FREE_BLOCKCIPHER_TESTSUITE(blk_start_idx,
16504                                 (*sched_mode_suites[sched_i]),
16505                                 RTE_DIM(blk_suites));
16506                 free(sched_mode_suites[sched_i]->unit_test_suites);
16507         }
16508         free(ts.unit_test_suites);
16509         return ret;
16510 }
16511
16512 REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler);
16513
16514 #endif
16515
16516 static int
16517 test_cryptodev_dpaa2_sec(void)
16518 {
16519         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
16520 }
16521
16522 static int
16523 test_cryptodev_dpaa_sec(void)
16524 {
16525         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD));
16526 }
16527
16528 static int
16529 test_cryptodev_ccp(void)
16530 {
16531         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CCP_PMD));
16532 }
16533
16534 static int
16535 test_cryptodev_octeontx(void)
16536 {
16537         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD));
16538 }
16539
16540 static int
16541 test_cryptodev_caam_jr(void)
16542 {
16543         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD));
16544 }
16545
16546 static int
16547 test_cryptodev_nitrox(void)
16548 {
16549         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_NITROX_PMD));
16550 }
16551
16552 static int
16553 test_cryptodev_bcmfs(void)
16554 {
16555         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_BCMFS_PMD));
16556 }
16557
16558 static int
16559 test_cryptodev_qat_raw_api(void)
16560 {
16561         static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD);
16562         int ret;
16563
16564         ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
16565                         "RAW API");
16566         if (ret)
16567                 return ret;
16568
16569         global_api_test_type = CRYPTODEV_RAW_API_TEST;
16570         ret = run_cryptodev_testsuite(pmd_name);
16571         global_api_test_type = CRYPTODEV_API_TEST;
16572
16573         return ret;
16574 }
16575
16576 static int
16577 test_cryptodev_cn9k(void)
16578 {
16579         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CN9K_PMD));
16580 }
16581
16582 static int
16583 test_cryptodev_cn10k(void)
16584 {
16585         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CN10K_PMD));
16586 }
16587
16588 static int
16589 test_cryptodev_dpaa2_sec_raw_api(void)
16590 {
16591         static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD);
16592         int ret;
16593
16594         ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
16595                         "RAW API");
16596         if (ret)
16597                 return ret;
16598
16599         global_api_test_type = CRYPTODEV_RAW_API_TEST;
16600         ret = run_cryptodev_testsuite(pmd_name);
16601         global_api_test_type = CRYPTODEV_API_TEST;
16602
16603         return ret;
16604 }
16605
16606 static int
16607 test_cryptodev_dpaa_sec_raw_api(void)
16608 {
16609         static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD);
16610         int ret;
16611
16612         ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
16613                         "RAW API");
16614         if (ret)
16615                 return ret;
16616
16617         global_api_test_type = CRYPTODEV_RAW_API_TEST;
16618         ret = run_cryptodev_testsuite(pmd_name);
16619         global_api_test_type = CRYPTODEV_API_TEST;
16620
16621         return ret;
16622 }
16623
16624 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_raw_api_autotest,
16625                 test_cryptodev_dpaa2_sec_raw_api);
16626 REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_raw_api_autotest,
16627                 test_cryptodev_dpaa_sec_raw_api);
16628 REGISTER_TEST_COMMAND(cryptodev_qat_raw_api_autotest,
16629                 test_cryptodev_qat_raw_api);
16630 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
16631 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
16632 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_mb_autotest,
16633         test_cryptodev_cpu_aesni_mb);
16634 REGISTER_TEST_COMMAND(cryptodev_chacha_poly_mb_autotest,
16635         test_cryptodev_chacha_poly_mb);
16636 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl);
16637 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm);
16638 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_gcm_autotest,
16639         test_cryptodev_cpu_aesni_gcm);
16640 REGISTER_TEST_COMMAND(cryptodev_mlx5_autotest, test_cryptodev_mlx5);
16641 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null);
16642 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
16643 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);
16644 REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc);
16645 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_autotest, test_cryptodev_armv8);
16646 REGISTER_TEST_COMMAND(cryptodev_sw_mvsam_autotest, test_cryptodev_mrvl);
16647 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_autotest, test_cryptodev_dpaa2_sec);
16648 REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_autotest, test_cryptodev_dpaa_sec);
16649 REGISTER_TEST_COMMAND(cryptodev_ccp_autotest, test_cryptodev_ccp);
16650 REGISTER_TEST_COMMAND(cryptodev_virtio_autotest, test_cryptodev_virtio);
16651 REGISTER_TEST_COMMAND(cryptodev_octeontx_autotest, test_cryptodev_octeontx);
16652 REGISTER_TEST_COMMAND(cryptodev_caam_jr_autotest, test_cryptodev_caam_jr);
16653 REGISTER_TEST_COMMAND(cryptodev_nitrox_autotest, test_cryptodev_nitrox);
16654 REGISTER_TEST_COMMAND(cryptodev_bcmfs_autotest, test_cryptodev_bcmfs);
16655 REGISTER_TEST_COMMAND(cryptodev_cn9k_autotest, test_cryptodev_cn9k);
16656 REGISTER_TEST_COMMAND(cryptodev_cn10k_autotest, test_cryptodev_cn10k);
16657
16658 #endif /* !RTE_EXEC_ENV_WINDOWS */