app/test/test_cryptodev.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2015-2020 Intel Corporation
   3  * Copyright 2020 NXP
   4  */
   5
   6 #include <time.h>
   7
   8 #include <rte_common.h>
   9 #include <rte_hexdump.h>
  10 #include <rte_mbuf.h>
  11 #include <rte_malloc.h>
  12 #include <rte_memcpy.h>
  13 #include <rte_pause.h>
  14 #include <rte_bus_vdev.h>
  15 #include <rte_ether.h>
  16
  17 #include <rte_crypto.h>
  18 #include <rte_cryptodev.h>
  19 #include <rte_ip.h>
  20 #include <rte_string_fns.h>
  21 #include <rte_tcp.h>
  22 #include <rte_udp.h>
  23
  24 #ifdef RTE_CRYPTO_SCHEDULER
  25 #include <rte_cryptodev_scheduler.h>
  26 #include <rte_cryptodev_scheduler_operations.h>
  27 #endif
  28
  29 #include <rte_lcore.h>
  30
  31 #include "test.h"
  32 #include "test_cryptodev.h"
  33
  34 #include "test_cryptodev_blockcipher.h"
  35 #include "test_cryptodev_aes_test_vectors.h"
  36 #include "test_cryptodev_des_test_vectors.h"
  37 #include "test_cryptodev_hash_test_vectors.h"
  38 #include "test_cryptodev_kasumi_test_vectors.h"
  39 #include "test_cryptodev_kasumi_hash_test_vectors.h"
  40 #include "test_cryptodev_snow3g_test_vectors.h"
  41 #include "test_cryptodev_snow3g_hash_test_vectors.h"
  42 #include "test_cryptodev_zuc_test_vectors.h"
  43 #include "test_cryptodev_aead_test_vectors.h"
  44 #include "test_cryptodev_hmac_test_vectors.h"
  45 #include "test_cryptodev_mixed_test_vectors.h"
  46 #ifdef RTE_LIB_SECURITY
  47 #include "test_cryptodev_security_ipsec.h"
  48 #include "test_cryptodev_security_ipsec_test_vectors.h"
  49 #include "test_cryptodev_security_pdcp_test_vectors.h"
  50 #include "test_cryptodev_security_pdcp_sdap_test_vectors.h"
  51 #include "test_cryptodev_security_pdcp_test_func.h"
  52 #include "test_cryptodev_security_docsis_test_vectors.h"
  53
  54 #define SDAP_DISABLED   0
  55 #define SDAP_ENABLED    1
  56 #endif
  57
  58 #define VDEV_ARGS_SIZE 100
  59 #define MAX_NB_SESSIONS 4
  60
  61 #define MAX_DRV_SERVICE_CTX_SIZE 256
  62
  63 #define MAX_RAW_DEQUEUE_COUNT   65535
  64
  65 #define IN_PLACE 0
  66 #define OUT_OF_PLACE 1
  67
  68 static int gbl_driver_id;
  69
  70 static enum rte_security_session_action_type gbl_action_type =
  71         RTE_SECURITY_ACTION_TYPE_NONE;
  72
  73 enum cryptodev_api_test_type global_api_test_type = CRYPTODEV_API_TEST;
  74
  75 struct crypto_unittest_params {
  76         struct rte_crypto_sym_xform cipher_xform;
  77         struct rte_crypto_sym_xform auth_xform;
  78         struct rte_crypto_sym_xform aead_xform;
  79 #ifdef RTE_LIB_SECURITY
  80         struct rte_security_docsis_xform docsis_xform;
  81 #endif
  82
  83         union {
  84                 struct rte_cryptodev_sym_session *sess;
  85 #ifdef RTE_LIB_SECURITY
  86                 struct rte_security_session *sec_session;
  87 #endif
  88         };
  89 #ifdef RTE_LIB_SECURITY
  90         enum rte_security_session_action_type type;
  91 #endif
  92         struct rte_crypto_op *op;
  93
  94         struct rte_mbuf *obuf, *ibuf;
  95
  96         uint8_t *digest;
  97 };
  98
  99 #define ALIGN_POW2_ROUNDUP(num, align) \
 100         (((num) + (align) - 1) & ~((align) - 1))
 101
 102 #define ADD_STATIC_TESTSUITE(index, parent_ts, child_ts, num_child_ts)  \
 103         for (j = 0; j < num_child_ts; index++, j++)                     \
 104                 parent_ts.unit_test_suites[index] = child_ts[j]
 105
 106 #define ADD_BLOCKCIPHER_TESTSUITE(index, parent_ts, blk_types, num_blk_types)   \
 107         for (j = 0; j < num_blk_types; index++, j++)                            \
 108                 parent_ts.unit_test_suites[index] =                             \
 109                                 build_blockcipher_test_suite(blk_types[j])
 110
 111 #define FREE_BLOCKCIPHER_TESTSUITE(index, parent_ts, num_blk_types)             \
 112         for (j = index; j < index + num_blk_types; j++)                         \
 113                 free_blockcipher_test_suite(parent_ts.unit_test_suites[j])
 114
 115 /*
 116  * Forward declarations.
 117  */
 118 static int
 119 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
 120                 struct crypto_unittest_params *ut_params, uint8_t *cipher_key,
 121                 uint8_t *hmac_key);
 122
 123 static int
 124 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
 125                 struct crypto_unittest_params *ut_params,
 126                 struct crypto_testsuite_params *ts_param,
 127                 const uint8_t *cipher,
 128                 const uint8_t *digest,
 129                 const uint8_t *iv);
 130
 131 static int
 132 security_proto_supported(enum rte_security_session_action_type action,
 133         enum rte_security_session_protocol proto);
 134
 135 static int
 136 dev_configure_and_start(uint64_t ff_disable);
 137
 138 static struct rte_mbuf *
 139 setup_test_string(struct rte_mempool *mpool,
 140                 const char *string, size_t len, uint8_t blocksize)
 141 {
 142         struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
 143         size_t t_len = len - (blocksize ? (len % blocksize) : 0);
 144
 145         if (m) {
 146                 char *dst;
 147
 148                 memset(m->buf_addr, 0, m->buf_len);
 149                 dst = rte_pktmbuf_append(m, t_len);
 150                 if (!dst) {
 151                         rte_pktmbuf_free(m);
 152                         return NULL;
 153                 }
 154                 if (string != NULL)
 155                         rte_memcpy(dst, string, t_len);
 156                 else
 157                         memset(dst, 0, t_len);
 158         }
 159
 160         return m;
 161 }
 162
 163 /* Get number of bytes in X bits (rounding up) */
 164 static uint32_t
 165 ceil_byte_length(uint32_t num_bits)
 166 {
 167         if (num_bits % 8)
 168                 return ((num_bits >> 3) + 1);
 169         else
 170                 return (num_bits >> 3);
 171 }
 172
 173 static void
 174 post_process_raw_dp_op(void *user_data, uint32_t index __rte_unused,
 175                 uint8_t is_op_success)
 176 {
 177         struct rte_crypto_op *op = user_data;
 178         op->status = is_op_success ? RTE_CRYPTO_OP_STATUS_SUCCESS :
 179                         RTE_CRYPTO_OP_STATUS_ERROR;
 180 }
 181
 182 void
 183 process_sym_raw_dp_op(uint8_t dev_id, uint16_t qp_id,
 184                 struct rte_crypto_op *op, uint8_t is_cipher, uint8_t is_auth,
 185                 uint8_t len_in_bits, uint8_t cipher_iv_len)
 186 {
 187         struct rte_crypto_sym_op *sop = op->sym;
 188         struct rte_crypto_op *ret_op = NULL;
 189         struct rte_crypto_vec data_vec[UINT8_MAX], dest_data_vec[UINT8_MAX];
 190         struct rte_crypto_va_iova_ptr cipher_iv, digest, aad_auth_iv;
 191         union rte_crypto_sym_ofs ofs;
 192         struct rte_crypto_sym_vec vec;
 193         struct rte_crypto_sgl sgl, dest_sgl;
 194         uint32_t max_len;
 195         union rte_cryptodev_session_ctx sess;
 196         uint32_t count = 0;
 197         struct rte_crypto_raw_dp_ctx *ctx;
 198         uint32_t cipher_offset = 0, cipher_len = 0, auth_offset = 0,
 199                         auth_len = 0;
 200         int32_t n;
 201         uint32_t n_success;
 202         int ctx_service_size;
 203         int32_t status = 0;
 204         int enqueue_status, dequeue_status;
 205
 206         ctx_service_size = rte_cryptodev_get_raw_dp_ctx_size(dev_id);
 207         if (ctx_service_size < 0) {
 208                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 209                 return;
 210         }
 211
 212         ctx = malloc(ctx_service_size);
 213         if (!ctx) {
 214                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 215                 return;
 216         }
 217
 218         /* Both are enums, setting crypto_sess will suit any session type */
 219         sess.crypto_sess = op->sym->session;
 220
 221         if (rte_cryptodev_configure_raw_dp_ctx(dev_id, qp_id, ctx,
 222                         op->sess_type, sess, 0) < 0) {
 223                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 224                 goto exit;
 225         }
 226
 227         cipher_iv.iova = 0;
 228         cipher_iv.va = NULL;
 229         aad_auth_iv.iova = 0;
 230         aad_auth_iv.va = NULL;
 231         digest.iova = 0;
 232         digest.va = NULL;
 233         sgl.vec = data_vec;
 234         vec.num = 1;
 235         vec.src_sgl = &sgl;
 236         vec.iv = &cipher_iv;
 237         vec.digest = &digest;
 238         vec.aad = &aad_auth_iv;
 239         vec.status = &status;
 240
 241         ofs.raw = 0;
 242
 243         if (is_cipher && is_auth) {
 244                 cipher_offset = sop->cipher.data.offset;
 245                 cipher_len = sop->cipher.data.length;
 246                 auth_offset = sop->auth.data.offset;
 247                 auth_len = sop->auth.data.length;
 248                 max_len = RTE_MAX(cipher_offset + cipher_len,
 249                                 auth_offset + auth_len);
 250                 if (len_in_bits) {
 251                         max_len = max_len >> 3;
 252                         cipher_offset = cipher_offset >> 3;
 253                         auth_offset = auth_offset >> 3;
 254                         cipher_len = cipher_len >> 3;
 255                         auth_len = auth_len >> 3;
 256                 }
 257                 ofs.ofs.cipher.head = cipher_offset;
 258                 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
 259                 ofs.ofs.auth.head = auth_offset;
 260                 ofs.ofs.auth.tail = max_len - auth_offset - auth_len;
 261                 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 262                 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
 263                 aad_auth_iv.va = rte_crypto_op_ctod_offset(
 264                                 op, void *, IV_OFFSET + cipher_iv_len);
 265                 aad_auth_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET +
 266                                 cipher_iv_len);
 267                 digest.va = (void *)sop->auth.digest.data;
 268                 digest.iova = sop->auth.digest.phys_addr;
 269
 270         } else if (is_cipher) {
 271                 cipher_offset = sop->cipher.data.offset;
 272                 cipher_len = sop->cipher.data.length;
 273                 max_len = cipher_len + cipher_offset;
 274                 if (len_in_bits) {
 275                         max_len = max_len >> 3;
 276                         cipher_offset = cipher_offset >> 3;
 277                         cipher_len = cipher_len >> 3;
 278                 }
 279                 ofs.ofs.cipher.head = cipher_offset;
 280                 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
 281                 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 282                 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
 283
 284         } else if (is_auth) {
 285                 auth_offset = sop->auth.data.offset;
 286                 auth_len = sop->auth.data.length;
 287                 max_len = auth_len + auth_offset;
 288                 if (len_in_bits) {
 289                         max_len = max_len >> 3;
 290                         auth_offset = auth_offset >> 3;
 291                         auth_len = auth_len >> 3;
 292                 }
 293                 ofs.ofs.auth.head = auth_offset;
 294                 ofs.ofs.auth.tail = max_len - auth_offset - auth_len;
 295                 aad_auth_iv.va = rte_crypto_op_ctod_offset(
 296                                 op, void *, IV_OFFSET + cipher_iv_len);
 297                 aad_auth_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET +
 298                                 cipher_iv_len);
 299                 digest.va = (void *)sop->auth.digest.data;
 300                 digest.iova = sop->auth.digest.phys_addr;
 301
 302         } else { /* aead */
 303                 cipher_offset = sop->aead.data.offset;
 304                 cipher_len = sop->aead.data.length;
 305                 max_len = cipher_len + cipher_offset;
 306                 if (len_in_bits) {
 307                         max_len = max_len >> 3;
 308                         cipher_offset = cipher_offset >> 3;
 309                         cipher_len = cipher_len >> 3;
 310                 }
 311                 ofs.ofs.cipher.head = cipher_offset;
 312                 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
 313                 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 314                 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
 315                 aad_auth_iv.va = (void *)sop->aead.aad.data;
 316                 aad_auth_iv.iova = sop->aead.aad.phys_addr;
 317                 digest.va = (void *)sop->aead.digest.data;
 318                 digest.iova = sop->aead.digest.phys_addr;
 319         }
 320
 321         n = rte_crypto_mbuf_to_vec(sop->m_src, 0, max_len,
 322                         data_vec, RTE_DIM(data_vec));
 323         if (n < 0 || n > sop->m_src->nb_segs) {
 324                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 325                 goto exit;
 326         }
 327
 328         sgl.num = n;
 329         /* Out of place */
 330         if (sop->m_dst != NULL) {
 331                 dest_sgl.vec = dest_data_vec;
 332                 vec.dest_sgl = &dest_sgl;
 333                 n = rte_crypto_mbuf_to_vec(sop->m_dst, 0, max_len,
 334                                 dest_data_vec, RTE_DIM(dest_data_vec));
 335                 if (n < 0 || n > sop->m_dst->nb_segs) {
 336                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 337                         goto exit;
 338                 }
 339                 dest_sgl.num = n;
 340         } else
 341                 vec.dest_sgl = NULL;
 342
 343         if (rte_cryptodev_raw_enqueue_burst(ctx, &vec, ofs, (void **)&op,
 344                         &enqueue_status) < 1) {
 345                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 346                 goto exit;
 347         }
 348
 349         if (enqueue_status == 0) {
 350                 status = rte_cryptodev_raw_enqueue_done(ctx, 1);
 351                 if (status < 0) {
 352                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 353                         goto exit;
 354                 }
 355         } else if (enqueue_status < 0) {
 356                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 357                 goto exit;
 358         }
 359
 360         n = n_success = 0;
 361         while (count++ < MAX_RAW_DEQUEUE_COUNT && n == 0) {
 362                 n = rte_cryptodev_raw_dequeue_burst(ctx,
 363                         NULL, 1, post_process_raw_dp_op,
 364                                 (void **)&ret_op, 0, &n_success,
 365                                 &dequeue_status);
 366                 if (dequeue_status < 0) {
 367                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 368                         goto exit;
 369                 }
 370                 if (n == 0)
 371                         rte_pause();
 372         }
 373
 374         if (n == 1 && dequeue_status == 0) {
 375                 if (rte_cryptodev_raw_dequeue_done(ctx, 1) < 0) {
 376                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 377                         goto exit;
 378                 }
 379         }
 380
 381         op->status = (count == MAX_RAW_DEQUEUE_COUNT + 1 || ret_op != op ||
 382                         ret_op->status == RTE_CRYPTO_OP_STATUS_ERROR ||
 383                         n_success < 1) ? RTE_CRYPTO_OP_STATUS_ERROR :
 384                                         RTE_CRYPTO_OP_STATUS_SUCCESS;
 385
 386 exit:
 387         free(ctx);
 388 }
 389
 390 static void
 391 process_cpu_aead_op(uint8_t dev_id, struct rte_crypto_op *op)
 392 {
 393         int32_t n, st;
 394         struct rte_crypto_sym_op *sop;
 395         union rte_crypto_sym_ofs ofs;
 396         struct rte_crypto_sgl sgl;
 397         struct rte_crypto_sym_vec symvec;
 398         struct rte_crypto_va_iova_ptr iv_ptr, aad_ptr, digest_ptr;
 399         struct rte_crypto_vec vec[UINT8_MAX];
 400
 401         sop = op->sym;
 402
 403         n = rte_crypto_mbuf_to_vec(sop->m_src, sop->aead.data.offset,
 404                 sop->aead.data.length, vec, RTE_DIM(vec));
 405
 406         if (n < 0 || n != sop->m_src->nb_segs) {
 407                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 408                 return;
 409         }
 410
 411         sgl.vec = vec;
 412         sgl.num = n;
 413         symvec.src_sgl = &sgl;
 414         symvec.iv = &iv_ptr;
 415         symvec.digest = &digest_ptr;
 416         symvec.aad = &aad_ptr;
 417         symvec.status = &st;
 418         symvec.num = 1;
 419
 420         /* for CPU crypto the IOVA address is not required */
 421         iv_ptr.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 422         digest_ptr.va = (void *)sop->aead.digest.data;
 423         aad_ptr.va = (void *)sop->aead.aad.data;
 424
 425         ofs.raw = 0;
 426
 427         n = rte_cryptodev_sym_cpu_crypto_process(dev_id, sop->session, ofs,
 428                 &symvec);
 429
 430         if (n != 1)
 431                 op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
 432         else
 433                 op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
 434 }
 435
 436 static void
 437 process_cpu_crypt_auth_op(uint8_t dev_id, struct rte_crypto_op *op)
 438 {
 439         int32_t n, st;
 440         struct rte_crypto_sym_op *sop;
 441         union rte_crypto_sym_ofs ofs;
 442         struct rte_crypto_sgl sgl;
 443         struct rte_crypto_sym_vec symvec;
 444         struct rte_crypto_va_iova_ptr iv_ptr, digest_ptr;
 445         struct rte_crypto_vec vec[UINT8_MAX];
 446
 447         sop = op->sym;
 448
 449         n = rte_crypto_mbuf_to_vec(sop->m_src, sop->auth.data.offset,
 450                 sop->auth.data.length, vec, RTE_DIM(vec));
 451
 452         if (n < 0 || n != sop->m_src->nb_segs) {
 453                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 454                 return;
 455         }
 456
 457         sgl.vec = vec;
 458         sgl.num = n;
 459         symvec.src_sgl = &sgl;
 460         symvec.iv = &iv_ptr;
 461         symvec.digest = &digest_ptr;
 462         symvec.status = &st;
 463         symvec.num = 1;
 464
 465         iv_ptr.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 466         digest_ptr.va = (void *)sop->auth.digest.data;
 467
 468         ofs.raw = 0;
 469         ofs.ofs.cipher.head = sop->cipher.data.offset - sop->auth.data.offset;
 470         ofs.ofs.cipher.tail = (sop->auth.data.offset + sop->auth.data.length) -
 471                 (sop->cipher.data.offset + sop->cipher.data.length);
 472
 473         n = rte_cryptodev_sym_cpu_crypto_process(dev_id, sop->session, ofs,
 474                 &symvec);
 475
 476         if (n != 1)
 477                 op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
 478         else
 479                 op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
 480 }
 481
 482 static struct rte_crypto_op *
 483 process_crypto_request(uint8_t dev_id, struct rte_crypto_op *op)
 484 {
 485
 486         RTE_VERIFY(gbl_action_type != RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO);
 487
 488         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
 489                 RTE_LOG(ERR, USER1, "Error sending packet for encryption\n");
 490                 return NULL;
 491         }
 492
 493         op = NULL;
 494
 495         while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0)
 496                 rte_pause();
 497
 498         if (op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
 499                 RTE_LOG(DEBUG, USER1, "Operation status %d\n", op->status);
 500                 return NULL;
 501         }
 502
 503         return op;
 504 }
 505
 506 static struct crypto_testsuite_params testsuite_params = { NULL };
 507 struct crypto_testsuite_params *p_testsuite_params = &testsuite_params;
 508 static struct crypto_unittest_params unittest_params;
 509
 510 static int
 511 testsuite_setup(void)
 512 {
 513         struct crypto_testsuite_params *ts_params = &testsuite_params;
 514         struct rte_cryptodev_info info;
 515         uint32_t i = 0, nb_devs, dev_id;
 516         uint16_t qp_id;
 517
 518         memset(ts_params, 0, sizeof(*ts_params));
 519
 520         ts_params->mbuf_pool = rte_mempool_lookup("CRYPTO_MBUFPOOL");
 521         if (ts_params->mbuf_pool == NULL) {
 522                 /* Not already created so create */
 523                 ts_params->mbuf_pool = rte_pktmbuf_pool_create(
 524                                 "CRYPTO_MBUFPOOL",
 525                                 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
 526                                 rte_socket_id());
 527                 if (ts_params->mbuf_pool == NULL) {
 528                         RTE_LOG(ERR, USER1, "Can't create CRYPTO_MBUFPOOL\n");
 529                         return TEST_FAILED;
 530                 }
 531         }
 532
 533         ts_params->large_mbuf_pool = rte_mempool_lookup(
 534                         "CRYPTO_LARGE_MBUFPOOL");
 535         if (ts_params->large_mbuf_pool == NULL) {
 536                 /* Not already created so create */
 537                 ts_params->large_mbuf_pool = rte_pktmbuf_pool_create(
 538                                 "CRYPTO_LARGE_MBUFPOOL",
 539                                 1, 0, 0, UINT16_MAX,
 540                                 rte_socket_id());
 541                 if (ts_params->large_mbuf_pool == NULL) {
 542                         RTE_LOG(ERR, USER1,
 543                                 "Can't create CRYPTO_LARGE_MBUFPOOL\n");
 544                         return TEST_FAILED;
 545                 }
 546         }
 547
 548         ts_params->op_mpool = rte_crypto_op_pool_create(
 549                         "MBUF_CRYPTO_SYM_OP_POOL",
 550                         RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 551                         NUM_MBUFS, MBUF_CACHE_SIZE,
 552                         DEFAULT_NUM_XFORMS *
 553                         sizeof(struct rte_crypto_sym_xform) +
 554                         MAXIMUM_IV_LENGTH,
 555                         rte_socket_id());
 556         if (ts_params->op_mpool == NULL) {
 557                 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
 558                 return TEST_FAILED;
 559         }
 560
 561         nb_devs = rte_cryptodev_count();
 562         if (nb_devs < 1) {
 563                 RTE_LOG(WARNING, USER1, "No crypto devices found?\n");
 564                 return TEST_SKIPPED;
 565         }
 566
 567         if (rte_cryptodev_device_count_by_driver(gbl_driver_id) < 1) {
 568                 RTE_LOG(WARNING, USER1, "No %s devices found?\n",
 569                                 rte_cryptodev_driver_name_get(gbl_driver_id));
 570                 return TEST_SKIPPED;
 571         }
 572
 573         /* Create list of valid crypto devs */
 574         for (i = 0; i < nb_devs; i++) {
 575                 rte_cryptodev_info_get(i, &info);
 576                 if (info.driver_id == gbl_driver_id)
 577                         ts_params->valid_devs[ts_params->valid_dev_count++] = i;
 578         }
 579
 580         if (ts_params->valid_dev_count < 1)
 581                 return TEST_FAILED;
 582
 583         /* Set up all the qps on the first of the valid devices found */
 584
 585         dev_id = ts_params->valid_devs[0];
 586
 587         rte_cryptodev_info_get(dev_id, &info);
 588
 589         ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
 590         ts_params->conf.socket_id = SOCKET_ID_ANY;
 591         ts_params->conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY;
 592
 593         unsigned int session_size =
 594                 rte_cryptodev_sym_get_private_session_size(dev_id);
 595
 596 #ifdef RTE_LIB_SECURITY
 597         unsigned int security_session_size = rte_security_session_get_size(
 598                         rte_cryptodev_get_sec_ctx(dev_id));
 599
 600         if (session_size < security_session_size)
 601                 session_size = security_session_size;
 602 #endif
 603         /*
 604          * Create mempool with maximum number of sessions.
 605          */
 606         if (info.sym.max_nb_sessions != 0 &&
 607                         info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
 608                 RTE_LOG(ERR, USER1, "Device does not support "
 609                                 "at least %u sessions\n",
 610                                 MAX_NB_SESSIONS);
 611                 return TEST_FAILED;
 612         }
 613
 614         ts_params->session_mpool = rte_cryptodev_sym_session_pool_create(
 615                         "test_sess_mp", MAX_NB_SESSIONS, 0, 0, 0,
 616                         SOCKET_ID_ANY);
 617         TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
 618                         "session mempool allocation failed");
 619
 620         ts_params->session_priv_mpool = rte_mempool_create(
 621                         "test_sess_mp_priv",
 622                         MAX_NB_SESSIONS,
 623                         session_size,
 624                         0, 0, NULL, NULL, NULL,
 625                         NULL, SOCKET_ID_ANY,
 626                         0);
 627         TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
 628                         "session mempool allocation failed");
 629
 630
 631
 632         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id,
 633                         &ts_params->conf),
 634                         "Failed to configure cryptodev %u with %u qps",
 635                         dev_id, ts_params->conf.nb_queue_pairs);
 636
 637         ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
 638         ts_params->qp_conf.mp_session = ts_params->session_mpool;
 639         ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
 640
 641         for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) {
 642                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 643                         dev_id, qp_id, &ts_params->qp_conf,
 644                         rte_cryptodev_socket_id(dev_id)),
 645                         "Failed to setup queue pair %u on cryptodev %u",
 646                         qp_id, dev_id);
 647         }
 648
 649         return TEST_SUCCESS;
 650 }
 651
 652 static void
 653 testsuite_teardown(void)
 654 {
 655         struct crypto_testsuite_params *ts_params = &testsuite_params;
 656         int res;
 657
 658         if (ts_params->mbuf_pool != NULL) {
 659                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
 660                 rte_mempool_avail_count(ts_params->mbuf_pool));
 661         }
 662
 663         if (ts_params->op_mpool != NULL) {
 664                 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n",
 665                 rte_mempool_avail_count(ts_params->op_mpool));
 666         }
 667
 668         /* Free session mempools */
 669         if (ts_params->session_priv_mpool != NULL) {
 670                 rte_mempool_free(ts_params->session_priv_mpool);
 671                 ts_params->session_priv_mpool = NULL;
 672         }
 673
 674         if (ts_params->session_mpool != NULL) {
 675                 rte_mempool_free(ts_params->session_mpool);
 676                 ts_params->session_mpool = NULL;
 677         }
 678
 679         res = rte_cryptodev_close(ts_params->valid_devs[0]);
 680         if (res)
 681                 RTE_LOG(ERR, USER1, "Crypto device close error %d\n", res);
 682 }
 683
 684 static int
 685 check_capabilities_supported(enum rte_crypto_sym_xform_type type,
 686                 const int *algs, uint16_t num_algs)
 687 {
 688         uint8_t dev_id = testsuite_params.valid_devs[0];
 689         bool some_alg_supported = FALSE;
 690         uint16_t i;
 691
 692         for (i = 0; i < num_algs && !some_alg_supported; i++) {
 693                 struct rte_cryptodev_sym_capability_idx alg = {
 694                         type, {algs[i]}
 695                 };
 696                 if (rte_cryptodev_sym_capability_get(dev_id,
 697                                 &alg) != NULL)
 698                         some_alg_supported = TRUE;
 699         }
 700         if (!some_alg_supported)
 701                 return TEST_SKIPPED;
 702
 703         return 0;
 704 }
 705
 706 int
 707 check_cipher_capabilities_supported(const enum rte_crypto_cipher_algorithm *ciphers,
 708                 uint16_t num_ciphers)
 709 {
 710         return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_CIPHER,
 711                         (const int *) ciphers, num_ciphers);
 712 }
 713
 714 int
 715 check_auth_capabilities_supported(const enum rte_crypto_auth_algorithm *auths,
 716                 uint16_t num_auths)
 717 {
 718         return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_AUTH,
 719                         (const int *) auths, num_auths);
 720 }
 721
 722 int
 723 check_aead_capabilities_supported(const enum rte_crypto_aead_algorithm *aeads,
 724                 uint16_t num_aeads)
 725 {
 726         return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_AEAD,
 727                         (const int *) aeads, num_aeads);
 728 }
 729
 730 static int
 731 null_testsuite_setup(void)
 732 {
 733         struct crypto_testsuite_params *ts_params = &testsuite_params;
 734         uint8_t dev_id = ts_params->valid_devs[0];
 735         struct rte_cryptodev_info dev_info;
 736         const enum rte_crypto_cipher_algorithm ciphers[] = {
 737                 RTE_CRYPTO_CIPHER_NULL
 738         };
 739         const enum rte_crypto_auth_algorithm auths[] = {
 740                 RTE_CRYPTO_AUTH_NULL
 741         };
 742
 743         rte_cryptodev_info_get(dev_id, &dev_info);
 744
 745         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
 746                 RTE_LOG(INFO, USER1, "Feature flag requirements for NULL "
 747                                 "testsuite not met\n");
 748                 return TEST_SKIPPED;
 749         }
 750
 751         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
 752                         && check_auth_capabilities_supported(auths,
 753                         RTE_DIM(auths)) != 0) {
 754                 RTE_LOG(INFO, USER1, "Capability requirements for NULL "
 755                                 "testsuite not met\n");
 756                 return TEST_SKIPPED;
 757         }
 758
 759         return 0;
 760 }
 761
 762 static int
 763 crypto_gen_testsuite_setup(void)
 764 {
 765         struct crypto_testsuite_params *ts_params = &testsuite_params;
 766         uint8_t dev_id = ts_params->valid_devs[0];
 767         struct rte_cryptodev_info dev_info;
 768
 769         rte_cryptodev_info_get(dev_id, &dev_info);
 770
 771         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
 772                 RTE_LOG(INFO, USER1, "Feature flag requirements for Crypto Gen "
 773                                 "testsuite not met\n");
 774                 return TEST_SKIPPED;
 775         }
 776
 777         return 0;
 778 }
 779
 780 #ifdef RTE_LIB_SECURITY
 781 static int
 782 ipsec_proto_testsuite_setup(void)
 783 {
 784         struct crypto_testsuite_params *ts_params = &testsuite_params;
 785         struct crypto_unittest_params *ut_params = &unittest_params;
 786         struct rte_cryptodev_info dev_info;
 787         int ret = 0;
 788
 789         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 790
 791         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SECURITY)) {
 792                 RTE_LOG(INFO, USER1, "Feature flag requirements for IPsec Proto "
 793                                 "testsuite not met\n");
 794                 return TEST_SKIPPED;
 795         }
 796
 797         /* Reconfigure to enable security */
 798         ret = dev_configure_and_start(0);
 799         if (ret != TEST_SUCCESS)
 800                 return ret;
 801
 802         /* Set action type */
 803         ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
 804
 805         if (security_proto_supported(
 806                         RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
 807                         RTE_SECURITY_PROTOCOL_IPSEC) < 0) {
 808                 RTE_LOG(INFO, USER1, "Capability requirements for IPsec Proto "
 809                                 "test not met\n");
 810                 ret = TEST_SKIPPED;
 811         }
 812
 813         /*
 814          * Stop the device. Device would be started again by individual test
 815          * case setup routine.
 816          */
 817         rte_cryptodev_stop(ts_params->valid_devs[0]);
 818
 819         return ret;
 820 }
 821
 822 static int
 823 pdcp_proto_testsuite_setup(void)
 824 {
 825         struct crypto_testsuite_params *ts_params = &testsuite_params;
 826         uint8_t dev_id = ts_params->valid_devs[0];
 827         struct rte_cryptodev_info dev_info;
 828         const enum rte_crypto_cipher_algorithm ciphers[] = {
 829                 RTE_CRYPTO_CIPHER_NULL,
 830                 RTE_CRYPTO_CIPHER_AES_CTR,
 831                 RTE_CRYPTO_CIPHER_ZUC_EEA3,
 832                 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
 833         };
 834         const enum rte_crypto_auth_algorithm auths[] = {
 835                 RTE_CRYPTO_AUTH_NULL,
 836                 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
 837                 RTE_CRYPTO_AUTH_AES_CMAC,
 838                 RTE_CRYPTO_AUTH_ZUC_EIA3
 839         };
 840
 841         rte_cryptodev_info_get(dev_id, &dev_info);
 842
 843         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 844                         !(dev_info.feature_flags &
 845                         RTE_CRYPTODEV_FF_SECURITY)) {
 846                 RTE_LOG(INFO, USER1, "Feature flag requirements for PDCP Proto "
 847                                 "testsuite not met\n");
 848                 return TEST_SKIPPED;
 849         }
 850
 851         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
 852                         && check_auth_capabilities_supported(auths,
 853                         RTE_DIM(auths)) != 0) {
 854                 RTE_LOG(INFO, USER1, "Capability requirements for PDCP Proto "
 855                                 "testsuite not met\n");
 856                 return TEST_SKIPPED;
 857         }
 858
 859         return 0;
 860 }
 861
 862 static int
 863 docsis_proto_testsuite_setup(void)
 864 {
 865         struct crypto_testsuite_params *ts_params = &testsuite_params;
 866         uint8_t dev_id = ts_params->valid_devs[0];
 867         struct rte_cryptodev_info dev_info;
 868         const enum rte_crypto_cipher_algorithm ciphers[] = {
 869                 RTE_CRYPTO_CIPHER_AES_DOCSISBPI
 870         };
 871
 872         rte_cryptodev_info_get(dev_id, &dev_info);
 873
 874         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 875                         !(dev_info.feature_flags &
 876                         RTE_CRYPTODEV_FF_SECURITY)) {
 877                 RTE_LOG(INFO, USER1, "Feature flag requirements for Docsis "
 878                                 "Proto testsuite not met\n");
 879                 return TEST_SKIPPED;
 880         }
 881
 882         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0) {
 883                 RTE_LOG(INFO, USER1, "Capability requirements for Docsis Proto "
 884                                 "testsuite not met\n");
 885                 return TEST_SKIPPED;
 886         }
 887
 888         return 0;
 889 }
 890 #endif
 891
 892 static int
 893 aes_ccm_auth_testsuite_setup(void)
 894 {
 895         struct crypto_testsuite_params *ts_params = &testsuite_params;
 896         uint8_t dev_id = ts_params->valid_devs[0];
 897         struct rte_cryptodev_info dev_info;
 898         const enum rte_crypto_aead_algorithm aeads[] = {
 899                 RTE_CRYPTO_AEAD_AES_CCM
 900         };
 901
 902         rte_cryptodev_info_get(dev_id, &dev_info);
 903
 904         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 905                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
 906                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
 907                 RTE_LOG(INFO, USER1, "Feature flag requirements for AES CCM "
 908                                 "testsuite not met\n");
 909                 return TEST_SKIPPED;
 910         }
 911
 912         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
 913                 RTE_LOG(INFO, USER1, "Capability requirements for AES CCM "
 914                                 "testsuite not met\n");
 915                 return TEST_SKIPPED;
 916         }
 917
 918         return 0;
 919 }
 920
 921 static int
 922 aes_gcm_auth_testsuite_setup(void)
 923 {
 924         struct crypto_testsuite_params *ts_params = &testsuite_params;
 925         uint8_t dev_id = ts_params->valid_devs[0];
 926         struct rte_cryptodev_info dev_info;
 927         const enum rte_crypto_aead_algorithm aeads[] = {
 928                 RTE_CRYPTO_AEAD_AES_GCM
 929         };
 930
 931         rte_cryptodev_info_get(dev_id, &dev_info);
 932
 933         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
 934                 RTE_LOG(INFO, USER1, "Feature flag requirements for AES GCM "
 935                                 "testsuite not met\n");
 936                 return TEST_SKIPPED;
 937         }
 938
 939         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
 940                 RTE_LOG(INFO, USER1, "Capability requirements for AES GCM "
 941                                 "testsuite not met\n");
 942                 return TEST_SKIPPED;
 943         }
 944
 945         return 0;
 946 }
 947
 948 static int
 949 aes_gmac_auth_testsuite_setup(void)
 950 {
 951         struct crypto_testsuite_params *ts_params = &testsuite_params;
 952         uint8_t dev_id = ts_params->valid_devs[0];
 953         struct rte_cryptodev_info dev_info;
 954         const enum rte_crypto_auth_algorithm auths[] = {
 955                 RTE_CRYPTO_AUTH_AES_GMAC
 956         };
 957
 958         rte_cryptodev_info_get(dev_id, &dev_info);
 959
 960         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 961                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
 962                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
 963                 RTE_LOG(INFO, USER1, "Feature flag requirements for AES GMAC "
 964                                 "testsuite not met\n");
 965                 return TEST_SKIPPED;
 966         }
 967
 968         if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
 969                 RTE_LOG(INFO, USER1, "Capability requirements for AES GMAC "
 970                                 "testsuite not met\n");
 971                 return TEST_SKIPPED;
 972         }
 973
 974         return 0;
 975 }
 976
 977 static int
 978 chacha20_poly1305_testsuite_setup(void)
 979 {
 980         struct crypto_testsuite_params *ts_params = &testsuite_params;
 981         uint8_t dev_id = ts_params->valid_devs[0];
 982         struct rte_cryptodev_info dev_info;
 983         const enum rte_crypto_aead_algorithm aeads[] = {
 984                 RTE_CRYPTO_AEAD_CHACHA20_POLY1305
 985         };
 986
 987         rte_cryptodev_info_get(dev_id, &dev_info);
 988
 989         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 990                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
 991                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
 992                 RTE_LOG(INFO, USER1, "Feature flag requirements for "
 993                                 "Chacha20-Poly1305 testsuite not met\n");
 994                 return TEST_SKIPPED;
 995         }
 996
 997         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
 998                 RTE_LOG(INFO, USER1, "Capability requirements for "
 999                                 "Chacha20-Poly1305 testsuite not met\n");
1000                 return TEST_SKIPPED;
1001         }
1002
1003         return 0;
1004 }
1005
1006 static int
1007 snow3g_testsuite_setup(void)
1008 {
1009         struct crypto_testsuite_params *ts_params = &testsuite_params;
1010         uint8_t dev_id = ts_params->valid_devs[0];
1011         struct rte_cryptodev_info dev_info;
1012         const enum rte_crypto_cipher_algorithm ciphers[] = {
1013                 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
1014
1015         };
1016         const enum rte_crypto_auth_algorithm auths[] = {
1017                 RTE_CRYPTO_AUTH_SNOW3G_UIA2
1018         };
1019
1020         rte_cryptodev_info_get(dev_id, &dev_info);
1021
1022         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1023                 RTE_LOG(INFO, USER1, "Feature flag requirements for Snow3G "
1024                                 "testsuite not met\n");
1025                 return TEST_SKIPPED;
1026         }
1027
1028         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1029                         && check_auth_capabilities_supported(auths,
1030                         RTE_DIM(auths)) != 0) {
1031                 RTE_LOG(INFO, USER1, "Capability requirements for Snow3G "
1032                                 "testsuite not met\n");
1033                 return TEST_SKIPPED;
1034         }
1035
1036         return 0;
1037 }
1038
1039 static int
1040 zuc_testsuite_setup(void)
1041 {
1042         struct crypto_testsuite_params *ts_params = &testsuite_params;
1043         uint8_t dev_id = ts_params->valid_devs[0];
1044         struct rte_cryptodev_info dev_info;
1045         const enum rte_crypto_cipher_algorithm ciphers[] = {
1046                 RTE_CRYPTO_CIPHER_ZUC_EEA3
1047         };
1048         const enum rte_crypto_auth_algorithm auths[] = {
1049                 RTE_CRYPTO_AUTH_ZUC_EIA3
1050         };
1051
1052         rte_cryptodev_info_get(dev_id, &dev_info);
1053
1054         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1055                 RTE_LOG(INFO, USER1, "Feature flag requirements for ZUC "
1056                                 "testsuite not met\n");
1057                 return TEST_SKIPPED;
1058         }
1059
1060         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1061                         && check_auth_capabilities_supported(auths,
1062                         RTE_DIM(auths)) != 0) {
1063                 RTE_LOG(INFO, USER1, "Capability requirements for ZUC "
1064                                 "testsuite not met\n");
1065                 return TEST_SKIPPED;
1066         }
1067
1068         return 0;
1069 }
1070
1071 static int
1072 hmac_md5_auth_testsuite_setup(void)
1073 {
1074         struct crypto_testsuite_params *ts_params = &testsuite_params;
1075         uint8_t dev_id = ts_params->valid_devs[0];
1076         struct rte_cryptodev_info dev_info;
1077         const enum rte_crypto_auth_algorithm auths[] = {
1078                 RTE_CRYPTO_AUTH_MD5_HMAC
1079         };
1080
1081         rte_cryptodev_info_get(dev_id, &dev_info);
1082
1083         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1084                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1085                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1086                 RTE_LOG(INFO, USER1, "Feature flag requirements for HMAC MD5 "
1087                                 "Auth testsuite not met\n");
1088                 return TEST_SKIPPED;
1089         }
1090
1091         if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
1092                 RTE_LOG(INFO, USER1, "Capability requirements for HMAC MD5 "
1093                                 "testsuite not met\n");
1094                 return TEST_SKIPPED;
1095         }
1096
1097         return 0;
1098 }
1099
1100 static int
1101 kasumi_testsuite_setup(void)
1102 {
1103         struct crypto_testsuite_params *ts_params = &testsuite_params;
1104         uint8_t dev_id = ts_params->valid_devs[0];
1105         struct rte_cryptodev_info dev_info;
1106         const enum rte_crypto_cipher_algorithm ciphers[] = {
1107                 RTE_CRYPTO_CIPHER_KASUMI_F8
1108         };
1109         const enum rte_crypto_auth_algorithm auths[] = {
1110                 RTE_CRYPTO_AUTH_KASUMI_F9
1111         };
1112
1113         rte_cryptodev_info_get(dev_id, &dev_info);
1114
1115         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1116                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1117                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1118                 RTE_LOG(INFO, USER1, "Feature flag requirements for Kasumi "
1119                                 "testsuite not met\n");
1120                 return TEST_SKIPPED;
1121         }
1122
1123         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1124                         && check_auth_capabilities_supported(auths,
1125                         RTE_DIM(auths)) != 0) {
1126                 RTE_LOG(INFO, USER1, "Capability requirements for Kasumi "
1127                                 "testsuite not met\n");
1128                 return TEST_SKIPPED;
1129         }
1130
1131         return 0;
1132 }
1133
1134 static int
1135 negative_aes_gcm_testsuite_setup(void)
1136 {
1137         struct crypto_testsuite_params *ts_params = &testsuite_params;
1138         uint8_t dev_id = ts_params->valid_devs[0];
1139         struct rte_cryptodev_info dev_info;
1140         const enum rte_crypto_aead_algorithm aeads[] = {
1141                 RTE_CRYPTO_AEAD_AES_GCM
1142         };
1143
1144         rte_cryptodev_info_get(dev_id, &dev_info);
1145
1146         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1147                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1148                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1149                 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1150                                 "AES GCM testsuite not met\n");
1151                 return TEST_SKIPPED;
1152         }
1153
1154         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
1155                 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1156                                 "AES GCM testsuite not met\n");
1157                 return TEST_SKIPPED;
1158         }
1159
1160         return 0;
1161 }
1162
1163 static int
1164 negative_aes_gmac_testsuite_setup(void)
1165 {
1166         struct crypto_testsuite_params *ts_params = &testsuite_params;
1167         uint8_t dev_id = ts_params->valid_devs[0];
1168         struct rte_cryptodev_info dev_info;
1169         const enum rte_crypto_auth_algorithm auths[] = {
1170                 RTE_CRYPTO_AUTH_AES_GMAC
1171         };
1172
1173         rte_cryptodev_info_get(dev_id, &dev_info);
1174
1175         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1176                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1177                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1178                 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1179                                 "AES GMAC testsuite not met\n");
1180                 return TEST_SKIPPED;
1181         }
1182
1183         if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
1184                 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1185                                 "AES GMAC testsuite not met\n");
1186                 return TEST_SKIPPED;
1187         }
1188
1189         return 0;
1190 }
1191
1192 static int
1193 mixed_cipher_hash_testsuite_setup(void)
1194 {
1195         struct crypto_testsuite_params *ts_params = &testsuite_params;
1196         uint8_t dev_id = ts_params->valid_devs[0];
1197         struct rte_cryptodev_info dev_info;
1198         uint64_t feat_flags;
1199         const enum rte_crypto_cipher_algorithm ciphers[] = {
1200                 RTE_CRYPTO_CIPHER_NULL,
1201                 RTE_CRYPTO_CIPHER_AES_CTR,
1202                 RTE_CRYPTO_CIPHER_ZUC_EEA3,
1203                 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
1204         };
1205         const enum rte_crypto_auth_algorithm auths[] = {
1206                 RTE_CRYPTO_AUTH_NULL,
1207                 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
1208                 RTE_CRYPTO_AUTH_AES_CMAC,
1209                 RTE_CRYPTO_AUTH_ZUC_EIA3
1210         };
1211
1212         rte_cryptodev_info_get(dev_id, &dev_info);
1213         feat_flags = dev_info.feature_flags;
1214
1215         if (!(feat_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1216                         (global_api_test_type == CRYPTODEV_RAW_API_TEST)) {
1217                 RTE_LOG(INFO, USER1, "Feature flag requirements for Mixed "
1218                                 "Cipher Hash testsuite not met\n");
1219                 return TEST_SKIPPED;
1220         }
1221
1222         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1223                         && check_auth_capabilities_supported(auths,
1224                         RTE_DIM(auths)) != 0) {
1225                 RTE_LOG(INFO, USER1, "Capability requirements for Mixed "
1226                                 "Cipher Hash testsuite not met\n");
1227                 return TEST_SKIPPED;
1228         }
1229
1230         return 0;
1231 }
1232
1233 static int
1234 esn_testsuite_setup(void)
1235 {
1236         struct crypto_testsuite_params *ts_params = &testsuite_params;
1237         uint8_t dev_id = ts_params->valid_devs[0];
1238         struct rte_cryptodev_info dev_info;
1239         const enum rte_crypto_cipher_algorithm ciphers[] = {
1240                 RTE_CRYPTO_CIPHER_AES_CBC
1241         };
1242         const enum rte_crypto_auth_algorithm auths[] = {
1243                 RTE_CRYPTO_AUTH_SHA1_HMAC
1244         };
1245
1246         rte_cryptodev_info_get(dev_id, &dev_info);
1247
1248         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1249                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1250                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1251                 RTE_LOG(INFO, USER1, "Feature flag requirements for ESN "
1252                                 "testsuite not met\n");
1253                 return TEST_SKIPPED;
1254         }
1255
1256         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1257                         && check_auth_capabilities_supported(auths,
1258                         RTE_DIM(auths)) != 0) {
1259                 RTE_LOG(INFO, USER1, "Capability requirements for ESN "
1260                                 "testsuite not met\n");
1261                 return TEST_SKIPPED;
1262         }
1263
1264         return 0;
1265 }
1266
1267 static int
1268 multi_session_testsuite_setup(void)
1269 {
1270         struct crypto_testsuite_params *ts_params = &testsuite_params;
1271         uint8_t dev_id = ts_params->valid_devs[0];
1272         struct rte_cryptodev_info dev_info;
1273         const enum rte_crypto_cipher_algorithm ciphers[] = {
1274                 RTE_CRYPTO_CIPHER_AES_CBC
1275         };
1276         const enum rte_crypto_auth_algorithm auths[] = {
1277                 RTE_CRYPTO_AUTH_SHA512_HMAC
1278         };
1279
1280         rte_cryptodev_info_get(dev_id, &dev_info);
1281
1282         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1283                 RTE_LOG(INFO, USER1, "Feature flag requirements for Multi "
1284                                 "Session testsuite not met\n");
1285                 return TEST_SKIPPED;
1286         }
1287
1288         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1289                         && check_auth_capabilities_supported(auths,
1290                         RTE_DIM(auths)) != 0) {
1291                 RTE_LOG(INFO, USER1, "Capability requirements for Multi "
1292                                 "Session testsuite not met\n");
1293                 return TEST_SKIPPED;
1294         }
1295
1296         return 0;
1297 }
1298
1299 static int
1300 negative_hmac_sha1_testsuite_setup(void)
1301 {
1302         struct crypto_testsuite_params *ts_params = &testsuite_params;
1303         uint8_t dev_id = ts_params->valid_devs[0];
1304         struct rte_cryptodev_info dev_info;
1305         const enum rte_crypto_cipher_algorithm ciphers[] = {
1306                 RTE_CRYPTO_CIPHER_AES_CBC
1307         };
1308         const enum rte_crypto_auth_algorithm auths[] = {
1309                 RTE_CRYPTO_AUTH_SHA1_HMAC
1310         };
1311
1312         rte_cryptodev_info_get(dev_id, &dev_info);
1313
1314         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1315                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1316                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1317                 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1318                                 "HMAC SHA1 testsuite not met\n");
1319                 return TEST_SKIPPED;
1320         }
1321
1322         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1323                         && check_auth_capabilities_supported(auths,
1324                         RTE_DIM(auths)) != 0) {
1325                 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1326                                 "HMAC SHA1 testsuite not met\n");
1327                 return TEST_SKIPPED;
1328         }
1329
1330         return 0;
1331 }
1332
1333 static int
1334 dev_configure_and_start(uint64_t ff_disable)
1335 {
1336         struct crypto_testsuite_params *ts_params = &testsuite_params;
1337         struct crypto_unittest_params *ut_params = &unittest_params;
1338
1339         uint16_t qp_id;
1340
1341         /* Clear unit test parameters before running test */
1342         memset(ut_params, 0, sizeof(*ut_params));
1343
1344         /* Reconfigure device to default parameters */
1345         ts_params->conf.socket_id = SOCKET_ID_ANY;
1346         ts_params->conf.ff_disable = ff_disable;
1347         ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
1348         ts_params->qp_conf.mp_session = ts_params->session_mpool;
1349         ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
1350
1351         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1352                         &ts_params->conf),
1353                         "Failed to configure cryptodev %u",
1354                         ts_params->valid_devs[0]);
1355
1356         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
1357                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1358                         ts_params->valid_devs[0], qp_id,
1359                         &ts_params->qp_conf,
1360                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1361                         "Failed to setup queue pair %u on cryptodev %u",
1362                         qp_id, ts_params->valid_devs[0]);
1363         }
1364
1365
1366         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
1367
1368         /* Start the device */
1369         TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
1370                         "Failed to start cryptodev %u",
1371                         ts_params->valid_devs[0]);
1372
1373         return TEST_SUCCESS;
1374 }
1375
1376 int
1377 ut_setup(void)
1378 {
1379         /* Configure and start the device with security feature disabled */
1380         return dev_configure_and_start(RTE_CRYPTODEV_FF_SECURITY);
1381 }
1382
1383 static int
1384 ut_setup_security(void)
1385 {
1386         /* Configure and start the device with no features disabled */
1387         return dev_configure_and_start(0);
1388 }
1389
1390 void
1391 ut_teardown(void)
1392 {
1393         struct crypto_testsuite_params *ts_params = &testsuite_params;
1394         struct crypto_unittest_params *ut_params = &unittest_params;
1395         struct rte_cryptodev_stats stats;
1396
1397         /* free crypto session structure */
1398 #ifdef RTE_LIB_SECURITY
1399         if (ut_params->type == RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL) {
1400                 if (ut_params->sec_session) {
1401                         rte_security_session_destroy(rte_cryptodev_get_sec_ctx
1402                                                 (ts_params->valid_devs[0]),
1403                                                 ut_params->sec_session);
1404                         ut_params->sec_session = NULL;
1405                 }
1406         } else
1407 #endif
1408         {
1409                 if (ut_params->sess) {
1410                         rte_cryptodev_sym_session_clear(
1411                                         ts_params->valid_devs[0],
1412                                         ut_params->sess);
1413                         rte_cryptodev_sym_session_free(ut_params->sess);
1414                         ut_params->sess = NULL;
1415                 }
1416         }
1417
1418         /* free crypto operation structure */
1419         if (ut_params->op)
1420                 rte_crypto_op_free(ut_params->op);
1421
1422         /*
1423          * free mbuf - both obuf and ibuf are usually the same,
1424          * so check if they point at the same address is necessary,
1425          * to avoid freeing the mbuf twice.
1426          */
1427         if (ut_params->obuf) {
1428                 rte_pktmbuf_free(ut_params->obuf);
1429                 if (ut_params->ibuf == ut_params->obuf)
1430                         ut_params->ibuf = 0;
1431                 ut_params->obuf = 0;
1432         }
1433         if (ut_params->ibuf) {
1434                 rte_pktmbuf_free(ut_params->ibuf);
1435                 ut_params->ibuf = 0;
1436         }
1437
1438         if (ts_params->mbuf_pool != NULL)
1439                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
1440                         rte_mempool_avail_count(ts_params->mbuf_pool));
1441
1442         rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats);
1443
1444         /* Stop the device */
1445         rte_cryptodev_stop(ts_params->valid_devs[0]);
1446 }
1447
1448 static int
1449 test_device_configure_invalid_dev_id(void)
1450 {
1451         struct crypto_testsuite_params *ts_params = &testsuite_params;
1452         uint16_t dev_id, num_devs = 0;
1453
1454         TEST_ASSERT((num_devs = rte_cryptodev_count()) >= 1,
1455                         "Need at least %d devices for test", 1);
1456
1457         /* valid dev_id values */
1458         dev_id = ts_params->valid_devs[0];
1459
1460         /* Stop the device in case it's started so it can be configured */
1461         rte_cryptodev_stop(dev_id);
1462
1463         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf),
1464                         "Failed test for rte_cryptodev_configure: "
1465                         "invalid dev_num %u", dev_id);
1466
1467         /* invalid dev_id values */
1468         dev_id = num_devs;
1469
1470         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
1471                         "Failed test for rte_cryptodev_configure: "
1472                         "invalid dev_num %u", dev_id);
1473
1474         dev_id = 0xff;
1475
1476         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
1477                         "Failed test for rte_cryptodev_configure:"
1478                         "invalid dev_num %u", dev_id);
1479
1480         return TEST_SUCCESS;
1481 }
1482
1483 static int
1484 test_device_configure_invalid_queue_pair_ids(void)
1485 {
1486         struct crypto_testsuite_params *ts_params = &testsuite_params;
1487         uint16_t orig_nb_qps = ts_params->conf.nb_queue_pairs;
1488
1489         /* Stop the device in case it's started so it can be configured */
1490         rte_cryptodev_stop(ts_params->valid_devs[0]);
1491
1492         /* valid - max value queue pairs */
1493         ts_params->conf.nb_queue_pairs = orig_nb_qps;
1494
1495         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1496                         &ts_params->conf),
1497                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
1498                         ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
1499
1500         /* valid - one queue pairs */
1501         ts_params->conf.nb_queue_pairs = 1;
1502
1503         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1504                         &ts_params->conf),
1505                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
1506                         ts_params->valid_devs[0],
1507                         ts_params->conf.nb_queue_pairs);
1508
1509
1510         /* invalid - zero queue pairs */
1511         ts_params->conf.nb_queue_pairs = 0;
1512
1513         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1514                         &ts_params->conf),
1515                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1516                         " invalid qps: %u",
1517                         ts_params->valid_devs[0],
1518                         ts_params->conf.nb_queue_pairs);
1519
1520
1521         /* invalid - max value supported by field queue pairs */
1522         ts_params->conf.nb_queue_pairs = UINT16_MAX;
1523
1524         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1525                         &ts_params->conf),
1526                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1527                         " invalid qps: %u",
1528                         ts_params->valid_devs[0],
1529                         ts_params->conf.nb_queue_pairs);
1530
1531
1532         /* invalid - max value + 1 queue pairs */
1533         ts_params->conf.nb_queue_pairs = orig_nb_qps + 1;
1534
1535         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1536                         &ts_params->conf),
1537                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1538                         " invalid qps: %u",
1539                         ts_params->valid_devs[0],
1540                         ts_params->conf.nb_queue_pairs);
1541
1542         /* revert to original testsuite value */
1543         ts_params->conf.nb_queue_pairs = orig_nb_qps;
1544
1545         return TEST_SUCCESS;
1546 }
1547
1548 static int
1549 test_queue_pair_descriptor_setup(void)
1550 {
1551         struct crypto_testsuite_params *ts_params = &testsuite_params;
1552         struct rte_cryptodev_qp_conf qp_conf = {
1553                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
1554         };
1555         uint16_t qp_id;
1556
1557         /* Stop the device in case it's started so it can be configured */
1558         rte_cryptodev_stop(ts_params->valid_devs[0]);
1559
1560         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1561                         &ts_params->conf),
1562                         "Failed to configure cryptodev %u",
1563                         ts_params->valid_devs[0]);
1564
1565         /*
1566          * Test various ring sizes on this device. memzones can't be
1567          * freed so are re-used if ring is released and re-created.
1568          */
1569         qp_conf.nb_descriptors = MIN_NUM_OPS_INFLIGHT; /* min size*/
1570         qp_conf.mp_session = ts_params->session_mpool;
1571         qp_conf.mp_session_private = ts_params->session_priv_mpool;
1572
1573         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1574                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1575                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1576                                 rte_cryptodev_socket_id(
1577                                                 ts_params->valid_devs[0])),
1578                                 "Failed test for "
1579                                 "rte_cryptodev_queue_pair_setup: num_inflights "
1580                                 "%u on qp %u on cryptodev %u",
1581                                 qp_conf.nb_descriptors, qp_id,
1582                                 ts_params->valid_devs[0]);
1583         }
1584
1585         qp_conf.nb_descriptors = (uint32_t)(MAX_NUM_OPS_INFLIGHT / 2);
1586
1587         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1588                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1589                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1590                                 rte_cryptodev_socket_id(
1591                                                 ts_params->valid_devs[0])),
1592                                 "Failed test for"
1593                                 " rte_cryptodev_queue_pair_setup: num_inflights"
1594                                 " %u on qp %u on cryptodev %u",
1595                                 qp_conf.nb_descriptors, qp_id,
1596                                 ts_params->valid_devs[0]);
1597         }
1598
1599         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; /* valid */
1600
1601         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1602                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1603                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1604                                 rte_cryptodev_socket_id(
1605                                                 ts_params->valid_devs[0])),
1606                                 "Failed test for "
1607                                 "rte_cryptodev_queue_pair_setup: num_inflights"
1608                                 " %u on qp %u on cryptodev %u",
1609                                 qp_conf.nb_descriptors, qp_id,
1610                                 ts_params->valid_devs[0]);
1611         }
1612
1613         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
1614
1615         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1616                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1617                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1618                                 rte_cryptodev_socket_id(
1619                                                 ts_params->valid_devs[0])),
1620                                 "Failed test for"
1621                                 " rte_cryptodev_queue_pair_setup:"
1622                                 "num_inflights %u on qp %u on cryptodev %u",
1623                                 qp_conf.nb_descriptors, qp_id,
1624                                 ts_params->valid_devs[0]);
1625         }
1626
1627         /* test invalid queue pair id */
1628         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;      /*valid */
1629
1630         qp_id = ts_params->conf.nb_queue_pairs;         /*invalid */
1631
1632         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
1633                         ts_params->valid_devs[0],
1634                         qp_id, &qp_conf,
1635                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1636                         "Failed test for rte_cryptodev_queue_pair_setup:"
1637                         "invalid qp %u on cryptodev %u",
1638                         qp_id, ts_params->valid_devs[0]);
1639
1640         qp_id = 0xffff; /*invalid*/
1641
1642         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
1643                         ts_params->valid_devs[0],
1644                         qp_id, &qp_conf,
1645                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1646                         "Failed test for rte_cryptodev_queue_pair_setup:"
1647                         "invalid qp %u on cryptodev %u",
1648                         qp_id, ts_params->valid_devs[0]);
1649
1650         return TEST_SUCCESS;
1651 }
1652
1653 /* ***** Plaintext data for tests ***** */
1654
1655 const char catch_22_quote_1[] =
1656                 "There was only one catch and that was Catch-22, which "
1657                 "specified that a concern for one's safety in the face of "
1658                 "dangers that were real and immediate was the process of a "
1659                 "rational mind. Orr was crazy and could be grounded. All he "
1660                 "had to do was ask; and as soon as he did, he would no longer "
1661                 "be crazy and would have to fly more missions. Orr would be "
1662                 "crazy to fly more missions and sane if he didn't, but if he "
1663                 "was sane he had to fly them. If he flew them he was crazy "
1664                 "and didn't have to; but if he didn't want to he was sane and "
1665                 "had to. Yossarian was moved very deeply by the absolute "
1666                 "simplicity of this clause of Catch-22 and let out a "
1667                 "respectful whistle. \"That's some catch, that Catch-22\", he "
1668                 "observed. \"It's the best there is,\" Doc Daneeka agreed.";
1669
1670 const char catch_22_quote[] =
1671                 "What a lousy earth! He wondered how many people were "
1672                 "destitute that same night even in his own prosperous country, "
1673                 "how many homes were shanties, how many husbands were drunk "
1674                 "and wives socked, and how many children were bullied, abused, "
1675                 "or abandoned. How many families hungered for food they could "
1676                 "not afford to buy? How many hearts were broken? How many "
1677                 "suicides would take place that same night, how many people "
1678                 "would go insane? How many cockroaches and landlords would "
1679                 "triumph? How many winners were losers, successes failures, "
1680                 "and rich men poor men? How many wise guys were stupid? How "
1681                 "many happy endings were unhappy endings? How many honest men "
1682                 "were liars, brave men cowards, loyal men traitors, how many "
1683                 "sainted men were corrupt, how many people in positions of "
1684                 "trust had sold their souls to bodyguards, how many had never "
1685                 "had souls? How many straight-and-narrow paths were crooked "
1686                 "paths? How many best families were worst families and how "
1687                 "many good people were bad people? When you added them all up "
1688                 "and then subtracted, you might be left with only the children, "
1689                 "and perhaps with Albert Einstein and an old violinist or "
1690                 "sculptor somewhere.";
1691
1692 #define QUOTE_480_BYTES         (480)
1693 #define QUOTE_512_BYTES         (512)
1694 #define QUOTE_768_BYTES         (768)
1695 #define QUOTE_1024_BYTES        (1024)
1696
1697
1698
1699 /* ***** SHA1 Hash Tests ***** */
1700
1701 #define HMAC_KEY_LENGTH_SHA1    (DIGEST_BYTE_LENGTH_SHA1)
1702
1703 static uint8_t hmac_sha1_key[] = {
1704         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
1705         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
1706         0xDE, 0xF4, 0xDE, 0xAD };
1707
1708 /* ***** SHA224 Hash Tests ***** */
1709
1710 #define HMAC_KEY_LENGTH_SHA224  (DIGEST_BYTE_LENGTH_SHA224)
1711
1712
1713 /* ***** AES-CBC Cipher Tests ***** */
1714
1715 #define CIPHER_KEY_LENGTH_AES_CBC       (16)
1716 #define CIPHER_IV_LENGTH_AES_CBC        (CIPHER_KEY_LENGTH_AES_CBC)
1717
1718 static uint8_t aes_cbc_key[] = {
1719         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
1720         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A };
1721
1722 static uint8_t aes_cbc_iv[] = {
1723         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1724         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
1725
1726
1727 /* ***** AES-CBC / HMAC-SHA1 Hash Tests ***** */
1728
1729 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_ciphertext[] = {
1730         0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31,
1731         0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76,
1732         0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E,
1733         0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A,
1734         0x3F, 0x6B, 0x5D, 0xDF, 0x52, 0x85, 0x5F, 0x8E,
1735         0x42, 0x3C, 0xFB, 0xE9, 0x1A, 0x24, 0xD6, 0x08,
1736         0xDD, 0xFD, 0x16, 0xFB, 0xE9, 0x55, 0xEF, 0xF0,
1737         0xA0, 0x8D, 0x13, 0xAB, 0x81, 0xC6, 0x90, 0x01,
1738         0xB5, 0x18, 0x84, 0xB3, 0xF6, 0xE6, 0x11, 0x57,
1739         0xD6, 0x71, 0xC6, 0x3C, 0x3F, 0x2F, 0x33, 0xEE,
1740         0x24, 0x42, 0x6E, 0xAC, 0x0B, 0xCA, 0xEC, 0xF9,
1741         0x84, 0xF8, 0x22, 0xAA, 0x60, 0xF0, 0x32, 0xA9,
1742         0x75, 0x75, 0x3B, 0xCB, 0x70, 0x21, 0x0A, 0x8D,
1743         0x0F, 0xE0, 0xC4, 0x78, 0x2B, 0xF8, 0x97, 0xE3,
1744         0xE4, 0x26, 0x4B, 0x29, 0xDA, 0x88, 0xCD, 0x46,
1745         0xEC, 0xAA, 0xF9, 0x7F, 0xF1, 0x15, 0xEA, 0xC3,
1746         0x87, 0xE6, 0x31, 0xF2, 0xCF, 0xDE, 0x4D, 0x80,
1747         0x70, 0x91, 0x7E, 0x0C, 0xF7, 0x26, 0x3A, 0x92,
1748         0x4F, 0x18, 0x83, 0xC0, 0x8F, 0x59, 0x01, 0xA5,
1749         0x88, 0xD1, 0xDB, 0x26, 0x71, 0x27, 0x16, 0xF5,
1750         0xEE, 0x10, 0x82, 0xAC, 0x68, 0x26, 0x9B, 0xE2,
1751         0x6D, 0xD8, 0x9A, 0x80, 0xDF, 0x04, 0x31, 0xD5,
1752         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1753         0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
1754         0x73, 0x02, 0x42, 0xC9, 0x23, 0x18, 0x8E, 0xB4,
1755         0x6F, 0xB4, 0xA3, 0x54, 0x6E, 0x88, 0x3B, 0x62,
1756         0x7C, 0x02, 0x8D, 0x4C, 0x9F, 0xC8, 0x45, 0xF4,
1757         0xC9, 0xDE, 0x4F, 0xEB, 0x22, 0x83, 0x1B, 0xE4,
1758         0x49, 0x37, 0xE4, 0xAD, 0xE7, 0xCD, 0x21, 0x54,
1759         0xBC, 0x1C, 0xC2, 0x04, 0x97, 0xB4, 0x10, 0x61,
1760         0xF0, 0xE4, 0xEF, 0x27, 0x63, 0x3A, 0xDA, 0x91,
1761         0x41, 0x25, 0x62, 0x1C, 0x5C, 0xB6, 0x38, 0x4A,
1762         0x88, 0x71, 0x59, 0x5A, 0x8D, 0xA0, 0x09, 0xAF,
1763         0x72, 0x94, 0xD7, 0x79, 0x5C, 0x60, 0x7C, 0x8F,
1764         0x4C, 0xF5, 0xD9, 0xA1, 0x39, 0x6D, 0x81, 0x28,
1765         0xEF, 0x13, 0x28, 0xDF, 0xF5, 0x3E, 0xF7, 0x8E,
1766         0x09, 0x9C, 0x78, 0x18, 0x79, 0xB8, 0x68, 0xD7,
1767         0xA8, 0x29, 0x62, 0xAD, 0xDE, 0xE1, 0x61, 0x76,
1768         0x1B, 0x05, 0x16, 0xCD, 0xBF, 0x02, 0x8E, 0xA6,
1769         0x43, 0x6E, 0x92, 0x55, 0x4F, 0x60, 0x9C, 0x03,
1770         0xB8, 0x4F, 0xA3, 0x02, 0xAC, 0xA8, 0xA7, 0x0C,
1771         0x1E, 0xB5, 0x6B, 0xF8, 0xC8, 0x4D, 0xDE, 0xD2,
1772         0xB0, 0x29, 0x6E, 0x40, 0xE6, 0xD6, 0xC9, 0xE6,
1773         0xB9, 0x0F, 0xB6, 0x63, 0xF5, 0xAA, 0x2B, 0x96,
1774         0xA7, 0x16, 0xAC, 0x4E, 0x0A, 0x33, 0x1C, 0xA6,
1775         0xE6, 0xBD, 0x8A, 0xCF, 0x40, 0xA9, 0xB2, 0xFA,
1776         0x63, 0x27, 0xFD, 0x9B, 0xD9, 0xFC, 0xD5, 0x87,
1777         0x8D, 0x4C, 0xB6, 0xA4, 0xCB, 0xE7, 0x74, 0x55,
1778         0xF4, 0xFB, 0x41, 0x25, 0xB5, 0x4B, 0x0A, 0x1B,
1779         0xB1, 0xD6, 0xB7, 0xD9, 0x47, 0x2A, 0xC3, 0x98,
1780         0x6A, 0xC4, 0x03, 0x73, 0x1F, 0x93, 0x6E, 0x53,
1781         0x19, 0x25, 0x64, 0x15, 0x83, 0xF9, 0x73, 0x2A,
1782         0x74, 0xB4, 0x93, 0x69, 0xC4, 0x72, 0xFC, 0x26,
1783         0xA2, 0x9F, 0x43, 0x45, 0xDD, 0xB9, 0xEF, 0x36,
1784         0xC8, 0x3A, 0xCD, 0x99, 0x9B, 0x54, 0x1A, 0x36,
1785         0xC1, 0x59, 0xF8, 0x98, 0xA8, 0xCC, 0x28, 0x0D,
1786         0x73, 0x4C, 0xEE, 0x98, 0xCB, 0x7C, 0x58, 0x7E,
1787         0x20, 0x75, 0x1E, 0xB7, 0xC9, 0xF8, 0xF2, 0x0E,
1788         0x63, 0x9E, 0x05, 0x78, 0x1A, 0xB6, 0xA8, 0x7A,
1789         0xF9, 0x98, 0x6A, 0xA6, 0x46, 0x84, 0x2E, 0xF6,
1790         0x4B, 0xDC, 0x9B, 0x8F, 0x9B, 0x8F, 0xEE, 0xB4,
1791         0xAA, 0x3F, 0xEE, 0xC0, 0x37, 0x27, 0x76, 0xC7,
1792         0x95, 0xBB, 0x26, 0x74, 0x69, 0x12, 0x7F, 0xF1,
1793         0xBB, 0xFF, 0xAE, 0xB5, 0x99, 0x6E, 0xCB, 0x0C
1794 };
1795
1796 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest[] = {
1797         0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60,
1798         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1799         0x18, 0x8c, 0x1d, 0x32
1800 };
1801
1802
1803 /* Multisession Vector context Test */
1804 /*Begin Session 0 */
1805 static uint8_t ms_aes_cbc_key0[] = {
1806         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1807         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1808 };
1809
1810 static uint8_t ms_aes_cbc_iv0[] = {
1811         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1812         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1813 };
1814
1815 static const uint8_t ms_aes_cbc_cipher0[] = {
1816                 0x3C, 0xE4, 0xEE, 0x42, 0xB6, 0x9B, 0xC3, 0x38,
1817                 0x5F, 0xAD, 0x54, 0xDC, 0xA8, 0x32, 0x81, 0xDC,
1818                 0x7A, 0x6F, 0x85, 0x58, 0x07, 0x35, 0xED, 0xEB,
1819                 0xAD, 0x79, 0x79, 0x96, 0xD3, 0x0E, 0xA6, 0xD9,
1820                 0xAA, 0x86, 0xA4, 0x8F, 0xB5, 0xD6, 0x6E, 0x6D,
1821                 0x0C, 0x91, 0x2F, 0xC4, 0x67, 0x98, 0x0E, 0xC4,
1822                 0x8D, 0x83, 0x68, 0x69, 0xC4, 0xD3, 0x94, 0x34,
1823                 0xC4, 0x5D, 0x60, 0x55, 0x22, 0x87, 0x8F, 0x6F,
1824                 0x17, 0x8E, 0x75, 0xE4, 0x02, 0xF5, 0x1B, 0x99,
1825                 0xC8, 0x39, 0xA9, 0xAB, 0x23, 0x91, 0x12, 0xED,
1826                 0x08, 0xE7, 0xD9, 0x25, 0x89, 0x24, 0x4F, 0x8D,
1827                 0x68, 0xF3, 0x10, 0x39, 0x0A, 0xEE, 0x45, 0x24,
1828                 0xDF, 0x7A, 0x9D, 0x00, 0x25, 0xE5, 0x35, 0x71,
1829                 0x4E, 0x40, 0x59, 0x6F, 0x0A, 0x13, 0xB3, 0x72,
1830                 0x1D, 0x98, 0x63, 0x94, 0x89, 0xA5, 0x39, 0x8E,
1831                 0xD3, 0x9C, 0x8A, 0x7F, 0x71, 0x2F, 0xC7, 0xCD,
1832                 0x81, 0x05, 0xDC, 0xC0, 0x8D, 0xCE, 0x6D, 0x18,
1833                 0x30, 0xC4, 0x72, 0x51, 0xF0, 0x27, 0xC8, 0xF6,
1834                 0x60, 0x5B, 0x7C, 0xB2, 0xE3, 0x49, 0x0C, 0x29,
1835                 0xC6, 0x9F, 0x39, 0x57, 0x80, 0x55, 0x24, 0x2C,
1836                 0x9B, 0x0F, 0x5A, 0xB3, 0x89, 0x55, 0x31, 0x96,
1837                 0x0D, 0xCD, 0xF6, 0x51, 0x03, 0x2D, 0x89, 0x26,
1838                 0x74, 0x44, 0xD6, 0xE8, 0xDC, 0xEA, 0x44, 0x55,
1839                 0x64, 0x71, 0x9C, 0x9F, 0x5D, 0xBA, 0x39, 0x46,
1840                 0xA8, 0x17, 0xA1, 0x9C, 0x52, 0x9D, 0xBC, 0x6B,
1841                 0x4A, 0x98, 0xE6, 0xEA, 0x33, 0xEC, 0x58, 0xB4,
1842                 0x43, 0xF0, 0x32, 0x45, 0xA4, 0xC1, 0x55, 0xB7,
1843                 0x5D, 0xB5, 0x59, 0xB2, 0xE3, 0x96, 0xFF, 0xA5,
1844                 0xAF, 0xE1, 0x86, 0x1B, 0x42, 0xE6, 0x3B, 0xA0,
1845                 0x90, 0x4A, 0xE8, 0x8C, 0x21, 0x7F, 0x36, 0x1E,
1846                 0x5B, 0x65, 0x25, 0xD1, 0xC1, 0x5A, 0xCA, 0x3D,
1847                 0x10, 0xED, 0x2D, 0x79, 0xD0, 0x0F, 0x58, 0x44,
1848                 0x69, 0x81, 0xF5, 0xD4, 0xC9, 0x0F, 0x90, 0x76,
1849                 0x1F, 0x54, 0xD2, 0xD5, 0x97, 0xCE, 0x2C, 0xE3,
1850                 0xEF, 0xF4, 0xB7, 0xC6, 0x3A, 0x87, 0x7F, 0x83,
1851                 0x2A, 0xAF, 0xCD, 0x90, 0x12, 0xA7, 0x7D, 0x85,
1852                 0x1D, 0x62, 0xD3, 0x85, 0x25, 0x05, 0xDB, 0x45,
1853                 0x92, 0xA3, 0xF6, 0xA2, 0xA8, 0x41, 0xE4, 0x25,
1854                 0x86, 0x87, 0x67, 0x24, 0xEC, 0x89, 0x23, 0x2A,
1855                 0x9B, 0x20, 0x4D, 0x93, 0xEE, 0xE2, 0x2E, 0xC1,
1856                 0x0B, 0x15, 0x33, 0xCF, 0x00, 0xD1, 0x1A, 0xDA,
1857                 0x93, 0xFD, 0x28, 0x21, 0x5B, 0xCF, 0xD1, 0xF3,
1858                 0x5A, 0x81, 0xBA, 0x82, 0x5E, 0x2F, 0x61, 0xB4,
1859                 0x05, 0x71, 0xB5, 0xF4, 0x39, 0x3C, 0x1F, 0x60,
1860                 0x00, 0x7A, 0xC4, 0xF8, 0x35, 0x20, 0x6C, 0x3A,
1861                 0xCC, 0x03, 0x8F, 0x7B, 0xA2, 0xB6, 0x65, 0x8A,
1862                 0xB6, 0x5F, 0xFD, 0x25, 0xD3, 0x5F, 0x92, 0xF9,
1863                 0xAE, 0x17, 0x9B, 0x5E, 0x6E, 0x9A, 0xE4, 0x55,
1864                 0x10, 0x25, 0x07, 0xA4, 0xAF, 0x21, 0x69, 0x13,
1865                 0xD8, 0xFA, 0x31, 0xED, 0xF7, 0xA7, 0xA7, 0x3B,
1866                 0xB8, 0x96, 0x8E, 0x10, 0x86, 0x74, 0xD8, 0xB1,
1867                 0x34, 0x9E, 0x9B, 0x6A, 0x26, 0xA8, 0xD4, 0xD0,
1868                 0xB5, 0xF6, 0xDE, 0xE7, 0xCA, 0x06, 0xDC, 0xA3,
1869                 0x6F, 0xEE, 0x6B, 0x1E, 0xB5, 0x30, 0x99, 0x23,
1870                 0xF9, 0x76, 0xF0, 0xA0, 0xCF, 0x3B, 0x94, 0x7B,
1871                 0x19, 0x8D, 0xA5, 0x0C, 0x18, 0xA6, 0x1D, 0x07,
1872                 0x89, 0xBE, 0x5B, 0x61, 0xE5, 0xF1, 0x42, 0xDB,
1873                 0xD4, 0x2E, 0x02, 0x1F, 0xCE, 0xEF, 0x92, 0xB1,
1874                 0x1B, 0x56, 0x50, 0xF2, 0x16, 0xE5, 0xE7, 0x4F,
1875                 0xFD, 0xBB, 0x3E, 0xD2, 0xFC, 0x3C, 0xC6, 0x0F,
1876                 0xF9, 0x12, 0x4E, 0xCB, 0x1E, 0x0C, 0x15, 0x84,
1877                 0x2A, 0x14, 0x8A, 0x02, 0xE4, 0x7E, 0x95, 0x5B,
1878                 0x86, 0xDB, 0x9B, 0x62, 0x5B, 0x19, 0xD2, 0x17,
1879                 0xFA, 0x13, 0xBB, 0x6B, 0x3F, 0x45, 0x9F, 0xBF
1880 };
1881
1882
1883 static  uint8_t ms_hmac_key0[] = {
1884                 0xFF, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1885                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1886                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1887                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1888                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1889                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1890                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1891                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1892 };
1893
1894 static const uint8_t ms_hmac_digest0[] = {
1895                 0x43, 0x52, 0xED, 0x34, 0xAB, 0x36, 0xB2, 0x51,
1896                 0xFB, 0xA3, 0xA6, 0x7C, 0x38, 0xFC, 0x42, 0x8F,
1897                 0x57, 0x64, 0xAB, 0x81, 0xA7, 0x89, 0xB7, 0x6C,
1898                 0xA0, 0xDC, 0xB9, 0x4D, 0xC4, 0x30, 0xF9, 0xD4,
1899                 0x10, 0x82, 0x55, 0xD0, 0xAB, 0x32, 0xFB, 0x56,
1900                 0x0D, 0xE4, 0x68, 0x3D, 0x76, 0xD0, 0x7B, 0xE4,
1901                 0xA6, 0x2C, 0x34, 0x9E, 0x8C, 0x41, 0xF8, 0x23,
1902                 0x28, 0x1B, 0x3A, 0x90, 0x26, 0x34, 0x47, 0x90
1903                 };
1904
1905 /* End Session 0 */
1906 /* Begin session 1 */
1907
1908 static  uint8_t ms_aes_cbc_key1[] = {
1909                 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1910                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1911 };
1912
1913 static  uint8_t ms_aes_cbc_iv1[] = {
1914         0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1915         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1916 };
1917
1918 static const uint8_t ms_aes_cbc_cipher1[] = {
1919                 0x5A, 0x7A, 0x67, 0x5D, 0xB8, 0xE1, 0xDC, 0x71,
1920                 0x39, 0xA8, 0x74, 0x93, 0x9C, 0x4C, 0xFE, 0x23,
1921                 0x61, 0xCD, 0xA4, 0xB3, 0xD9, 0xCE, 0x99, 0x09,
1922                 0x2A, 0x23, 0xF3, 0x29, 0xBF, 0x4C, 0xB4, 0x6A,
1923                 0x1B, 0x6B, 0x73, 0x4D, 0x48, 0x0C, 0xCF, 0x6C,
1924                 0x5E, 0x34, 0x9E, 0x7F, 0xBC, 0x8F, 0xCC, 0x8F,
1925                 0x75, 0x1D, 0x3D, 0x77, 0x10, 0x76, 0xC8, 0xB9,
1926                 0x99, 0x6F, 0xD6, 0x56, 0x75, 0xA9, 0xB2, 0x66,
1927                 0xC2, 0x24, 0x2B, 0x9C, 0xFE, 0x40, 0x8E, 0x43,
1928                 0x20, 0x97, 0x1B, 0xFA, 0xD0, 0xCF, 0x04, 0xAB,
1929                 0xBB, 0xF6, 0x5D, 0xF5, 0xA0, 0x19, 0x7C, 0x23,
1930                 0x5D, 0x80, 0x8C, 0x49, 0xF6, 0x76, 0x88, 0x29,
1931                 0x27, 0x4C, 0x59, 0x2B, 0x43, 0xA6, 0xB2, 0x26,
1932                 0x27, 0x78, 0xBE, 0x1B, 0xE1, 0x4F, 0x5A, 0x1F,
1933                 0xFC, 0x68, 0x08, 0xE7, 0xC4, 0xD1, 0x34, 0x68,
1934                 0xB7, 0x13, 0x14, 0x41, 0x62, 0x6B, 0x1F, 0x77,
1935                 0x0C, 0x68, 0x1D, 0x0D, 0xED, 0x89, 0xAA, 0xD8,
1936                 0x97, 0x02, 0xBA, 0x5E, 0xD4, 0x84, 0x25, 0x97,
1937                 0x03, 0xA5, 0xA6, 0x13, 0x66, 0x02, 0xF4, 0xC3,
1938                 0xF3, 0xD3, 0xCC, 0x95, 0xC3, 0x87, 0x46, 0x90,
1939                 0x1F, 0x6E, 0x14, 0xA8, 0x00, 0xF2, 0x6F, 0xD5,
1940                 0xA1, 0xAD, 0xD5, 0x40, 0xA2, 0x0F, 0x32, 0x7E,
1941                 0x99, 0xA3, 0xF5, 0x53, 0xC3, 0x26, 0xA1, 0x45,
1942                 0x01, 0x88, 0x57, 0x84, 0x3E, 0x7B, 0x4E, 0x0B,
1943                 0x3C, 0xB5, 0x3E, 0x9E, 0xE9, 0x78, 0x77, 0xC5,
1944                 0xC0, 0x89, 0xA8, 0xF8, 0xF1, 0xA5, 0x2D, 0x5D,
1945                 0xF9, 0xC6, 0xFB, 0xCB, 0x05, 0x23, 0xBD, 0x6E,
1946                 0x5E, 0x14, 0xC6, 0x57, 0x73, 0xCF, 0x98, 0xBD,
1947                 0x10, 0x8B, 0x18, 0xA6, 0x01, 0x5B, 0x13, 0xAE,
1948                 0x8E, 0xDE, 0x1F, 0xB5, 0xB7, 0x40, 0x6C, 0xC1,
1949                 0x1E, 0xA1, 0x19, 0x20, 0x9E, 0x95, 0xE0, 0x2F,
1950                 0x1C, 0xF5, 0xD9, 0xD0, 0x2B, 0x1E, 0x82, 0x25,
1951                 0x62, 0xB4, 0xEB, 0xA1, 0x1F, 0xCE, 0x44, 0xA1,
1952                 0xCB, 0x92, 0x01, 0x6B, 0xE4, 0x26, 0x23, 0xE3,
1953                 0xC5, 0x67, 0x35, 0x55, 0xDA, 0xE5, 0x27, 0xEE,
1954                 0x8D, 0x12, 0x84, 0xB7, 0xBA, 0xA7, 0x1C, 0xD6,
1955                 0x32, 0x3F, 0x67, 0xED, 0xFB, 0x5B, 0x8B, 0x52,
1956                 0x46, 0x8C, 0xF9, 0x69, 0xCD, 0xAE, 0x79, 0xAA,
1957                 0x37, 0x78, 0x49, 0xEB, 0xC6, 0x8E, 0x76, 0x63,
1958                 0x84, 0xFF, 0x9D, 0x22, 0x99, 0x51, 0xB7, 0x5E,
1959                 0x83, 0x4C, 0x8B, 0xDF, 0x5A, 0x07, 0xCC, 0xBA,
1960                 0x42, 0xA5, 0x98, 0xB6, 0x47, 0x0E, 0x66, 0xEB,
1961                 0x23, 0x0E, 0xBA, 0x44, 0xA8, 0xAA, 0x20, 0x71,
1962                 0x79, 0x9C, 0x77, 0x5F, 0xF5, 0xFE, 0xEC, 0xEF,
1963                 0xC6, 0x64, 0x3D, 0x84, 0xD0, 0x2B, 0xA7, 0x0A,
1964                 0xC3, 0x72, 0x5B, 0x9C, 0xFA, 0xA8, 0x87, 0x95,
1965                 0x94, 0x11, 0x38, 0xA7, 0x1E, 0x58, 0xE3, 0x73,
1966                 0xC6, 0xC9, 0xD1, 0x7B, 0x92, 0xDB, 0x0F, 0x49,
1967                 0x74, 0xC2, 0xA2, 0x0E, 0x35, 0x57, 0xAC, 0xDB,
1968                 0x9A, 0x1C, 0xCF, 0x5A, 0x32, 0x3E, 0x26, 0x9B,
1969                 0xEC, 0xB3, 0xEF, 0x9C, 0xFE, 0xBE, 0x52, 0xAC,
1970                 0xB1, 0x29, 0xDD, 0xFD, 0x07, 0xE2, 0xEE, 0xED,
1971                 0xE4, 0x46, 0x37, 0xFE, 0xD1, 0xDC, 0xCD, 0x02,
1972                 0xF9, 0x31, 0xB0, 0xFB, 0x36, 0xB7, 0x34, 0xA4,
1973                 0x76, 0xE8, 0x57, 0xBF, 0x99, 0x92, 0xC7, 0xAF,
1974                 0x98, 0x10, 0xE2, 0x70, 0xCA, 0xC9, 0x2B, 0x82,
1975                 0x06, 0x96, 0x88, 0x0D, 0xB3, 0xAC, 0x9E, 0x6D,
1976                 0x43, 0xBC, 0x5B, 0x31, 0xCF, 0x65, 0x8D, 0xA6,
1977                 0xC7, 0xFE, 0x73, 0xE1, 0x54, 0xF7, 0x10, 0xF9,
1978                 0x86, 0xF7, 0xDF, 0xA1, 0xA1, 0xD8, 0xAE, 0x35,
1979                 0xB3, 0x90, 0xDC, 0x6F, 0x43, 0x7A, 0x8B, 0xE0,
1980                 0xFE, 0x8F, 0x33, 0x4D, 0x29, 0x6C, 0x45, 0x53,
1981                 0x73, 0xDD, 0x21, 0x0B, 0x85, 0x30, 0xB5, 0xA5,
1982                 0xF3, 0x5D, 0xEC, 0x79, 0x61, 0x9D, 0x9E, 0xB3
1983
1984 };
1985
1986 static uint8_t ms_hmac_key1[] = {
1987                 0xFE, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1988                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1989                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1990                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1991                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1992                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1993                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1994                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1995 };
1996
1997 static const uint8_t ms_hmac_digest1[] = {
1998                 0xCE, 0x6E, 0x5F, 0x77, 0x96, 0x9A, 0xB1, 0x69,
1999                 0x2D, 0x5E, 0xF3, 0x2F, 0x32, 0x10, 0xCB, 0x50,
2000                 0x0E, 0x09, 0x56, 0x25, 0x07, 0x34, 0xC9, 0x20,
2001                 0xEC, 0x13, 0x43, 0x23, 0x5C, 0x08, 0x8B, 0xCD,
2002                 0xDC, 0x86, 0x8C, 0xEE, 0x0A, 0x95, 0x2E, 0xB9,
2003                 0x8C, 0x7B, 0x02, 0x7A, 0xD4, 0xE1, 0x49, 0xB4,
2004                 0x45, 0xB5, 0x52, 0x37, 0xC6, 0xFF, 0xFE, 0xAA,
2005                 0x0A, 0x87, 0xB8, 0x51, 0xF9, 0x2A, 0x01, 0x8F
2006 };
2007 /* End Session 1  */
2008 /* Begin Session 2 */
2009 static  uint8_t ms_aes_cbc_key2[] = {
2010                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
2011                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
2012 };
2013
2014 static  uint8_t ms_aes_cbc_iv2[] = {
2015                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
2016                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
2017 };
2018
2019 static const uint8_t ms_aes_cbc_cipher2[] = {
2020                 0xBB, 0x3C, 0x68, 0x25, 0xFD, 0xB6, 0xA2, 0x91,
2021                 0x20, 0x56, 0xF6, 0x30, 0x35, 0xFC, 0x9E, 0x97,
2022                 0xF2, 0x90, 0xFC, 0x7E, 0x3E, 0x0A, 0x75, 0xC8,
2023                 0x4C, 0xF2, 0x2D, 0xAC, 0xD3, 0x93, 0xF0, 0xC5,
2024                 0x14, 0x88, 0x8A, 0x23, 0xC2, 0x59, 0x9A, 0x98,
2025                 0x4B, 0xD5, 0x2C, 0xDA, 0x43, 0xA9, 0x34, 0x69,
2026                 0x7C, 0x6D, 0xDB, 0xDC, 0xCB, 0xC0, 0xA0, 0x09,
2027                 0xA7, 0x86, 0x16, 0x4B, 0xBF, 0xA8, 0xB6, 0xCF,
2028                 0x7F, 0x74, 0x1F, 0x22, 0xF0, 0xF6, 0xBB, 0x44,
2029                 0x8B, 0x4C, 0x9E, 0x23, 0xF8, 0x9F, 0xFC, 0x5B,
2030                 0x9E, 0x9C, 0x2A, 0x79, 0x30, 0x8F, 0xBF, 0xA9,
2031                 0x68, 0xA1, 0x20, 0x71, 0x7C, 0x77, 0x22, 0x34,
2032                 0x07, 0xCD, 0xC6, 0xF6, 0x50, 0x0A, 0x08, 0x99,
2033                 0x17, 0x98, 0xE3, 0x93, 0x8A, 0xB0, 0xEE, 0xDF,
2034                 0xC2, 0xBA, 0x3B, 0x44, 0x73, 0xDF, 0xDD, 0xDC,
2035                 0x14, 0x4D, 0x3B, 0xBB, 0x5E, 0x58, 0xC1, 0x26,
2036                 0xA7, 0xAE, 0x47, 0xF3, 0x24, 0x6D, 0x4F, 0xD3,
2037                 0x6E, 0x3E, 0x33, 0xE6, 0x7F, 0xCA, 0x50, 0xAF,
2038                 0x5D, 0x3D, 0xA0, 0xDD, 0xC9, 0xF3, 0x30, 0xD3,
2039                 0x6E, 0x8B, 0x2E, 0x12, 0x24, 0x34, 0xF0, 0xD3,
2040                 0xC7, 0x8D, 0x23, 0x29, 0xAA, 0x05, 0xE1, 0xFA,
2041                 0x2E, 0xF6, 0x8D, 0x37, 0x86, 0xC0, 0x6D, 0x13,
2042                 0x2D, 0x98, 0xF3, 0x52, 0x39, 0x22, 0xCE, 0x38,
2043                 0xC2, 0x1A, 0x72, 0xED, 0xFB, 0xCC, 0xE4, 0x71,
2044                 0x5A, 0x0C, 0x0D, 0x09, 0xF8, 0xE8, 0x1B, 0xBC,
2045                 0x53, 0xC8, 0xD8, 0x8F, 0xE5, 0x98, 0x5A, 0xB1,
2046                 0x06, 0xA6, 0x5B, 0xE6, 0xA2, 0x88, 0x21, 0x9E,
2047                 0x36, 0xC0, 0x34, 0xF9, 0xFB, 0x3B, 0x0A, 0x22,
2048                 0x00, 0x00, 0x39, 0x48, 0x8D, 0x23, 0x74, 0x62,
2049                 0x72, 0x91, 0xE6, 0x36, 0xAA, 0x77, 0x9C, 0x72,
2050                 0x9D, 0xA8, 0xC3, 0xA9, 0xD5, 0x44, 0x72, 0xA6,
2051                 0xB9, 0x28, 0x8F, 0x64, 0x4C, 0x8A, 0x64, 0xE6,
2052                 0x4E, 0xFA, 0xEF, 0x87, 0xDE, 0x7B, 0x22, 0x44,
2053                 0xB0, 0xDF, 0x2E, 0x5F, 0x0B, 0xA5, 0xF2, 0x24,
2054                 0x07, 0x5C, 0x2D, 0x39, 0xB7, 0x3D, 0x8A, 0xE5,
2055                 0x0E, 0x9D, 0x4E, 0x50, 0xED, 0x03, 0x99, 0x8E,
2056                 0xF0, 0x06, 0x55, 0x4E, 0xA2, 0x24, 0xE7, 0x17,
2057                 0x46, 0xDF, 0x6C, 0xCD, 0xC6, 0x44, 0xE8, 0xF9,
2058                 0xB9, 0x1B, 0x36, 0xF6, 0x7F, 0x10, 0xA4, 0x7D,
2059                 0x90, 0xBD, 0xE4, 0xAA, 0xD6, 0x9E, 0x18, 0x9D,
2060                 0x22, 0x35, 0xD6, 0x55, 0x54, 0xAA, 0xF7, 0x22,
2061                 0xA3, 0x3E, 0xEF, 0xC8, 0xA2, 0x34, 0x8D, 0xA9,
2062                 0x37, 0x63, 0xA6, 0xC3, 0x57, 0xCB, 0x0C, 0x49,
2063                 0x7D, 0x02, 0xBE, 0xAA, 0x13, 0x75, 0xB7, 0x4E,
2064                 0x52, 0x62, 0xA5, 0xC2, 0x33, 0xC7, 0x6C, 0x1B,
2065                 0xF6, 0x34, 0xF6, 0x09, 0xA5, 0x0C, 0xC7, 0xA2,
2066                 0x61, 0x48, 0x62, 0x7D, 0x17, 0x15, 0xE3, 0x95,
2067                 0xC8, 0x63, 0xD2, 0xA4, 0x43, 0xA9, 0x49, 0x07,
2068                 0xB2, 0x3B, 0x2B, 0x62, 0x7D, 0xCB, 0x51, 0xB3,
2069                 0x25, 0x33, 0x47, 0x0E, 0x14, 0x67, 0xDC, 0x6A,
2070                 0x9B, 0x51, 0xAC, 0x9D, 0x8F, 0xA2, 0x2B, 0x57,
2071                 0x8C, 0x5C, 0x5F, 0x76, 0x23, 0x92, 0x0F, 0x84,
2072                 0x46, 0x0E, 0x40, 0x85, 0x38, 0x60, 0xFA, 0x61,
2073                 0x20, 0xC5, 0xE3, 0xF1, 0x70, 0xAC, 0x1B, 0xBF,
2074                 0xC4, 0x2B, 0xC5, 0x67, 0xD1, 0x43, 0xC5, 0x17,
2075                 0x74, 0x71, 0x69, 0x6F, 0x82, 0x89, 0x19, 0x8A,
2076                 0x70, 0x43, 0x92, 0x01, 0xC4, 0x63, 0x7E, 0xB1,
2077                 0x59, 0x4E, 0xCD, 0xEA, 0x93, 0xA4, 0x52, 0x53,
2078                 0x9B, 0x61, 0x5B, 0xD2, 0x3E, 0x19, 0x39, 0xB7,
2079                 0x32, 0xEA, 0x8E, 0xF8, 0x1D, 0x76, 0x5C, 0xB2,
2080                 0x73, 0x2D, 0x91, 0xC0, 0x18, 0xED, 0x25, 0x2A,
2081                 0x53, 0x64, 0xF0, 0x92, 0x31, 0x55, 0x21, 0xA8,
2082                 0x24, 0xA9, 0xD1, 0x02, 0xF6, 0x6C, 0x2B, 0x70,
2083                 0xA9, 0x59, 0xC1, 0xD6, 0xC3, 0x57, 0x5B, 0x92
2084 };
2085
2086 static  uint8_t ms_hmac_key2[] = {
2087                 0xFC, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
2088                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
2089                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
2090                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
2091                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
2092                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
2093                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
2094                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
2095 };
2096
2097 static const uint8_t ms_hmac_digest2[] = {
2098                 0xA5, 0x0F, 0x9C, 0xFB, 0x08, 0x62, 0x59, 0xFF,
2099                 0x80, 0x2F, 0xEB, 0x4B, 0xE1, 0x46, 0x21, 0xD6,
2100                 0x02, 0x98, 0xF2, 0x8E, 0xF4, 0xEC, 0xD4, 0x77,
2101                 0x86, 0x4C, 0x31, 0x28, 0xC8, 0x25, 0x80, 0x27,
2102                 0x3A, 0x72, 0x5D, 0x6A, 0x56, 0x8A, 0xD3, 0x82,
2103                 0xB0, 0xEC, 0x31, 0x6D, 0x8B, 0x6B, 0xB4, 0x24,
2104                 0xE7, 0x62, 0xC1, 0x52, 0xBC, 0x14, 0x1B, 0x8E,
2105                 0xEC, 0x9A, 0xF1, 0x47, 0x80, 0xD2, 0xB0, 0x59
2106 };
2107
2108 /* End Session 2 */
2109
2110
2111 static int
2112 test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
2113 {
2114         struct crypto_testsuite_params *ts_params = &testsuite_params;
2115         struct crypto_unittest_params *ut_params = &unittest_params;
2116
2117         /* Verify the capabilities */
2118         struct rte_cryptodev_sym_capability_idx cap_idx;
2119         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2120         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
2121         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2122                         &cap_idx) == NULL)
2123                 return TEST_SKIPPED;
2124         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2125         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
2126         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2127                         &cap_idx) == NULL)
2128                 return TEST_SKIPPED;
2129
2130         /* Generate test mbuf data and space for digest */
2131         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
2132                         catch_22_quote, QUOTE_512_BYTES, 0);
2133
2134         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2135                         DIGEST_BYTE_LENGTH_SHA1);
2136         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
2137
2138         /* Setup Cipher Parameters */
2139         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2140         ut_params->cipher_xform.next = &ut_params->auth_xform;
2141
2142         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
2143         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2144         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
2145         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
2146         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2147         ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
2148
2149         /* Setup HMAC Parameters */
2150         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2151
2152         ut_params->auth_xform.next = NULL;
2153
2154         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2155         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
2156         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1;
2157         ut_params->auth_xform.auth.key.data = hmac_sha1_key;
2158         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
2159
2160         ut_params->sess = rte_cryptodev_sym_session_create(
2161                         ts_params->session_mpool);
2162
2163         /* Create crypto session*/
2164         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
2165                         ut_params->sess, &ut_params->cipher_xform,
2166                         ts_params->session_priv_mpool);
2167         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2168
2169         /* Generate crypto op data structure */
2170         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2171                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2172         TEST_ASSERT_NOT_NULL(ut_params->op,
2173                         "Failed to allocate symmetric crypto operation struct");
2174
2175         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2176
2177         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2178
2179         /* set crypto operation source mbuf */
2180         sym_op->m_src = ut_params->ibuf;
2181
2182         /* Set crypto operation authentication parameters */
2183         sym_op->auth.digest.data = ut_params->digest;
2184         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2185                         ut_params->ibuf, QUOTE_512_BYTES);
2186
2187         sym_op->auth.data.offset = 0;
2188         sym_op->auth.data.length = QUOTE_512_BYTES;
2189
2190         /* Copy IV at the end of the crypto operation */
2191         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2192                         aes_cbc_iv, CIPHER_IV_LENGTH_AES_CBC);
2193
2194         /* Set crypto operation cipher parameters */
2195         sym_op->cipher.data.offset = 0;
2196         sym_op->cipher.data.length = QUOTE_512_BYTES;
2197
2198         /* Process crypto operation */
2199         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2200                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
2201                         ut_params->op);
2202         else
2203                 TEST_ASSERT_NOT_NULL(
2204                         process_crypto_request(ts_params->valid_devs[0],
2205                                 ut_params->op),
2206                                 "failed to process sym crypto op");
2207
2208         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2209                         "crypto op processing failed");
2210
2211         /* Validate obuf */
2212         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
2213                         uint8_t *);
2214
2215         TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext,
2216                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
2217                         QUOTE_512_BYTES,
2218                         "ciphertext data not as expected");
2219
2220         uint8_t *digest = ciphertext + QUOTE_512_BYTES;
2221
2222         TEST_ASSERT_BUFFERS_ARE_EQUAL(digest,
2223                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
2224                         gbl_driver_id == rte_cryptodev_driver_id_get(
2225                                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) ?
2226                                         TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
2227                                         DIGEST_BYTE_LENGTH_SHA1,
2228                         "Generated digest data not as expected");
2229
2230         return TEST_SUCCESS;
2231 }
2232
2233 /* ***** AES-CBC / HMAC-SHA512 Hash Tests ***** */
2234
2235 #define HMAC_KEY_LENGTH_SHA512  (DIGEST_BYTE_LENGTH_SHA512)
2236
2237 static uint8_t hmac_sha512_key[] = {
2238         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
2239         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
2240         0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
2241         0x9a, 0xaf, 0x88, 0x1b, 0xb6, 0x8f, 0xf8, 0x60,
2242         0xa2, 0x5a, 0x7f, 0x3f, 0xf4, 0x72, 0x70, 0xf1,
2243         0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
2244         0x47, 0x3a, 0x75, 0x61, 0x5C, 0xa2, 0x10, 0x76,
2245         0x9a, 0xaf, 0x77, 0x5b, 0xb6, 0x7f, 0xf7, 0x60 };
2246
2247 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest[] = {
2248         0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8,
2249         0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48,
2250         0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8,
2251         0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70,
2252         0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8,
2253         0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E,
2254         0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D,
2255         0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A };
2256
2257
2258
2259 static int
2260 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
2261                 struct crypto_unittest_params *ut_params,
2262                 uint8_t *cipher_key,
2263                 uint8_t *hmac_key);
2264
2265 static int
2266 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
2267                 struct crypto_unittest_params *ut_params,
2268                 struct crypto_testsuite_params *ts_params,
2269                 const uint8_t *cipher,
2270                 const uint8_t *digest,
2271                 const uint8_t *iv);
2272
2273
2274 static int
2275 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
2276                 struct crypto_unittest_params *ut_params,
2277                 uint8_t *cipher_key,
2278                 uint8_t *hmac_key)
2279 {
2280
2281         /* Setup Cipher Parameters */
2282         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2283         ut_params->cipher_xform.next = NULL;
2284
2285         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
2286         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
2287         ut_params->cipher_xform.cipher.key.data = cipher_key;
2288         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
2289         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2290         ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
2291
2292         /* Setup HMAC Parameters */
2293         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2294         ut_params->auth_xform.next = &ut_params->cipher_xform;
2295
2296         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
2297         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC;
2298         ut_params->auth_xform.auth.key.data = hmac_key;
2299         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512;
2300         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512;
2301
2302         return TEST_SUCCESS;
2303 }
2304
2305
2306 static int
2307 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
2308                 struct crypto_unittest_params *ut_params,
2309                 struct crypto_testsuite_params *ts_params,
2310                 const uint8_t *cipher,
2311                 const uint8_t *digest,
2312                 const uint8_t *iv)
2313 {
2314         /* Generate test mbuf data and digest */
2315         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
2316                         (const char *)
2317                         cipher,
2318                         QUOTE_512_BYTES, 0);
2319
2320         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2321                         DIGEST_BYTE_LENGTH_SHA512);
2322         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
2323
2324         rte_memcpy(ut_params->digest,
2325                         digest,
2326                         DIGEST_BYTE_LENGTH_SHA512);
2327
2328         /* Generate Crypto op data structure */
2329         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2330                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2331         TEST_ASSERT_NOT_NULL(ut_params->op,
2332                         "Failed to allocate symmetric crypto operation struct");
2333
2334         rte_crypto_op_attach_sym_session(ut_params->op, sess);
2335
2336         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2337
2338         /* set crypto operation source mbuf */
2339         sym_op->m_src = ut_params->ibuf;
2340
2341         sym_op->auth.digest.data = ut_params->digest;
2342         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2343                         ut_params->ibuf, QUOTE_512_BYTES);
2344
2345         sym_op->auth.data.offset = 0;
2346         sym_op->auth.data.length = QUOTE_512_BYTES;
2347
2348         /* Copy IV at the end of the crypto operation */
2349         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2350                         iv, CIPHER_IV_LENGTH_AES_CBC);
2351
2352         sym_op->cipher.data.offset = 0;
2353         sym_op->cipher.data.length = QUOTE_512_BYTES;
2354
2355         /* Process crypto operation */
2356         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2357                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
2358                         ut_params->op);
2359         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
2360                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
2361                                 ut_params->op, 1, 1, 0, 0);
2362         else
2363                 TEST_ASSERT_NOT_NULL(
2364                                 process_crypto_request(ts_params->valid_devs[0],
2365                                         ut_params->op),
2366                                         "failed to process sym crypto op");
2367
2368         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2369                         "crypto op processing failed");
2370
2371         ut_params->obuf = ut_params->op->sym->m_src;
2372
2373         /* Validate obuf */
2374         TEST_ASSERT_BUFFERS_ARE_EQUAL(
2375                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *),
2376                         catch_22_quote,
2377                         QUOTE_512_BYTES,
2378                         "Plaintext data not as expected");
2379
2380         /* Validate obuf */
2381         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2382                         "Digest verification failed");
2383
2384         return TEST_SUCCESS;
2385 }
2386
2387 /* ***** SNOW 3G Tests ***** */
2388 static int
2389 create_wireless_algo_hash_session(uint8_t dev_id,
2390         const uint8_t *key, const uint8_t key_len,
2391         const uint8_t iv_len, const uint8_t auth_len,
2392         enum rte_crypto_auth_operation op,
2393         enum rte_crypto_auth_algorithm algo)
2394 {
2395         uint8_t hash_key[key_len];
2396         int status;
2397
2398         struct crypto_testsuite_params *ts_params = &testsuite_params;
2399         struct crypto_unittest_params *ut_params = &unittest_params;
2400
2401         memcpy(hash_key, key, key_len);
2402
2403         debug_hexdump(stdout, "key:", key, key_len);
2404
2405         /* Setup Authentication Parameters */
2406         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2407         ut_params->auth_xform.next = NULL;
2408
2409         ut_params->auth_xform.auth.op = op;
2410         ut_params->auth_xform.auth.algo = algo;
2411         ut_params->auth_xform.auth.key.length = key_len;
2412         ut_params->auth_xform.auth.key.data = hash_key;
2413         ut_params->auth_xform.auth.digest_length = auth_len;
2414         ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
2415         ut_params->auth_xform.auth.iv.length = iv_len;
2416         ut_params->sess = rte_cryptodev_sym_session_create(
2417                         ts_params->session_mpool);
2418
2419         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2420                         &ut_params->auth_xform,
2421                         ts_params->session_priv_mpool);
2422         if (status == -ENOTSUP)
2423                 return TEST_SKIPPED;
2424
2425         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2426         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2427         return 0;
2428 }
2429
2430 static int
2431 create_wireless_algo_cipher_session(uint8_t dev_id,
2432                         enum rte_crypto_cipher_operation op,
2433                         enum rte_crypto_cipher_algorithm algo,
2434                         const uint8_t *key, const uint8_t key_len,
2435                         uint8_t iv_len)
2436 {
2437         uint8_t cipher_key[key_len];
2438         int status;
2439         struct crypto_testsuite_params *ts_params = &testsuite_params;
2440         struct crypto_unittest_params *ut_params = &unittest_params;
2441
2442         memcpy(cipher_key, key, key_len);
2443
2444         /* Setup Cipher Parameters */
2445         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2446         ut_params->cipher_xform.next = NULL;
2447
2448         ut_params->cipher_xform.cipher.algo = algo;
2449         ut_params->cipher_xform.cipher.op = op;
2450         ut_params->cipher_xform.cipher.key.data = cipher_key;
2451         ut_params->cipher_xform.cipher.key.length = key_len;
2452         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2453         ut_params->cipher_xform.cipher.iv.length = iv_len;
2454
2455         debug_hexdump(stdout, "key:", key, key_len);
2456
2457         /* Create Crypto session */
2458         ut_params->sess = rte_cryptodev_sym_session_create(
2459                         ts_params->session_mpool);
2460
2461         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2462                         &ut_params->cipher_xform,
2463                         ts_params->session_priv_mpool);
2464         if (status == -ENOTSUP)
2465                 return TEST_SKIPPED;
2466
2467         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2468         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2469         return 0;
2470 }
2471
2472 static int
2473 create_wireless_algo_cipher_operation(const uint8_t *iv, uint8_t iv_len,
2474                         unsigned int cipher_len,
2475                         unsigned int cipher_offset)
2476 {
2477         struct crypto_testsuite_params *ts_params = &testsuite_params;
2478         struct crypto_unittest_params *ut_params = &unittest_params;
2479
2480         /* Generate Crypto op data structure */
2481         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2482                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2483         TEST_ASSERT_NOT_NULL(ut_params->op,
2484                                 "Failed to allocate pktmbuf offload");
2485
2486         /* Set crypto operation data parameters */
2487         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2488
2489         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2490
2491         /* set crypto operation source mbuf */
2492         sym_op->m_src = ut_params->ibuf;
2493
2494         /* iv */
2495         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2496                         iv, iv_len);
2497         sym_op->cipher.data.length = cipher_len;
2498         sym_op->cipher.data.offset = cipher_offset;
2499         return 0;
2500 }
2501
2502 static int
2503 create_wireless_algo_cipher_operation_oop(const uint8_t *iv, uint8_t iv_len,
2504                         unsigned int cipher_len,
2505                         unsigned int cipher_offset)
2506 {
2507         struct crypto_testsuite_params *ts_params = &testsuite_params;
2508         struct crypto_unittest_params *ut_params = &unittest_params;
2509
2510         /* Generate Crypto op data structure */
2511         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2512                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2513         TEST_ASSERT_NOT_NULL(ut_params->op,
2514                                 "Failed to allocate pktmbuf offload");
2515
2516         /* Set crypto operation data parameters */
2517         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2518
2519         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2520
2521         /* set crypto operation source mbuf */
2522         sym_op->m_src = ut_params->ibuf;
2523         sym_op->m_dst = ut_params->obuf;
2524
2525         /* iv */
2526         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2527                         iv, iv_len);
2528         sym_op->cipher.data.length = cipher_len;
2529         sym_op->cipher.data.offset = cipher_offset;
2530         return 0;
2531 }
2532
2533 static int
2534 create_wireless_algo_cipher_auth_session(uint8_t dev_id,
2535                 enum rte_crypto_cipher_operation cipher_op,
2536                 enum rte_crypto_auth_operation auth_op,
2537                 enum rte_crypto_auth_algorithm auth_algo,
2538                 enum rte_crypto_cipher_algorithm cipher_algo,
2539                 const uint8_t *key, uint8_t key_len,
2540                 uint8_t auth_iv_len, uint8_t auth_len,
2541                 uint8_t cipher_iv_len)
2542
2543 {
2544         uint8_t cipher_auth_key[key_len];
2545         int status;
2546
2547         struct crypto_testsuite_params *ts_params = &testsuite_params;
2548         struct crypto_unittest_params *ut_params = &unittest_params;
2549
2550         memcpy(cipher_auth_key, key, key_len);
2551
2552         /* Setup Authentication Parameters */
2553         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2554         ut_params->auth_xform.next = NULL;
2555
2556         ut_params->auth_xform.auth.op = auth_op;
2557         ut_params->auth_xform.auth.algo = auth_algo;
2558         ut_params->auth_xform.auth.key.length = key_len;
2559         /* Hash key = cipher key */
2560         ut_params->auth_xform.auth.key.data = cipher_auth_key;
2561         ut_params->auth_xform.auth.digest_length = auth_len;
2562         /* Auth IV will be after cipher IV */
2563         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2564         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2565
2566         /* Setup Cipher Parameters */
2567         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2568         ut_params->cipher_xform.next = &ut_params->auth_xform;
2569
2570         ut_params->cipher_xform.cipher.algo = cipher_algo;
2571         ut_params->cipher_xform.cipher.op = cipher_op;
2572         ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2573         ut_params->cipher_xform.cipher.key.length = key_len;
2574         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2575         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2576
2577         debug_hexdump(stdout, "key:", key, key_len);
2578
2579         /* Create Crypto session*/
2580         ut_params->sess = rte_cryptodev_sym_session_create(
2581                         ts_params->session_mpool);
2582         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2583
2584         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2585                         &ut_params->cipher_xform,
2586                         ts_params->session_priv_mpool);
2587         if (status == -ENOTSUP)
2588                 return TEST_SKIPPED;
2589
2590         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2591         return 0;
2592 }
2593
2594 static int
2595 create_wireless_cipher_auth_session(uint8_t dev_id,
2596                 enum rte_crypto_cipher_operation cipher_op,
2597                 enum rte_crypto_auth_operation auth_op,
2598                 enum rte_crypto_auth_algorithm auth_algo,
2599                 enum rte_crypto_cipher_algorithm cipher_algo,
2600                 const struct wireless_test_data *tdata)
2601 {
2602         const uint8_t key_len = tdata->key.len;
2603         uint8_t cipher_auth_key[key_len];
2604         int status;
2605
2606         struct crypto_testsuite_params *ts_params = &testsuite_params;
2607         struct crypto_unittest_params *ut_params = &unittest_params;
2608         const uint8_t *key = tdata->key.data;
2609         const uint8_t auth_len = tdata->digest.len;
2610         uint8_t cipher_iv_len = tdata->cipher_iv.len;
2611         uint8_t auth_iv_len = tdata->auth_iv.len;
2612
2613         memcpy(cipher_auth_key, key, key_len);
2614
2615         /* Setup Authentication Parameters */
2616         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2617         ut_params->auth_xform.next = NULL;
2618
2619         ut_params->auth_xform.auth.op = auth_op;
2620         ut_params->auth_xform.auth.algo = auth_algo;
2621         ut_params->auth_xform.auth.key.length = key_len;
2622         /* Hash key = cipher key */
2623         ut_params->auth_xform.auth.key.data = cipher_auth_key;
2624         ut_params->auth_xform.auth.digest_length = auth_len;
2625         /* Auth IV will be after cipher IV */
2626         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2627         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2628
2629         /* Setup Cipher Parameters */
2630         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2631         ut_params->cipher_xform.next = &ut_params->auth_xform;
2632
2633         ut_params->cipher_xform.cipher.algo = cipher_algo;
2634         ut_params->cipher_xform.cipher.op = cipher_op;
2635         ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2636         ut_params->cipher_xform.cipher.key.length = key_len;
2637         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2638         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2639
2640
2641         debug_hexdump(stdout, "key:", key, key_len);
2642
2643         /* Create Crypto session*/
2644         ut_params->sess = rte_cryptodev_sym_session_create(
2645                         ts_params->session_mpool);
2646
2647         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2648                         &ut_params->cipher_xform,
2649                         ts_params->session_priv_mpool);
2650         if (status == -ENOTSUP)
2651                 return TEST_SKIPPED;
2652
2653         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2654         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2655         return 0;
2656 }
2657
2658 static int
2659 create_zuc_cipher_auth_encrypt_generate_session(uint8_t dev_id,
2660                 const struct wireless_test_data *tdata)
2661 {
2662         return create_wireless_cipher_auth_session(dev_id,
2663                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2664                 RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_ZUC_EIA3,
2665                 RTE_CRYPTO_CIPHER_ZUC_EEA3, tdata);
2666 }
2667
2668 static int
2669 create_wireless_algo_auth_cipher_session(uint8_t dev_id,
2670                 enum rte_crypto_cipher_operation cipher_op,
2671                 enum rte_crypto_auth_operation auth_op,
2672                 enum rte_crypto_auth_algorithm auth_algo,
2673                 enum rte_crypto_cipher_algorithm cipher_algo,
2674                 const uint8_t *key, const uint8_t key_len,
2675                 uint8_t auth_iv_len, uint8_t auth_len,
2676                 uint8_t cipher_iv_len)
2677 {
2678         uint8_t auth_cipher_key[key_len];
2679         int status;
2680         struct crypto_testsuite_params *ts_params = &testsuite_params;
2681         struct crypto_unittest_params *ut_params = &unittest_params;
2682
2683         memcpy(auth_cipher_key, key, key_len);
2684
2685         /* Setup Authentication Parameters */
2686         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2687         ut_params->auth_xform.auth.op = auth_op;
2688         ut_params->auth_xform.next = &ut_params->cipher_xform;
2689         ut_params->auth_xform.auth.algo = auth_algo;
2690         ut_params->auth_xform.auth.key.length = key_len;
2691         ut_params->auth_xform.auth.key.data = auth_cipher_key;
2692         ut_params->auth_xform.auth.digest_length = auth_len;
2693         /* Auth IV will be after cipher IV */
2694         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2695         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2696
2697         /* Setup Cipher Parameters */
2698         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2699         ut_params->cipher_xform.next = NULL;
2700         ut_params->cipher_xform.cipher.algo = cipher_algo;
2701         ut_params->cipher_xform.cipher.op = cipher_op;
2702         ut_params->cipher_xform.cipher.key.data = auth_cipher_key;
2703         ut_params->cipher_xform.cipher.key.length = key_len;
2704         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2705         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2706
2707         debug_hexdump(stdout, "key:", key, key_len);
2708
2709         /* Create Crypto session*/
2710         ut_params->sess = rte_cryptodev_sym_session_create(
2711                         ts_params->session_mpool);
2712         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2713
2714         if (cipher_op == RTE_CRYPTO_CIPHER_OP_DECRYPT) {
2715                 ut_params->auth_xform.next = NULL;
2716                 ut_params->cipher_xform.next = &ut_params->auth_xform;
2717                 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2718                                 &ut_params->cipher_xform,
2719                                 ts_params->session_priv_mpool);
2720
2721         } else
2722                 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2723                                 &ut_params->auth_xform,
2724                                 ts_params->session_priv_mpool);
2725
2726         if (status == -ENOTSUP)
2727                 return TEST_SKIPPED;
2728
2729         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2730
2731         return 0;
2732 }
2733
2734 static int
2735 create_wireless_algo_hash_operation(const uint8_t *auth_tag,
2736                 unsigned int auth_tag_len,
2737                 const uint8_t *iv, unsigned int iv_len,
2738                 unsigned int data_pad_len,
2739                 enum rte_crypto_auth_operation op,
2740                 unsigned int auth_len, unsigned int auth_offset)
2741 {
2742         struct crypto_testsuite_params *ts_params = &testsuite_params;
2743
2744         struct crypto_unittest_params *ut_params = &unittest_params;
2745
2746         /* Generate Crypto op data structure */
2747         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2748                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2749         TEST_ASSERT_NOT_NULL(ut_params->op,
2750                 "Failed to allocate pktmbuf offload");
2751
2752         /* Set crypto operation data parameters */
2753         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2754
2755         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2756
2757         /* set crypto operation source mbuf */
2758         sym_op->m_src = ut_params->ibuf;
2759
2760         /* iv */
2761         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2762                         iv, iv_len);
2763         /* digest */
2764         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2765                                         ut_params->ibuf, auth_tag_len);
2766
2767         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2768                                 "no room to append auth tag");
2769         ut_params->digest = sym_op->auth.digest.data;
2770         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2771                         ut_params->ibuf, data_pad_len);
2772         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2773                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2774         else
2775                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2776
2777         debug_hexdump(stdout, "digest:",
2778                 sym_op->auth.digest.data,
2779                 auth_tag_len);
2780
2781         sym_op->auth.data.length = auth_len;
2782         sym_op->auth.data.offset = auth_offset;
2783
2784         return 0;
2785 }
2786
2787 static int
2788 create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata,
2789         enum rte_crypto_auth_operation op)
2790 {
2791         struct crypto_testsuite_params *ts_params = &testsuite_params;
2792         struct crypto_unittest_params *ut_params = &unittest_params;
2793
2794         const uint8_t *auth_tag = tdata->digest.data;
2795         const unsigned int auth_tag_len = tdata->digest.len;
2796         unsigned int plaintext_len = ceil_byte_length(tdata->plaintext.len);
2797         unsigned int data_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2798
2799         const uint8_t *cipher_iv = tdata->cipher_iv.data;
2800         const uint8_t cipher_iv_len = tdata->cipher_iv.len;
2801         const uint8_t *auth_iv = tdata->auth_iv.data;
2802         const uint8_t auth_iv_len = tdata->auth_iv.len;
2803         const unsigned int cipher_len = tdata->validCipherLenInBits.len;
2804         const unsigned int auth_len = tdata->validAuthLenInBits.len;
2805
2806         /* Generate Crypto op data structure */
2807         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2808                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2809         TEST_ASSERT_NOT_NULL(ut_params->op,
2810                         "Failed to allocate pktmbuf offload");
2811         /* Set crypto operation data parameters */
2812         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2813
2814         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2815
2816         /* set crypto operation source mbuf */
2817         sym_op->m_src = ut_params->ibuf;
2818
2819         /* digest */
2820         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2821                         ut_params->ibuf, auth_tag_len);
2822
2823         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2824                         "no room to append auth tag");
2825         ut_params->digest = sym_op->auth.digest.data;
2826         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2827                         ut_params->ibuf, data_pad_len);
2828         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2829                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2830         else
2831                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2832
2833         debug_hexdump(stdout, "digest:",
2834                 sym_op->auth.digest.data,
2835                 auth_tag_len);
2836
2837         /* Copy cipher and auth IVs at the end of the crypto operation */
2838         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2839                                                 IV_OFFSET);
2840         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2841         iv_ptr += cipher_iv_len;
2842         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2843
2844         sym_op->cipher.data.length = cipher_len;
2845         sym_op->cipher.data.offset = 0;
2846         sym_op->auth.data.length = auth_len;
2847         sym_op->auth.data.offset = 0;
2848
2849         return 0;
2850 }
2851
2852 static int
2853 create_zuc_cipher_hash_generate_operation(
2854                 const struct wireless_test_data *tdata)
2855 {
2856         return create_wireless_cipher_hash_operation(tdata,
2857                 RTE_CRYPTO_AUTH_OP_GENERATE);
2858 }
2859
2860 static int
2861 create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
2862                 const unsigned auth_tag_len,
2863                 const uint8_t *auth_iv, uint8_t auth_iv_len,
2864                 unsigned data_pad_len,
2865                 enum rte_crypto_auth_operation op,
2866                 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2867                 const unsigned cipher_len, const unsigned cipher_offset,
2868                 const unsigned auth_len, const unsigned auth_offset)
2869 {
2870         struct crypto_testsuite_params *ts_params = &testsuite_params;
2871         struct crypto_unittest_params *ut_params = &unittest_params;
2872
2873         enum rte_crypto_cipher_algorithm cipher_algo =
2874                         ut_params->cipher_xform.cipher.algo;
2875         enum rte_crypto_auth_algorithm auth_algo =
2876                         ut_params->auth_xform.auth.algo;
2877
2878         /* Generate Crypto op data structure */
2879         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2880                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2881         TEST_ASSERT_NOT_NULL(ut_params->op,
2882                         "Failed to allocate pktmbuf offload");
2883         /* Set crypto operation data parameters */
2884         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2885
2886         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2887
2888         /* set crypto operation source mbuf */
2889         sym_op->m_src = ut_params->ibuf;
2890
2891         /* digest */
2892         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2893                         ut_params->ibuf, auth_tag_len);
2894
2895         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2896                         "no room to append auth tag");
2897         ut_params->digest = sym_op->auth.digest.data;
2898
2899         if (rte_pktmbuf_is_contiguous(ut_params->ibuf)) {
2900                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2901                                 ut_params->ibuf, data_pad_len);
2902         } else {
2903                 struct rte_mbuf *m = ut_params->ibuf;
2904                 unsigned int offset = data_pad_len;
2905
2906                 while (offset > m->data_len && m->next != NULL) {
2907                         offset -= m->data_len;
2908                         m = m->next;
2909                 }
2910                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2911                         m, offset);
2912         }
2913
2914         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2915                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2916         else
2917                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2918
2919         debug_hexdump(stdout, "digest:",
2920                 sym_op->auth.digest.data,
2921                 auth_tag_len);
2922
2923         /* Copy cipher and auth IVs at the end of the crypto operation */
2924         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2925                                                 IV_OFFSET);
2926         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2927         iv_ptr += cipher_iv_len;
2928         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2929
2930         if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
2931                 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
2932                 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
2933                 sym_op->cipher.data.length = cipher_len;
2934                 sym_op->cipher.data.offset = cipher_offset;
2935         } else {
2936                 sym_op->cipher.data.length = cipher_len >> 3;
2937                 sym_op->cipher.data.offset = cipher_offset >> 3;
2938         }
2939
2940         if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
2941                 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
2942                 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
2943                 sym_op->auth.data.length = auth_len;
2944                 sym_op->auth.data.offset = auth_offset;
2945         } else {
2946                 sym_op->auth.data.length = auth_len >> 3;
2947                 sym_op->auth.data.offset = auth_offset >> 3;
2948         }
2949
2950         return 0;
2951 }
2952
2953 static int
2954 create_wireless_algo_auth_cipher_operation(
2955                 const uint8_t *auth_tag, unsigned int auth_tag_len,
2956                 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2957                 const uint8_t *auth_iv, uint8_t auth_iv_len,
2958                 unsigned int data_pad_len,
2959                 unsigned int cipher_len, unsigned int cipher_offset,
2960                 unsigned int auth_len, unsigned int auth_offset,
2961                 uint8_t op_mode, uint8_t do_sgl, uint8_t verify)
2962 {
2963         struct crypto_testsuite_params *ts_params = &testsuite_params;
2964         struct crypto_unittest_params *ut_params = &unittest_params;
2965
2966         enum rte_crypto_cipher_algorithm cipher_algo =
2967                         ut_params->cipher_xform.cipher.algo;
2968         enum rte_crypto_auth_algorithm auth_algo =
2969                         ut_params->auth_xform.auth.algo;
2970
2971         /* Generate Crypto op data structure */
2972         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2973                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2974         TEST_ASSERT_NOT_NULL(ut_params->op,
2975                         "Failed to allocate pktmbuf offload");
2976
2977         /* Set crypto operation data parameters */
2978         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2979
2980         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2981
2982         /* set crypto operation mbufs */
2983         sym_op->m_src = ut_params->ibuf;
2984         if (op_mode == OUT_OF_PLACE)
2985                 sym_op->m_dst = ut_params->obuf;
2986
2987         /* digest */
2988         if (!do_sgl) {
2989                 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(
2990                         (op_mode == IN_PLACE ?
2991                                 ut_params->ibuf : ut_params->obuf),
2992                         uint8_t *, data_pad_len);
2993                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2994                         (op_mode == IN_PLACE ?
2995                                 ut_params->ibuf : ut_params->obuf),
2996                         data_pad_len);
2997                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2998         } else {
2999                 uint16_t remaining_off = (auth_offset >> 3) + (auth_len >> 3);
3000                 struct rte_mbuf *sgl_buf = (op_mode == IN_PLACE ?
3001                                 sym_op->m_src : sym_op->m_dst);
3002                 while (remaining_off >= rte_pktmbuf_data_len(sgl_buf)) {
3003                         remaining_off -= rte_pktmbuf_data_len(sgl_buf);
3004                         sgl_buf = sgl_buf->next;
3005                 }
3006                 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(sgl_buf,
3007                                 uint8_t *, remaining_off);
3008                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(sgl_buf,
3009                                 remaining_off);
3010                 memset(sym_op->auth.digest.data, 0, remaining_off);
3011                 while (sgl_buf->next != NULL) {
3012                         memset(rte_pktmbuf_mtod(sgl_buf, uint8_t *),
3013                                 0, rte_pktmbuf_data_len(sgl_buf));
3014                         sgl_buf = sgl_buf->next;
3015                 }
3016         }
3017
3018         /* Copy digest for the verification */
3019         if (verify)
3020                 memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
3021
3022         /* Copy cipher and auth IVs at the end of the crypto operation */
3023         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(
3024                         ut_params->op, uint8_t *, IV_OFFSET);
3025
3026         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
3027         iv_ptr += cipher_iv_len;
3028         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
3029
3030         /* Only copy over the offset data needed from src to dst in OOP,
3031          * if the auth and cipher offsets are not aligned
3032          */
3033         if (op_mode == OUT_OF_PLACE) {
3034                 if (cipher_offset > auth_offset)
3035                         rte_memcpy(
3036                                 rte_pktmbuf_mtod_offset(
3037                                         sym_op->m_dst,
3038                                         uint8_t *, auth_offset >> 3),
3039                                 rte_pktmbuf_mtod_offset(
3040                                         sym_op->m_src,
3041                                         uint8_t *, auth_offset >> 3),
3042                                 ((cipher_offset >> 3) - (auth_offset >> 3)));
3043         }
3044
3045         if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
3046                 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
3047                 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
3048                 sym_op->cipher.data.length = cipher_len;
3049                 sym_op->cipher.data.offset = cipher_offset;
3050         } else {
3051                 sym_op->cipher.data.length = cipher_len >> 3;
3052                 sym_op->cipher.data.offset = cipher_offset >> 3;
3053         }
3054
3055         if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
3056                 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
3057                 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
3058                 sym_op->auth.data.length = auth_len;
3059                 sym_op->auth.data.offset = auth_offset;
3060         } else {
3061                 sym_op->auth.data.length = auth_len >> 3;
3062                 sym_op->auth.data.offset = auth_offset >> 3;
3063         }
3064
3065         return 0;
3066 }
3067
3068 static int
3069 test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
3070 {
3071         struct crypto_testsuite_params *ts_params = &testsuite_params;
3072         struct crypto_unittest_params *ut_params = &unittest_params;
3073
3074         int retval;
3075         unsigned plaintext_pad_len;
3076         unsigned plaintext_len;
3077         uint8_t *plaintext;
3078         struct rte_cryptodev_info dev_info;
3079
3080         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3081         uint64_t feat_flags = dev_info.feature_flags;
3082
3083         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
3084                         ((tdata->validAuthLenInBits.len % 8) != 0)) {
3085                 printf("Device doesn't support NON-Byte Aligned Data.\n");
3086                 return TEST_SKIPPED;
3087         }
3088
3089         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3090                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3091                 printf("Device doesn't support RAW data-path APIs.\n");
3092                 return TEST_SKIPPED;
3093         }
3094
3095         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3096                 return TEST_SKIPPED;
3097
3098         /* Verify the capabilities */
3099         struct rte_cryptodev_sym_capability_idx cap_idx;
3100         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3101         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
3102         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3103                         &cap_idx) == NULL)
3104                 return TEST_SKIPPED;
3105
3106         /* Create SNOW 3G session */
3107         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3108                         tdata->key.data, tdata->key.len,
3109                         tdata->auth_iv.len, tdata->digest.len,
3110                         RTE_CRYPTO_AUTH_OP_GENERATE,
3111                         RTE_CRYPTO_AUTH_SNOW3G_UIA2);
3112         if (retval < 0)
3113                 return retval;
3114
3115         /* alloc mbuf and set payload */
3116         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3117
3118         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3119         rte_pktmbuf_tailroom(ut_params->ibuf));
3120
3121         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3122         /* Append data which is padded to a multiple of */
3123         /* the algorithms block size */
3124         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3125         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3126                                 plaintext_pad_len);
3127         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3128
3129         /* Create SNOW 3G operation */
3130         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
3131                         tdata->auth_iv.data, tdata->auth_iv.len,
3132                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3133                         tdata->validAuthLenInBits.len,
3134                         0);
3135         if (retval < 0)
3136                 return retval;
3137
3138         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3139                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3140                                 ut_params->op, 0, 1, 1, 0);
3141         else
3142                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3143                                 ut_params->op);
3144         ut_params->obuf = ut_params->op->sym->m_src;
3145         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3146         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3147                         + plaintext_pad_len;
3148
3149         /* Validate obuf */
3150         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3151         ut_params->digest,
3152         tdata->digest.data,
3153         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
3154         "SNOW 3G Generated auth tag not as expected");
3155
3156         return 0;
3157 }
3158
3159 static int
3160 test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
3161 {
3162         struct crypto_testsuite_params *ts_params = &testsuite_params;
3163         struct crypto_unittest_params *ut_params = &unittest_params;
3164
3165         int retval;
3166         unsigned plaintext_pad_len;
3167         unsigned plaintext_len;
3168         uint8_t *plaintext;
3169         struct rte_cryptodev_info dev_info;
3170
3171         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3172         uint64_t feat_flags = dev_info.feature_flags;
3173
3174         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
3175                         ((tdata->validAuthLenInBits.len % 8) != 0)) {
3176                 printf("Device doesn't support NON-Byte Aligned Data.\n");
3177                 return TEST_SKIPPED;
3178         }
3179
3180         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3181                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3182                 printf("Device doesn't support RAW data-path APIs.\n");
3183                 return TEST_SKIPPED;
3184         }
3185
3186         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3187                 return TEST_SKIPPED;
3188
3189         /* Verify the capabilities */
3190         struct rte_cryptodev_sym_capability_idx cap_idx;
3191         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3192         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
3193         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3194                         &cap_idx) == NULL)
3195                 return TEST_SKIPPED;
3196
3197         /* Create SNOW 3G session */
3198         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3199                                 tdata->key.data, tdata->key.len,
3200                                 tdata->auth_iv.len, tdata->digest.len,
3201                                 RTE_CRYPTO_AUTH_OP_VERIFY,
3202                                 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
3203         if (retval < 0)
3204                 return retval;
3205         /* alloc mbuf and set payload */
3206         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3207
3208         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3209         rte_pktmbuf_tailroom(ut_params->ibuf));
3210
3211         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3212         /* Append data which is padded to a multiple of */
3213         /* the algorithms block size */
3214         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3215         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3216                                 plaintext_pad_len);
3217         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3218
3219         /* Create SNOW 3G operation */
3220         retval = create_wireless_algo_hash_operation(tdata->digest.data,
3221                         tdata->digest.len,
3222                         tdata->auth_iv.data, tdata->auth_iv.len,
3223                         plaintext_pad_len,
3224                         RTE_CRYPTO_AUTH_OP_VERIFY,
3225                         tdata->validAuthLenInBits.len,
3226                         0);
3227         if (retval < 0)
3228                 return retval;
3229
3230         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3231                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3232                                 ut_params->op, 0, 1, 1, 0);
3233         else
3234                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3235                                 ut_params->op);
3236         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3237         ut_params->obuf = ut_params->op->sym->m_src;
3238         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3239                                 + plaintext_pad_len;
3240
3241         /* Validate obuf */
3242         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
3243                 return 0;
3244         else
3245                 return -1;
3246
3247         return 0;
3248 }
3249
3250 static int
3251 test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
3252 {
3253         struct crypto_testsuite_params *ts_params = &testsuite_params;
3254         struct crypto_unittest_params *ut_params = &unittest_params;
3255
3256         int retval;
3257         unsigned plaintext_pad_len;
3258         unsigned plaintext_len;
3259         uint8_t *plaintext;
3260         struct rte_cryptodev_info dev_info;
3261
3262         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3263         uint64_t feat_flags = dev_info.feature_flags;
3264
3265         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3266                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3267                 printf("Device doesn't support RAW data-path APIs.\n");
3268                 return TEST_SKIPPED;
3269         }
3270
3271         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3272                 return TEST_SKIPPED;
3273
3274         /* Verify the capabilities */
3275         struct rte_cryptodev_sym_capability_idx cap_idx;
3276         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3277         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
3278         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3279                         &cap_idx) == NULL)
3280                 return TEST_SKIPPED;
3281
3282         /* Create KASUMI session */
3283         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3284                         tdata->key.data, tdata->key.len,
3285                         0, tdata->digest.len,
3286                         RTE_CRYPTO_AUTH_OP_GENERATE,
3287                         RTE_CRYPTO_AUTH_KASUMI_F9);
3288         if (retval < 0)
3289                 return retval;
3290
3291         /* alloc mbuf and set payload */
3292         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3293
3294         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3295         rte_pktmbuf_tailroom(ut_params->ibuf));
3296
3297         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3298         /* Append data which is padded to a multiple of */
3299         /* the algorithms block size */
3300         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3301         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3302                                 plaintext_pad_len);
3303         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3304
3305         /* Create KASUMI operation */
3306         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
3307                         NULL, 0,
3308                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3309                         tdata->plaintext.len,
3310                         0);
3311         if (retval < 0)
3312                 return retval;
3313
3314         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3315                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
3316                         ut_params->op);
3317         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3318                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3319                                 ut_params->op, 0, 1, 1, 0);
3320         else
3321                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3322                         ut_params->op);
3323
3324         ut_params->obuf = ut_params->op->sym->m_src;
3325         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3326         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3327                         + plaintext_pad_len;
3328
3329         /* Validate obuf */
3330         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3331         ut_params->digest,
3332         tdata->digest.data,
3333         DIGEST_BYTE_LENGTH_KASUMI_F9,
3334         "KASUMI Generated auth tag not as expected");
3335
3336         return 0;
3337 }
3338
3339 static int
3340 test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
3341 {
3342         struct crypto_testsuite_params *ts_params = &testsuite_params;
3343         struct crypto_unittest_params *ut_params = &unittest_params;
3344
3345         int retval;
3346         unsigned plaintext_pad_len;
3347         unsigned plaintext_len;
3348         uint8_t *plaintext;
3349         struct rte_cryptodev_info dev_info;
3350
3351         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3352         uint64_t feat_flags = dev_info.feature_flags;
3353
3354         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3355                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3356                 printf("Device doesn't support RAW data-path APIs.\n");
3357                 return TEST_SKIPPED;
3358         }
3359
3360         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3361                 return TEST_SKIPPED;
3362
3363         /* Verify the capabilities */
3364         struct rte_cryptodev_sym_capability_idx cap_idx;
3365         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3366         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
3367         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3368                         &cap_idx) == NULL)
3369                 return TEST_SKIPPED;
3370
3371         /* Create KASUMI session */
3372         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3373                                 tdata->key.data, tdata->key.len,
3374                                 0, tdata->digest.len,
3375                                 RTE_CRYPTO_AUTH_OP_VERIFY,
3376                                 RTE_CRYPTO_AUTH_KASUMI_F9);
3377         if (retval < 0)
3378                 return retval;
3379         /* alloc mbuf and set payload */
3380         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3381
3382         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3383         rte_pktmbuf_tailroom(ut_params->ibuf));
3384
3385         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3386         /* Append data which is padded to a multiple */
3387         /* of the algorithms block size */
3388         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3389         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3390                                 plaintext_pad_len);
3391         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3392
3393         /* Create KASUMI operation */
3394         retval = create_wireless_algo_hash_operation(tdata->digest.data,
3395                         tdata->digest.len,
3396                         NULL, 0,
3397                         plaintext_pad_len,
3398                         RTE_CRYPTO_AUTH_OP_VERIFY,
3399                         tdata->plaintext.len,
3400                         0);
3401         if (retval < 0)
3402                 return retval;
3403
3404         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3405                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3406                                 ut_params->op, 0, 1, 1, 0);
3407         else
3408                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3409                                 ut_params->op);
3410         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3411         ut_params->obuf = ut_params->op->sym->m_src;
3412         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3413                                 + plaintext_pad_len;
3414
3415         /* Validate obuf */
3416         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
3417                 return 0;
3418         else
3419                 return -1;
3420
3421         return 0;
3422 }
3423
3424 static int
3425 test_snow3g_hash_generate_test_case_1(void)
3426 {
3427         return test_snow3g_authentication(&snow3g_hash_test_case_1);
3428 }
3429
3430 static int
3431 test_snow3g_hash_generate_test_case_2(void)
3432 {
3433         return test_snow3g_authentication(&snow3g_hash_test_case_2);
3434 }
3435
3436 static int
3437 test_snow3g_hash_generate_test_case_3(void)
3438 {
3439         return test_snow3g_authentication(&snow3g_hash_test_case_3);
3440 }
3441
3442 static int
3443 test_snow3g_hash_generate_test_case_4(void)
3444 {
3445         return test_snow3g_authentication(&snow3g_hash_test_case_4);
3446 }
3447
3448 static int
3449 test_snow3g_hash_generate_test_case_5(void)
3450 {
3451         return test_snow3g_authentication(&snow3g_hash_test_case_5);
3452 }
3453
3454 static int
3455 test_snow3g_hash_generate_test_case_6(void)
3456 {
3457         return test_snow3g_authentication(&snow3g_hash_test_case_6);
3458 }
3459
3460 static int
3461 test_snow3g_hash_verify_test_case_1(void)
3462 {
3463         return test_snow3g_authentication_verify(&snow3g_hash_test_case_1);
3464
3465 }
3466
3467 static int
3468 test_snow3g_hash_verify_test_case_2(void)
3469 {
3470         return test_snow3g_authentication_verify(&snow3g_hash_test_case_2);
3471 }
3472
3473 static int
3474 test_snow3g_hash_verify_test_case_3(void)
3475 {
3476         return test_snow3g_authentication_verify(&snow3g_hash_test_case_3);
3477 }
3478
3479 static int
3480 test_snow3g_hash_verify_test_case_4(void)
3481 {
3482         return test_snow3g_authentication_verify(&snow3g_hash_test_case_4);
3483 }
3484
3485 static int
3486 test_snow3g_hash_verify_test_case_5(void)
3487 {
3488         return test_snow3g_authentication_verify(&snow3g_hash_test_case_5);
3489 }
3490
3491 static int
3492 test_snow3g_hash_verify_test_case_6(void)
3493 {
3494         return test_snow3g_authentication_verify(&snow3g_hash_test_case_6);
3495 }
3496
3497 static int
3498 test_kasumi_hash_generate_test_case_1(void)
3499 {
3500         return test_kasumi_authentication(&kasumi_hash_test_case_1);
3501 }
3502
3503 static int
3504 test_kasumi_hash_generate_test_case_2(void)
3505 {
3506         return test_kasumi_authentication(&kasumi_hash_test_case_2);
3507 }
3508
3509 static int
3510 test_kasumi_hash_generate_test_case_3(void)
3511 {
3512         return test_kasumi_authentication(&kasumi_hash_test_case_3);
3513 }
3514
3515 static int
3516 test_kasumi_hash_generate_test_case_4(void)
3517 {
3518         return test_kasumi_authentication(&kasumi_hash_test_case_4);
3519 }
3520
3521 static int
3522 test_kasumi_hash_generate_test_case_5(void)
3523 {
3524         return test_kasumi_authentication(&kasumi_hash_test_case_5);
3525 }
3526
3527 static int
3528 test_kasumi_hash_generate_test_case_6(void)
3529 {
3530         return test_kasumi_authentication(&kasumi_hash_test_case_6);
3531 }
3532
3533 static int
3534 test_kasumi_hash_verify_test_case_1(void)
3535 {
3536         return test_kasumi_authentication_verify(&kasumi_hash_test_case_1);
3537 }
3538
3539 static int
3540 test_kasumi_hash_verify_test_case_2(void)
3541 {
3542         return test_kasumi_authentication_verify(&kasumi_hash_test_case_2);
3543 }
3544
3545 static int
3546 test_kasumi_hash_verify_test_case_3(void)
3547 {
3548         return test_kasumi_authentication_verify(&kasumi_hash_test_case_3);
3549 }
3550
3551 static int
3552 test_kasumi_hash_verify_test_case_4(void)
3553 {
3554         return test_kasumi_authentication_verify(&kasumi_hash_test_case_4);
3555 }
3556
3557 static int
3558 test_kasumi_hash_verify_test_case_5(void)
3559 {
3560         return test_kasumi_authentication_verify(&kasumi_hash_test_case_5);
3561 }
3562
3563 static int
3564 test_kasumi_encryption(const struct kasumi_test_data *tdata)
3565 {
3566         struct crypto_testsuite_params *ts_params = &testsuite_params;
3567         struct crypto_unittest_params *ut_params = &unittest_params;
3568
3569         int retval;
3570         uint8_t *plaintext, *ciphertext;
3571         unsigned plaintext_pad_len;
3572         unsigned plaintext_len;
3573         struct rte_cryptodev_info dev_info;
3574
3575         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3576         uint64_t feat_flags = dev_info.feature_flags;
3577
3578         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3579                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3580                 printf("Device doesn't support RAW data-path APIs.\n");
3581                 return TEST_SKIPPED;
3582         }
3583
3584         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3585                 return TEST_SKIPPED;
3586
3587         /* Verify the capabilities */
3588         struct rte_cryptodev_sym_capability_idx cap_idx;
3589         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3590         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3591         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3592                         &cap_idx) == NULL)
3593                 return TEST_SKIPPED;
3594
3595         /* Create KASUMI session */
3596         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3597                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3598                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3599                                         tdata->key.data, tdata->key.len,
3600                                         tdata->cipher_iv.len);
3601         if (retval < 0)
3602                 return retval;
3603
3604         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3605
3606         /* Clear mbuf payload */
3607         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3608                rte_pktmbuf_tailroom(ut_params->ibuf));
3609
3610         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3611         /* Append data which is padded to a multiple */
3612         /* of the algorithms block size */
3613         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3614         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3615                                 plaintext_pad_len);
3616         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3617
3618         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3619
3620         /* Create KASUMI operation */
3621         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3622                                 tdata->cipher_iv.len,
3623                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3624                                 tdata->validCipherOffsetInBits.len);
3625         if (retval < 0)
3626                 return retval;
3627
3628         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3629                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3630                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
3631         else
3632                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3633                                 ut_params->op);
3634         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3635
3636         ut_params->obuf = ut_params->op->sym->m_dst;
3637         if (ut_params->obuf)
3638                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3639         else
3640                 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3641
3642         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3643
3644         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3645                                 (tdata->validCipherOffsetInBits.len >> 3);
3646         /* Validate obuf */
3647         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3648                 ciphertext,
3649                 reference_ciphertext,
3650                 tdata->validCipherLenInBits.len,
3651                 "KASUMI Ciphertext data not as expected");
3652         return 0;
3653 }
3654
3655 static int
3656 test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
3657 {
3658         struct crypto_testsuite_params *ts_params = &testsuite_params;
3659         struct crypto_unittest_params *ut_params = &unittest_params;
3660
3661         int retval;
3662
3663         unsigned int plaintext_pad_len;
3664         unsigned int plaintext_len;
3665
3666         uint8_t buffer[10000];
3667         const uint8_t *ciphertext;
3668
3669         struct rte_cryptodev_info dev_info;
3670
3671         /* Verify the capabilities */
3672         struct rte_cryptodev_sym_capability_idx cap_idx;
3673         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3674         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3675         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3676                         &cap_idx) == NULL)
3677                 return TEST_SKIPPED;
3678
3679         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3680
3681         uint64_t feat_flags = dev_info.feature_flags;
3682
3683         if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
3684                 printf("Device doesn't support in-place scatter-gather. "
3685                                 "Test Skipped.\n");
3686                 return TEST_SKIPPED;
3687         }
3688
3689         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3690                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3691                 printf("Device doesn't support RAW data-path APIs.\n");
3692                 return TEST_SKIPPED;
3693         }
3694
3695         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3696                 return TEST_SKIPPED;
3697
3698         /* Create KASUMI session */
3699         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3700                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3701                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3702                                         tdata->key.data, tdata->key.len,
3703                                         tdata->cipher_iv.len);
3704         if (retval < 0)
3705                 return retval;
3706
3707         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3708
3709
3710         /* Append data which is padded to a multiple */
3711         /* of the algorithms block size */
3712         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3713
3714         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3715                         plaintext_pad_len, 10, 0);
3716
3717         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3718
3719         /* Create KASUMI operation */
3720         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3721                                 tdata->cipher_iv.len,
3722                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3723                                 tdata->validCipherOffsetInBits.len);
3724         if (retval < 0)
3725                 return retval;
3726
3727         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3728                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3729                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
3730         else
3731                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3732                                                 ut_params->op);
3733         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3734
3735         ut_params->obuf = ut_params->op->sym->m_dst;
3736
3737         if (ut_params->obuf)
3738                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3739                                 plaintext_len, buffer);
3740         else
3741                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3742                                 tdata->validCipherOffsetInBits.len >> 3,
3743                                 plaintext_len, buffer);
3744
3745         /* Validate obuf */
3746         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3747
3748         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3749                                 (tdata->validCipherOffsetInBits.len >> 3);
3750         /* Validate obuf */
3751         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3752                 ciphertext,
3753                 reference_ciphertext,
3754                 tdata->validCipherLenInBits.len,
3755                 "KASUMI Ciphertext data not as expected");
3756         return 0;
3757 }
3758
3759 static int
3760 test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
3761 {
3762         struct crypto_testsuite_params *ts_params = &testsuite_params;
3763         struct crypto_unittest_params *ut_params = &unittest_params;
3764
3765         int retval;
3766         uint8_t *plaintext, *ciphertext;
3767         unsigned plaintext_pad_len;
3768         unsigned plaintext_len;
3769
3770         /* Verify the capabilities */
3771         struct rte_cryptodev_sym_capability_idx cap_idx;
3772         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3773         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3774         /* Data-path service does not support OOP */
3775         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3776                         &cap_idx) == NULL)
3777                 return TEST_SKIPPED;
3778
3779         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3780                 return TEST_SKIPPED;
3781
3782         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3783                 return TEST_SKIPPED;
3784
3785         /* Create KASUMI session */
3786         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3787                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3788                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3789                                         tdata->key.data, tdata->key.len,
3790                                         tdata->cipher_iv.len);
3791         if (retval < 0)
3792                 return retval;
3793
3794         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3795         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3796
3797         /* Clear mbuf payload */
3798         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3799                rte_pktmbuf_tailroom(ut_params->ibuf));
3800
3801         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3802         /* Append data which is padded to a multiple */
3803         /* of the algorithms block size */
3804         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3805         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3806                                 plaintext_pad_len);
3807         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3808         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3809
3810         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3811
3812         /* Create KASUMI operation */
3813         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3814                                 tdata->cipher_iv.len,
3815                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3816                                 tdata->validCipherOffsetInBits.len);
3817         if (retval < 0)
3818                 return retval;
3819
3820         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3821                                                 ut_params->op);
3822         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3823
3824         ut_params->obuf = ut_params->op->sym->m_dst;
3825         if (ut_params->obuf)
3826                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3827         else
3828                 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3829
3830         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3831
3832         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3833                                 (tdata->validCipherOffsetInBits.len >> 3);
3834         /* Validate obuf */
3835         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3836                 ciphertext,
3837                 reference_ciphertext,
3838                 tdata->validCipherLenInBits.len,
3839                 "KASUMI Ciphertext data not as expected");
3840         return 0;
3841 }
3842
3843 static int
3844 test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
3845 {
3846         struct crypto_testsuite_params *ts_params = &testsuite_params;
3847         struct crypto_unittest_params *ut_params = &unittest_params;
3848
3849         int retval;
3850         unsigned int plaintext_pad_len;
3851         unsigned int plaintext_len;
3852
3853         const uint8_t *ciphertext;
3854         uint8_t buffer[2048];
3855
3856         struct rte_cryptodev_info dev_info;
3857
3858         /* Verify the capabilities */
3859         struct rte_cryptodev_sym_capability_idx cap_idx;
3860         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3861         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3862         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3863                         &cap_idx) == NULL)
3864                 return TEST_SKIPPED;
3865
3866         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3867                 return TEST_SKIPPED;
3868
3869         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3870                 return TEST_SKIPPED;
3871
3872         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3873
3874         uint64_t feat_flags = dev_info.feature_flags;
3875         if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
3876                 printf("Device doesn't support out-of-place scatter-gather "
3877                                 "in both input and output mbufs. "
3878                                 "Test Skipped.\n");
3879                 return TEST_SKIPPED;
3880         }
3881
3882         /* Create KASUMI session */
3883         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3884                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3885                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3886                                         tdata->key.data, tdata->key.len,
3887                                         tdata->cipher_iv.len);
3888         if (retval < 0)
3889                 return retval;
3890
3891         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3892         /* Append data which is padded to a multiple */
3893         /* of the algorithms block size */
3894         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3895
3896         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3897                         plaintext_pad_len, 10, 0);
3898         ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
3899                         plaintext_pad_len, 3, 0);
3900
3901         /* Append data which is padded to a multiple */
3902         /* of the algorithms block size */
3903         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3904
3905         /* Create KASUMI operation */
3906         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3907                                 tdata->cipher_iv.len,
3908                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3909                                 tdata->validCipherOffsetInBits.len);
3910         if (retval < 0)
3911                 return retval;
3912
3913         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3914                                                 ut_params->op);
3915         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3916
3917         ut_params->obuf = ut_params->op->sym->m_dst;
3918         if (ut_params->obuf)
3919                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3920                                 plaintext_pad_len, buffer);
3921         else
3922                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3923                                 tdata->validCipherOffsetInBits.len >> 3,
3924                                 plaintext_pad_len, buffer);
3925
3926         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3927                                 (tdata->validCipherOffsetInBits.len >> 3);
3928         /* Validate obuf */
3929         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3930                 ciphertext,
3931                 reference_ciphertext,
3932                 tdata->validCipherLenInBits.len,
3933                 "KASUMI Ciphertext data not as expected");
3934         return 0;
3935 }
3936
3937
3938 static int
3939 test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
3940 {
3941         struct crypto_testsuite_params *ts_params = &testsuite_params;
3942         struct crypto_unittest_params *ut_params = &unittest_params;
3943
3944         int retval;
3945         uint8_t *ciphertext, *plaintext;
3946         unsigned ciphertext_pad_len;
3947         unsigned ciphertext_len;
3948
3949         /* Verify the capabilities */
3950         struct rte_cryptodev_sym_capability_idx cap_idx;
3951         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3952         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3953         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3954                         &cap_idx) == NULL)
3955                 return TEST_SKIPPED;
3956
3957         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3958                 return TEST_SKIPPED;
3959
3960         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3961                 return TEST_SKIPPED;
3962
3963         /* Create KASUMI session */
3964         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3965                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
3966                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3967                                         tdata->key.data, tdata->key.len,
3968                                         tdata->cipher_iv.len);
3969         if (retval < 0)
3970                 return retval;
3971
3972         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3973         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3974
3975         /* Clear mbuf payload */
3976         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3977                rte_pktmbuf_tailroom(ut_params->ibuf));
3978
3979         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3980         /* Append data which is padded to a multiple */
3981         /* of the algorithms block size */
3982         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
3983         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3984                                 ciphertext_pad_len);
3985         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
3986         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3987
3988         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
3989
3990         /* Create KASUMI operation */
3991         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3992                                 tdata->cipher_iv.len,
3993                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3994                                 tdata->validCipherOffsetInBits.len);
3995         if (retval < 0)
3996                 return retval;
3997
3998         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3999                                                 ut_params->op);
4000         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4001
4002         ut_params->obuf = ut_params->op->sym->m_dst;
4003         if (ut_params->obuf)
4004                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4005         else
4006                 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
4007
4008         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4009
4010         const uint8_t *reference_plaintext = tdata->plaintext.data +
4011                                 (tdata->validCipherOffsetInBits.len >> 3);
4012         /* Validate obuf */
4013         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4014                 plaintext,
4015                 reference_plaintext,
4016                 tdata->validCipherLenInBits.len,
4017                 "KASUMI Plaintext data not as expected");
4018         return 0;
4019 }
4020
4021 static int
4022 test_kasumi_decryption(const struct kasumi_test_data *tdata)
4023 {
4024         struct crypto_testsuite_params *ts_params = &testsuite_params;
4025         struct crypto_unittest_params *ut_params = &unittest_params;
4026
4027         int retval;
4028         uint8_t *ciphertext, *plaintext;
4029         unsigned ciphertext_pad_len;
4030         unsigned ciphertext_len;
4031         struct rte_cryptodev_info dev_info;
4032
4033         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4034         uint64_t feat_flags = dev_info.feature_flags;
4035
4036         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4037                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4038                 printf("Device doesn't support RAW data-path APIs.\n");
4039                 return TEST_SKIPPED;
4040         }
4041
4042         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4043                 return TEST_SKIPPED;
4044
4045         /* Verify the capabilities */
4046         struct rte_cryptodev_sym_capability_idx cap_idx;
4047         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4048         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
4049         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4050                         &cap_idx) == NULL)
4051                 return TEST_SKIPPED;
4052
4053         /* Create KASUMI session */
4054         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4055                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4056                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
4057                                         tdata->key.data, tdata->key.len,
4058                                         tdata->cipher_iv.len);
4059         if (retval < 0)
4060                 return retval;
4061
4062         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4063
4064         /* Clear mbuf payload */
4065         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4066                rte_pktmbuf_tailroom(ut_params->ibuf));
4067
4068         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4069         /* Append data which is padded to a multiple */
4070         /* of the algorithms block size */
4071         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
4072         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4073                                 ciphertext_pad_len);
4074         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4075
4076         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4077
4078         /* Create KASUMI operation */
4079         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4080                                         tdata->cipher_iv.len,
4081                                         tdata->ciphertext.len,
4082                                         tdata->validCipherOffsetInBits.len);
4083         if (retval < 0)
4084                 return retval;
4085
4086         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4087                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4088                                 ut_params->op, 1, 0, 1, 0);
4089         else
4090                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4091                                                 ut_params->op);
4092         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4093
4094         ut_params->obuf = ut_params->op->sym->m_dst;
4095         if (ut_params->obuf)
4096                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4097         else
4098                 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
4099
4100         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4101
4102         const uint8_t *reference_plaintext = tdata->plaintext.data +
4103                                 (tdata->validCipherOffsetInBits.len >> 3);
4104         /* Validate obuf */
4105         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4106                 plaintext,
4107                 reference_plaintext,
4108                 tdata->validCipherLenInBits.len,
4109                 "KASUMI Plaintext data not as expected");
4110         return 0;
4111 }
4112
4113 static int
4114 test_snow3g_encryption(const struct snow3g_test_data *tdata)
4115 {
4116         struct crypto_testsuite_params *ts_params = &testsuite_params;
4117         struct crypto_unittest_params *ut_params = &unittest_params;
4118
4119         int retval;
4120         uint8_t *plaintext, *ciphertext;
4121         unsigned plaintext_pad_len;
4122         unsigned plaintext_len;
4123         struct rte_cryptodev_info dev_info;
4124
4125         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4126         uint64_t feat_flags = dev_info.feature_flags;
4127
4128         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4129                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4130                 printf("Device doesn't support RAW data-path APIs.\n");
4131                 return TEST_SKIPPED;
4132         }
4133
4134         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4135                 return TEST_SKIPPED;
4136
4137         /* Verify the capabilities */
4138         struct rte_cryptodev_sym_capability_idx cap_idx;
4139         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4140         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4141         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4142                         &cap_idx) == NULL)
4143                 return TEST_SKIPPED;
4144
4145         /* Create SNOW 3G session */
4146         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4147                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4148                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4149                                         tdata->key.data, tdata->key.len,
4150                                         tdata->cipher_iv.len);
4151         if (retval < 0)
4152                 return retval;
4153
4154         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4155
4156         /* Clear mbuf payload */
4157         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4158                rte_pktmbuf_tailroom(ut_params->ibuf));
4159
4160         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4161         /* Append data which is padded to a multiple of */
4162         /* the algorithms block size */
4163         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4164         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4165                                 plaintext_pad_len);
4166         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4167
4168         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4169
4170         /* Create SNOW 3G operation */
4171         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4172                                         tdata->cipher_iv.len,
4173                                         tdata->validCipherLenInBits.len,
4174                                         0);
4175         if (retval < 0)
4176                 return retval;
4177
4178         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4179                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4180                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4181         else
4182                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4183                                                 ut_params->op);
4184         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4185
4186         ut_params->obuf = ut_params->op->sym->m_dst;
4187         if (ut_params->obuf)
4188                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4189         else
4190                 ciphertext = plaintext;
4191
4192         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4193
4194         /* Validate obuf */
4195         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4196                 ciphertext,
4197                 tdata->ciphertext.data,
4198                 tdata->validDataLenInBits.len,
4199                 "SNOW 3G Ciphertext data not as expected");
4200         return 0;
4201 }
4202
4203
4204 static int
4205 test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
4206 {
4207         struct crypto_testsuite_params *ts_params = &testsuite_params;
4208         struct crypto_unittest_params *ut_params = &unittest_params;
4209         uint8_t *plaintext, *ciphertext;
4210
4211         int retval;
4212         unsigned plaintext_pad_len;
4213         unsigned plaintext_len;
4214         struct rte_cryptodev_info dev_info;
4215
4216         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4217         uint64_t feat_flags = dev_info.feature_flags;
4218
4219         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4220                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4221                 printf("Device does not support RAW data-path APIs.\n");
4222                 return -ENOTSUP;
4223         }
4224
4225         /* Verify the capabilities */
4226         struct rte_cryptodev_sym_capability_idx cap_idx;
4227         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4228         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4229         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4230                         &cap_idx) == NULL)
4231                 return TEST_SKIPPED;
4232
4233         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4234                 return TEST_SKIPPED;
4235
4236         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4237                 return TEST_SKIPPED;
4238
4239         /* Create SNOW 3G session */
4240         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4241                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4242                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4243                                         tdata->key.data, tdata->key.len,
4244                                         tdata->cipher_iv.len);
4245         if (retval < 0)
4246                 return retval;
4247
4248         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4249         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4250
4251         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4252                         "Failed to allocate input buffer in mempool");
4253         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4254                         "Failed to allocate output buffer in mempool");
4255
4256         /* Clear mbuf payload */
4257         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4258                rte_pktmbuf_tailroom(ut_params->ibuf));
4259
4260         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4261         /* Append data which is padded to a multiple of */
4262         /* the algorithms block size */
4263         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4264         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4265                                 plaintext_pad_len);
4266         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4267         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4268
4269         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4270
4271         /* Create SNOW 3G operation */
4272         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4273                                         tdata->cipher_iv.len,
4274                                         tdata->validCipherLenInBits.len,
4275                                         0);
4276         if (retval < 0)
4277                 return retval;
4278
4279         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4280                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4281                         ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4282         else
4283                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4284                                                 ut_params->op);
4285         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4286
4287         ut_params->obuf = ut_params->op->sym->m_dst;
4288         if (ut_params->obuf)
4289                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4290         else
4291                 ciphertext = plaintext;
4292
4293         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4294
4295         /* Validate obuf */
4296         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4297                 ciphertext,
4298                 tdata->ciphertext.data,
4299                 tdata->validDataLenInBits.len,
4300                 "SNOW 3G Ciphertext data not as expected");
4301         return 0;
4302 }
4303
4304 static int
4305 test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
4306 {
4307         struct crypto_testsuite_params *ts_params = &testsuite_params;
4308         struct crypto_unittest_params *ut_params = &unittest_params;
4309
4310         int retval;
4311         unsigned int plaintext_pad_len;
4312         unsigned int plaintext_len;
4313         uint8_t buffer[10000];
4314         const uint8_t *ciphertext;
4315
4316         struct rte_cryptodev_info dev_info;
4317
4318         /* Verify the capabilities */
4319         struct rte_cryptodev_sym_capability_idx cap_idx;
4320         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4321         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4322         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4323                         &cap_idx) == NULL)
4324                 return TEST_SKIPPED;
4325
4326         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4327                 return TEST_SKIPPED;
4328
4329         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4330                 return TEST_SKIPPED;
4331
4332         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4333
4334         uint64_t feat_flags = dev_info.feature_flags;
4335
4336         if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
4337                 printf("Device doesn't support out-of-place scatter-gather "
4338                                 "in both input and output mbufs. "
4339                                 "Test Skipped.\n");
4340                 return TEST_SKIPPED;
4341         }
4342
4343         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4344                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4345                 printf("Device does not support RAW data-path APIs.\n");
4346                 return -ENOTSUP;
4347         }
4348
4349         /* Create SNOW 3G session */
4350         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4351                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4352                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4353                                         tdata->key.data, tdata->key.len,
4354                                         tdata->cipher_iv.len);
4355         if (retval < 0)
4356                 return retval;
4357
4358         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4359         /* Append data which is padded to a multiple of */
4360         /* the algorithms block size */
4361         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4362
4363         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
4364                         plaintext_pad_len, 10, 0);
4365         ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
4366                         plaintext_pad_len, 3, 0);
4367
4368         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4369                         "Failed to allocate input buffer in mempool");
4370         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4371                         "Failed to allocate output buffer in mempool");
4372
4373         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
4374
4375         /* Create SNOW 3G operation */
4376         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4377                                         tdata->cipher_iv.len,
4378                                         tdata->validCipherLenInBits.len,
4379                                         0);
4380         if (retval < 0)
4381                 return retval;
4382
4383         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4384                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4385                         ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4386         else
4387                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4388                                                 ut_params->op);
4389         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4390
4391         ut_params->obuf = ut_params->op->sym->m_dst;
4392         if (ut_params->obuf)
4393                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
4394                                 plaintext_len, buffer);
4395         else
4396                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
4397                                 plaintext_len, buffer);
4398
4399         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4400
4401         /* Validate obuf */
4402         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4403                 ciphertext,
4404                 tdata->ciphertext.data,
4405                 tdata->validDataLenInBits.len,
4406                 "SNOW 3G Ciphertext data not as expected");
4407
4408         return 0;
4409 }
4410
4411 /* Shift right a buffer by "offset" bits, "offset" < 8 */
4412 static void
4413 buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset)
4414 {
4415         uint8_t curr_byte, prev_byte;
4416         uint32_t length_in_bytes = ceil_byte_length(length + offset);
4417         uint8_t lower_byte_mask = (1 << offset) - 1;
4418         unsigned i;
4419
4420         prev_byte = buffer[0];
4421         buffer[0] >>= offset;
4422
4423         for (i = 1; i < length_in_bytes; i++) {
4424                 curr_byte = buffer[i];
4425                 buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) |
4426                                 (curr_byte >> offset);
4427                 prev_byte = curr_byte;
4428         }
4429 }
4430
4431 static int
4432 test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
4433 {
4434         struct crypto_testsuite_params *ts_params = &testsuite_params;
4435         struct crypto_unittest_params *ut_params = &unittest_params;
4436         uint8_t *plaintext, *ciphertext;
4437         int retval;
4438         uint32_t plaintext_len;
4439         uint32_t plaintext_pad_len;
4440         uint8_t extra_offset = 4;
4441         uint8_t *expected_ciphertext_shifted;
4442         struct rte_cryptodev_info dev_info;
4443
4444         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4445         uint64_t feat_flags = dev_info.feature_flags;
4446
4447         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
4448                         ((tdata->validDataLenInBits.len % 8) != 0)) {
4449                 printf("Device doesn't support NON-Byte Aligned Data.\n");
4450                 return TEST_SKIPPED;
4451         }
4452
4453         /* Verify the capabilities */
4454         struct rte_cryptodev_sym_capability_idx cap_idx;
4455         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4456         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4457         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4458                         &cap_idx) == NULL)
4459                 return TEST_SKIPPED;
4460
4461         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4462                 return TEST_SKIPPED;
4463
4464         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4465                 return TEST_SKIPPED;
4466
4467         /* Create SNOW 3G session */
4468         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4469                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4470                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4471                                         tdata->key.data, tdata->key.len,
4472                                         tdata->cipher_iv.len);
4473         if (retval < 0)
4474                 return retval;
4475
4476         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4477         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4478
4479         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4480                         "Failed to allocate input buffer in mempool");
4481         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4482                         "Failed to allocate output buffer in mempool");
4483
4484         /* Clear mbuf payload */
4485         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4486                rte_pktmbuf_tailroom(ut_params->ibuf));
4487
4488         plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset);
4489         /*
4490          * Append data which is padded to a
4491          * multiple of the algorithms block size
4492          */
4493         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4494
4495         plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf,
4496                                                 plaintext_pad_len);
4497
4498         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4499
4500         memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3));
4501         buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset);
4502
4503 #ifdef RTE_APP_TEST_DEBUG
4504         rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
4505 #endif
4506         /* Create SNOW 3G operation */
4507         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4508                                         tdata->cipher_iv.len,
4509                                         tdata->validCipherLenInBits.len,
4510                                         extra_offset);
4511         if (retval < 0)
4512                 return retval;
4513
4514         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4515                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4516                         ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4517         else
4518                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4519                                                 ut_params->op);
4520         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4521
4522         ut_params->obuf = ut_params->op->sym->m_dst;
4523         if (ut_params->obuf)
4524                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4525         else
4526                 ciphertext = plaintext;
4527
4528 #ifdef RTE_APP_TEST_DEBUG
4529         rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4530 #endif
4531
4532         expected_ciphertext_shifted = rte_malloc(NULL, plaintext_len, 8);
4533
4534         TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted,
4535                         "failed to reserve memory for ciphertext shifted\n");
4536
4537         memcpy(expected_ciphertext_shifted, tdata->ciphertext.data,
4538                         ceil_byte_length(tdata->ciphertext.len));
4539         buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len,
4540                         extra_offset);
4541         /* Validate obuf */
4542         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
4543                 ciphertext,
4544                 expected_ciphertext_shifted,
4545                 tdata->validDataLenInBits.len,
4546                 extra_offset,
4547                 "SNOW 3G Ciphertext data not as expected");
4548         return 0;
4549 }
4550
4551 static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
4552 {
4553         struct crypto_testsuite_params *ts_params = &testsuite_params;
4554         struct crypto_unittest_params *ut_params = &unittest_params;
4555
4556         int retval;
4557
4558         uint8_t *plaintext, *ciphertext;
4559         unsigned ciphertext_pad_len;
4560         unsigned ciphertext_len;
4561         struct rte_cryptodev_info dev_info;
4562
4563         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4564         uint64_t feat_flags = dev_info.feature_flags;
4565
4566         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4567                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4568                 printf("Device doesn't support RAW data-path APIs.\n");
4569                 return TEST_SKIPPED;
4570         }
4571
4572         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4573                 return TEST_SKIPPED;
4574
4575         /* Verify the capabilities */
4576         struct rte_cryptodev_sym_capability_idx cap_idx;
4577         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4578         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4579         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4580                         &cap_idx) == NULL)
4581                 return TEST_SKIPPED;
4582
4583         /* Create SNOW 3G session */
4584         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4585                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4586                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4587                                         tdata->key.data, tdata->key.len,
4588                                         tdata->cipher_iv.len);
4589         if (retval < 0)
4590                 return retval;
4591
4592         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4593
4594         /* Clear mbuf payload */
4595         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4596                rte_pktmbuf_tailroom(ut_params->ibuf));
4597
4598         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4599         /* Append data which is padded to a multiple of */
4600         /* the algorithms block size */
4601         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4602         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4603                                 ciphertext_pad_len);
4604         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4605
4606         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4607
4608         /* Create SNOW 3G operation */
4609         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4610                                         tdata->cipher_iv.len,
4611                                         tdata->validCipherLenInBits.len,
4612                                         tdata->cipher.offset_bits);
4613         if (retval < 0)
4614                 return retval;
4615
4616         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4617                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4618                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4619         else
4620                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4621                                                 ut_params->op);
4622         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4623         ut_params->obuf = ut_params->op->sym->m_dst;
4624         if (ut_params->obuf)
4625                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4626         else
4627                 plaintext = ciphertext;
4628
4629         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4630
4631         /* Validate obuf */
4632         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4633                                 tdata->plaintext.data,
4634                                 tdata->validDataLenInBits.len,
4635                                 "SNOW 3G Plaintext data not as expected");
4636         return 0;
4637 }
4638
4639 static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
4640 {
4641         struct crypto_testsuite_params *ts_params = &testsuite_params;
4642         struct crypto_unittest_params *ut_params = &unittest_params;
4643
4644         int retval;
4645
4646         uint8_t *plaintext, *ciphertext;
4647         unsigned ciphertext_pad_len;
4648         unsigned ciphertext_len;
4649         struct rte_cryptodev_info dev_info;
4650
4651         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4652         uint64_t feat_flags = dev_info.feature_flags;
4653
4654         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4655                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4656                 printf("Device does not support RAW data-path APIs.\n");
4657                 return -ENOTSUP;
4658         }
4659         /* Verify the capabilities */
4660         struct rte_cryptodev_sym_capability_idx cap_idx;
4661         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4662         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4663         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4664                         &cap_idx) == NULL)
4665                 return TEST_SKIPPED;
4666
4667         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4668                 return TEST_SKIPPED;
4669
4670         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4671                 return TEST_SKIPPED;
4672
4673         /* Create SNOW 3G session */
4674         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4675                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4676                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4677                                         tdata->key.data, tdata->key.len,
4678                                         tdata->cipher_iv.len);
4679         if (retval < 0)
4680                 return retval;
4681
4682         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4683         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4684
4685         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4686                         "Failed to allocate input buffer");
4687         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4688                         "Failed to allocate output buffer");
4689
4690         /* Clear mbuf payload */
4691         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4692                rte_pktmbuf_tailroom(ut_params->ibuf));
4693
4694         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
4695                        rte_pktmbuf_tailroom(ut_params->obuf));
4696
4697         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4698         /* Append data which is padded to a multiple of */
4699         /* the algorithms block size */
4700         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4701         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4702                                 ciphertext_pad_len);
4703         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4704         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4705
4706         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4707
4708         /* Create SNOW 3G operation */
4709         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4710                                         tdata->cipher_iv.len,
4711                                         tdata->validCipherLenInBits.len,
4712                                         0);
4713         if (retval < 0)
4714                 return retval;
4715
4716         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4717                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4718                         ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4719         else
4720                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4721                                                 ut_params->op);
4722         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4723         ut_params->obuf = ut_params->op->sym->m_dst;
4724         if (ut_params->obuf)
4725                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4726         else
4727                 plaintext = ciphertext;
4728
4729         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4730
4731         /* Validate obuf */
4732         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4733                                 tdata->plaintext.data,
4734                                 tdata->validDataLenInBits.len,
4735                                 "SNOW 3G Plaintext data not as expected");
4736         return 0;
4737 }
4738
4739 static int
4740 test_zuc_cipher_auth(const struct wireless_test_data *tdata)
4741 {
4742         struct crypto_testsuite_params *ts_params = &testsuite_params;
4743         struct crypto_unittest_params *ut_params = &unittest_params;
4744
4745         int retval;
4746
4747         uint8_t *plaintext, *ciphertext;
4748         unsigned int plaintext_pad_len;
4749         unsigned int plaintext_len;
4750
4751         struct rte_cryptodev_info dev_info;
4752         struct rte_cryptodev_sym_capability_idx cap_idx;
4753
4754         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4755         uint64_t feat_flags = dev_info.feature_flags;
4756
4757         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
4758                         ((tdata->validAuthLenInBits.len % 8 != 0) ||
4759                         (tdata->validDataLenInBits.len % 8 != 0))) {
4760                 printf("Device doesn't support NON-Byte Aligned Data.\n");
4761                 return TEST_SKIPPED;
4762         }
4763
4764         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4765                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4766                 printf("Device doesn't support RAW data-path APIs.\n");
4767                 return TEST_SKIPPED;
4768         }
4769
4770         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4771                 return TEST_SKIPPED;
4772
4773         /* Check if device supports ZUC EEA3 */
4774         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4775         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
4776
4777         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4778                         &cap_idx) == NULL)
4779                 return TEST_SKIPPED;
4780
4781         /* Check if device supports ZUC EIA3 */
4782         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4783         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
4784
4785         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4786                         &cap_idx) == NULL)
4787                 return TEST_SKIPPED;
4788
4789         /* Create ZUC session */
4790         retval = create_zuc_cipher_auth_encrypt_generate_session(
4791                         ts_params->valid_devs[0],
4792                         tdata);
4793         if (retval != 0)
4794                 return retval;
4795         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4796
4797         /* clear mbuf payload */
4798         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4799                         rte_pktmbuf_tailroom(ut_params->ibuf));
4800
4801         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4802         /* Append data which is padded to a multiple of */
4803         /* the algorithms block size */
4804         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4805         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4806                                 plaintext_pad_len);
4807         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4808
4809         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4810
4811         /* Create ZUC operation */
4812         retval = create_zuc_cipher_hash_generate_operation(tdata);
4813         if (retval < 0)
4814                 return retval;
4815
4816         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4817                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4818                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4819         else
4820                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4821                         ut_params->op);
4822         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4823         ut_params->obuf = ut_params->op->sym->m_src;
4824         if (ut_params->obuf)
4825                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4826         else
4827                 ciphertext = plaintext;
4828
4829         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4830         /* Validate obuf */
4831         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4832                         ciphertext,
4833                         tdata->ciphertext.data,
4834                         tdata->validDataLenInBits.len,
4835                         "ZUC Ciphertext data not as expected");
4836
4837         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4838             + plaintext_pad_len;
4839
4840         /* Validate obuf */
4841         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4842                         ut_params->digest,
4843                         tdata->digest.data,
4844                         4,
4845                         "ZUC Generated auth tag not as expected");
4846         return 0;
4847 }
4848
4849 static int
4850 test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
4851 {
4852         struct crypto_testsuite_params *ts_params = &testsuite_params;
4853         struct crypto_unittest_params *ut_params = &unittest_params;
4854
4855         int retval;
4856
4857         uint8_t *plaintext, *ciphertext;
4858         unsigned plaintext_pad_len;
4859         unsigned plaintext_len;
4860         struct rte_cryptodev_info dev_info;
4861
4862         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4863         uint64_t feat_flags = dev_info.feature_flags;
4864
4865         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4866                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4867                 printf("Device doesn't support RAW data-path APIs.\n");
4868                 return TEST_SKIPPED;
4869         }
4870
4871         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4872                 return TEST_SKIPPED;
4873
4874         /* Verify the capabilities */
4875         struct rte_cryptodev_sym_capability_idx cap_idx;
4876         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4877         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
4878         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4879                         &cap_idx) == NULL)
4880                 return TEST_SKIPPED;
4881         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4882         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4883         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4884                         &cap_idx) == NULL)
4885                 return TEST_SKIPPED;
4886
4887         /* Create SNOW 3G session */
4888         retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0],
4889                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4890                         RTE_CRYPTO_AUTH_OP_GENERATE,
4891                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4892                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4893                         tdata->key.data, tdata->key.len,
4894                         tdata->auth_iv.len, tdata->digest.len,
4895                         tdata->cipher_iv.len);
4896         if (retval != 0)
4897                 return retval;
4898         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4899
4900         /* clear mbuf payload */
4901         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4902                         rte_pktmbuf_tailroom(ut_params->ibuf));
4903
4904         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4905         /* Append data which is padded to a multiple of */
4906         /* the algorithms block size */
4907         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4908         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4909                                 plaintext_pad_len);
4910         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4911
4912         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4913
4914         /* Create SNOW 3G operation */
4915         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
4916                         tdata->digest.len, tdata->auth_iv.data,
4917                         tdata->auth_iv.len,
4918                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
4919                         tdata->cipher_iv.data, tdata->cipher_iv.len,
4920                         tdata->validCipherLenInBits.len,
4921                         0,
4922                         tdata->validAuthLenInBits.len,
4923                         0
4924                         );
4925         if (retval < 0)
4926                 return retval;
4927
4928         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4929                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4930                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4931         else
4932                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4933                         ut_params->op);
4934         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4935         ut_params->obuf = ut_params->op->sym->m_src;
4936         if (ut_params->obuf)
4937                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4938         else
4939                 ciphertext = plaintext;
4940
4941         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4942         /* Validate obuf */
4943         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4944                         ciphertext,
4945                         tdata->ciphertext.data,
4946                         tdata->validDataLenInBits.len,
4947                         "SNOW 3G Ciphertext data not as expected");
4948
4949         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4950             + plaintext_pad_len;
4951
4952         /* Validate obuf */
4953         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4954                         ut_params->digest,
4955                         tdata->digest.data,
4956                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4957                         "SNOW 3G Generated auth tag not as expected");
4958         return 0;
4959 }
4960
4961 static int
4962 test_snow3g_auth_cipher(const struct snow3g_test_data *tdata,
4963         uint8_t op_mode, uint8_t verify)
4964 {
4965         struct crypto_testsuite_params *ts_params = &testsuite_params;
4966         struct crypto_unittest_params *ut_params = &unittest_params;
4967
4968         int retval;
4969
4970         uint8_t *plaintext = NULL, *ciphertext = NULL;
4971         unsigned int plaintext_pad_len;
4972         unsigned int plaintext_len;
4973         unsigned int ciphertext_pad_len;
4974         unsigned int ciphertext_len;
4975
4976         struct rte_cryptodev_info dev_info;
4977
4978         /* Verify the capabilities */
4979         struct rte_cryptodev_sym_capability_idx cap_idx;
4980         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4981         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
4982         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4983                         &cap_idx) == NULL)
4984                 return TEST_SKIPPED;
4985         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4986         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4987         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4988                         &cap_idx) == NULL)
4989                 return TEST_SKIPPED;
4990
4991         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4992                 return TEST_SKIPPED;
4993
4994         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4995
4996         uint64_t feat_flags = dev_info.feature_flags;
4997
4998         if (op_mode == OUT_OF_PLACE) {
4999                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5000                         printf("Device doesn't support digest encrypted.\n");
5001                         return TEST_SKIPPED;
5002                 }
5003                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5004                         return TEST_SKIPPED;
5005         }
5006
5007         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5008                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5009                 printf("Device doesn't support RAW data-path APIs.\n");
5010                 return TEST_SKIPPED;
5011         }
5012
5013         /* Create SNOW 3G session */
5014         retval = create_wireless_algo_auth_cipher_session(
5015                         ts_params->valid_devs[0],
5016                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5017                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5018                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5019                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5020                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
5021                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
5022                         tdata->key.data, tdata->key.len,
5023                         tdata->auth_iv.len, tdata->digest.len,
5024                         tdata->cipher_iv.len);
5025         if (retval != 0)
5026                 return retval;
5027
5028         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5029         if (op_mode == OUT_OF_PLACE)
5030                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5031
5032         /* clear mbuf payload */
5033         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5034                 rte_pktmbuf_tailroom(ut_params->ibuf));
5035         if (op_mode == OUT_OF_PLACE)
5036                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5037                         rte_pktmbuf_tailroom(ut_params->obuf));
5038
5039         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5040         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5041         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5042         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5043
5044         if (verify) {
5045                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5046                                         ciphertext_pad_len);
5047                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
5048                 if (op_mode == OUT_OF_PLACE)
5049                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
5050                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5051                         ciphertext_len);
5052         } else {
5053                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5054                                         plaintext_pad_len);
5055                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5056                 if (op_mode == OUT_OF_PLACE)
5057                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
5058                 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5059         }
5060
5061         /* Create SNOW 3G operation */
5062         retval = create_wireless_algo_auth_cipher_operation(
5063                 tdata->digest.data, tdata->digest.len,
5064                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5065                 tdata->auth_iv.data, tdata->auth_iv.len,
5066                 (tdata->digest.offset_bytes == 0 ?
5067                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5068                         : tdata->digest.offset_bytes),
5069                 tdata->validCipherLenInBits.len,
5070                 tdata->cipher.offset_bits,
5071                 tdata->validAuthLenInBits.len,
5072                 tdata->auth.offset_bits,
5073                 op_mode, 0, verify);
5074
5075         if (retval < 0)
5076                 return retval;
5077
5078         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5079                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5080                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5081         else
5082                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5083                         ut_params->op);
5084
5085         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5086
5087         ut_params->obuf = (op_mode == IN_PLACE ?
5088                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5089
5090         if (verify) {
5091                 if (ut_params->obuf)
5092                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5093                                                         uint8_t *);
5094                 else
5095                         plaintext = ciphertext +
5096                                 (tdata->cipher.offset_bits >> 3);
5097
5098                 debug_hexdump(stdout, "plaintext:", plaintext,
5099                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5100                 debug_hexdump(stdout, "plaintext expected:",
5101                         tdata->plaintext.data,
5102                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5103         } else {
5104                 if (ut_params->obuf)
5105                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5106                                                         uint8_t *);
5107                 else
5108                         ciphertext = plaintext;
5109
5110                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5111                         ciphertext_len);
5112                 debug_hexdump(stdout, "ciphertext expected:",
5113                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5114
5115                 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5116                         + (tdata->digest.offset_bytes == 0 ?
5117                 plaintext_pad_len : tdata->digest.offset_bytes);
5118
5119                 debug_hexdump(stdout, "digest:", ut_params->digest,
5120                         tdata->digest.len);
5121                 debug_hexdump(stdout, "digest expected:", tdata->digest.data,
5122                                 tdata->digest.len);
5123         }
5124
5125         /* Validate obuf */
5126         if (verify) {
5127                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5128                         plaintext,
5129                         tdata->plaintext.data,
5130                         (tdata->plaintext.len - tdata->cipher.offset_bits -
5131                          (tdata->digest.len << 3)),
5132                         tdata->cipher.offset_bits,
5133                         "SNOW 3G Plaintext data not as expected");
5134         } else {
5135                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5136                         ciphertext,
5137                         tdata->ciphertext.data,
5138                         (tdata->validDataLenInBits.len -
5139                          tdata->cipher.offset_bits),
5140                         tdata->cipher.offset_bits,
5141                         "SNOW 3G Ciphertext data not as expected");
5142
5143                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5144                         ut_params->digest,
5145                         tdata->digest.data,
5146                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5147                         "SNOW 3G Generated auth tag not as expected");
5148         }
5149         return 0;
5150 }
5151
5152 static int
5153 test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata,
5154         uint8_t op_mode, uint8_t verify)
5155 {
5156         struct crypto_testsuite_params *ts_params = &testsuite_params;
5157         struct crypto_unittest_params *ut_params = &unittest_params;
5158
5159         int retval;
5160
5161         const uint8_t *plaintext = NULL;
5162         const uint8_t *ciphertext = NULL;
5163         const uint8_t *digest = NULL;
5164         unsigned int plaintext_pad_len;
5165         unsigned int plaintext_len;
5166         unsigned int ciphertext_pad_len;
5167         unsigned int ciphertext_len;
5168         uint8_t buffer[10000];
5169         uint8_t digest_buffer[10000];
5170
5171         struct rte_cryptodev_info dev_info;
5172
5173         /* Verify the capabilities */
5174         struct rte_cryptodev_sym_capability_idx cap_idx;
5175         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5176         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
5177         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5178                         &cap_idx) == NULL)
5179                 return TEST_SKIPPED;
5180         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5181         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
5182         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5183                         &cap_idx) == NULL)
5184                 return TEST_SKIPPED;
5185
5186         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5187                 return TEST_SKIPPED;
5188
5189         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5190
5191         uint64_t feat_flags = dev_info.feature_flags;
5192
5193         if (op_mode == IN_PLACE) {
5194                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5195                         printf("Device doesn't support in-place scatter-gather "
5196                                         "in both input and output mbufs.\n");
5197                         return TEST_SKIPPED;
5198                 }
5199                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5200                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5201                         printf("Device doesn't support RAW data-path APIs.\n");
5202                         return TEST_SKIPPED;
5203                 }
5204         } else {
5205                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5206                         return TEST_SKIPPED;
5207                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5208                         printf("Device doesn't support out-of-place scatter-gather "
5209                                         "in both input and output mbufs.\n");
5210                         return TEST_SKIPPED;
5211                 }
5212                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5213                         printf("Device doesn't support digest encrypted.\n");
5214                         return TEST_SKIPPED;
5215                 }
5216         }
5217
5218         /* Create SNOW 3G session */
5219         retval = create_wireless_algo_auth_cipher_session(
5220                         ts_params->valid_devs[0],
5221                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5222                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5223                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5224                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5225                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
5226                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
5227                         tdata->key.data, tdata->key.len,
5228                         tdata->auth_iv.len, tdata->digest.len,
5229                         tdata->cipher_iv.len);
5230
5231         if (retval != 0)
5232                 return retval;
5233
5234         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5235         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5236         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5237         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5238
5239         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5240                         plaintext_pad_len, 15, 0);
5241         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5242                         "Failed to allocate input buffer in mempool");
5243
5244         if (op_mode == OUT_OF_PLACE) {
5245                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5246                                 plaintext_pad_len, 15, 0);
5247                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5248                                 "Failed to allocate output buffer in mempool");
5249         }
5250
5251         if (verify) {
5252                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
5253                         tdata->ciphertext.data);
5254                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5255                                         ciphertext_len, buffer);
5256                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5257                         ciphertext_len);
5258         } else {
5259                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5260                         tdata->plaintext.data);
5261                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5262                                         plaintext_len, buffer);
5263                 debug_hexdump(stdout, "plaintext:", plaintext,
5264                         plaintext_len);
5265         }
5266         memset(buffer, 0, sizeof(buffer));
5267
5268         /* Create SNOW 3G operation */
5269         retval = create_wireless_algo_auth_cipher_operation(
5270                 tdata->digest.data, tdata->digest.len,
5271                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5272                 tdata->auth_iv.data, tdata->auth_iv.len,
5273                 (tdata->digest.offset_bytes == 0 ?
5274                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5275                         : tdata->digest.offset_bytes),
5276                 tdata->validCipherLenInBits.len,
5277                 tdata->cipher.offset_bits,
5278                 tdata->validAuthLenInBits.len,
5279                 tdata->auth.offset_bits,
5280                 op_mode, 1, verify);
5281
5282         if (retval < 0)
5283                 return retval;
5284
5285         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5286                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5287                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5288         else
5289                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5290                         ut_params->op);
5291
5292         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5293
5294         ut_params->obuf = (op_mode == IN_PLACE ?
5295                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5296
5297         if (verify) {
5298                 if (ut_params->obuf)
5299                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
5300                                         plaintext_len, buffer);
5301                 else
5302                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5303                                         plaintext_len, buffer);
5304
5305                 debug_hexdump(stdout, "plaintext:", plaintext,
5306                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5307                 debug_hexdump(stdout, "plaintext expected:",
5308                         tdata->plaintext.data,
5309                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5310         } else {
5311                 if (ut_params->obuf)
5312                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
5313                                         ciphertext_len, buffer);
5314                 else
5315                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5316                                         ciphertext_len, buffer);
5317
5318                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5319                         ciphertext_len);
5320                 debug_hexdump(stdout, "ciphertext expected:",
5321                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5322
5323                 if (ut_params->obuf)
5324                         digest = rte_pktmbuf_read(ut_params->obuf,
5325                                 (tdata->digest.offset_bytes == 0 ?
5326                                 plaintext_pad_len : tdata->digest.offset_bytes),
5327                                 tdata->digest.len, digest_buffer);
5328                 else
5329                         digest = rte_pktmbuf_read(ut_params->ibuf,
5330                                 (tdata->digest.offset_bytes == 0 ?
5331                                 plaintext_pad_len : tdata->digest.offset_bytes),
5332                                 tdata->digest.len, digest_buffer);
5333
5334                 debug_hexdump(stdout, "digest:", digest,
5335                         tdata->digest.len);
5336                 debug_hexdump(stdout, "digest expected:",
5337                         tdata->digest.data, tdata->digest.len);
5338         }
5339
5340         /* Validate obuf */
5341         if (verify) {
5342                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5343                         plaintext,
5344                         tdata->plaintext.data,
5345                         (tdata->plaintext.len - tdata->cipher.offset_bits -
5346                          (tdata->digest.len << 3)),
5347                         tdata->cipher.offset_bits,
5348                         "SNOW 3G Plaintext data not as expected");
5349         } else {
5350                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5351                         ciphertext,
5352                         tdata->ciphertext.data,
5353                         (tdata->validDataLenInBits.len -
5354                          tdata->cipher.offset_bits),
5355                         tdata->cipher.offset_bits,
5356                         "SNOW 3G Ciphertext data not as expected");
5357
5358                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5359                         digest,
5360                         tdata->digest.data,
5361                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5362                         "SNOW 3G Generated auth tag not as expected");
5363         }
5364         return 0;
5365 }
5366
5367 static int
5368 test_kasumi_auth_cipher(const struct kasumi_test_data *tdata,
5369         uint8_t op_mode, uint8_t verify)
5370 {
5371         struct crypto_testsuite_params *ts_params = &testsuite_params;
5372         struct crypto_unittest_params *ut_params = &unittest_params;
5373
5374         int retval;
5375
5376         uint8_t *plaintext = NULL, *ciphertext = NULL;
5377         unsigned int plaintext_pad_len;
5378         unsigned int plaintext_len;
5379         unsigned int ciphertext_pad_len;
5380         unsigned int ciphertext_len;
5381
5382         struct rte_cryptodev_info dev_info;
5383
5384         /* Verify the capabilities */
5385         struct rte_cryptodev_sym_capability_idx cap_idx;
5386         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5387         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5388         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5389                         &cap_idx) == NULL)
5390                 return TEST_SKIPPED;
5391         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5392         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5393         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5394                         &cap_idx) == NULL)
5395                 return TEST_SKIPPED;
5396
5397         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5398
5399         uint64_t feat_flags = dev_info.feature_flags;
5400
5401         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5402                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5403                 printf("Device doesn't support RAW data-path APIs.\n");
5404                 return TEST_SKIPPED;
5405         }
5406
5407         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5408                 return TEST_SKIPPED;
5409
5410         if (op_mode == OUT_OF_PLACE) {
5411                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5412                         return TEST_SKIPPED;
5413                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5414                         printf("Device doesn't support digest encrypted.\n");
5415                         return TEST_SKIPPED;
5416                 }
5417         }
5418
5419         /* Create KASUMI session */
5420         retval = create_wireless_algo_auth_cipher_session(
5421                         ts_params->valid_devs[0],
5422                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5423                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5424                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5425                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5426                         RTE_CRYPTO_AUTH_KASUMI_F9,
5427                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5428                         tdata->key.data, tdata->key.len,
5429                         0, tdata->digest.len,
5430                         tdata->cipher_iv.len);
5431
5432         if (retval != 0)
5433                 return retval;
5434
5435         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5436         if (op_mode == OUT_OF_PLACE)
5437                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5438
5439         /* clear mbuf payload */
5440         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5441                 rte_pktmbuf_tailroom(ut_params->ibuf));
5442         if (op_mode == OUT_OF_PLACE)
5443                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5444                         rte_pktmbuf_tailroom(ut_params->obuf));
5445
5446         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5447         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5448         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5449         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5450
5451         if (verify) {
5452                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5453                                         ciphertext_pad_len);
5454                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
5455                 if (op_mode == OUT_OF_PLACE)
5456                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
5457                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5458                         ciphertext_len);
5459         } else {
5460                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5461                                         plaintext_pad_len);
5462                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5463                 if (op_mode == OUT_OF_PLACE)
5464                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
5465                 debug_hexdump(stdout, "plaintext:", plaintext,
5466                         plaintext_len);
5467         }
5468
5469         /* Create KASUMI operation */
5470         retval = create_wireless_algo_auth_cipher_operation(
5471                 tdata->digest.data, tdata->digest.len,
5472                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5473                 NULL, 0,
5474                 (tdata->digest.offset_bytes == 0 ?
5475                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5476                         : tdata->digest.offset_bytes),
5477                 tdata->validCipherLenInBits.len,
5478                 tdata->validCipherOffsetInBits.len,
5479                 tdata->validAuthLenInBits.len,
5480                 0,
5481                 op_mode, 0, verify);
5482
5483         if (retval < 0)
5484                 return retval;
5485
5486         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5487                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5488                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5489         else
5490                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5491                         ut_params->op);
5492
5493         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5494
5495         ut_params->obuf = (op_mode == IN_PLACE ?
5496                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5497
5498
5499         if (verify) {
5500                 if (ut_params->obuf)
5501                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5502                                                         uint8_t *);
5503                 else
5504                         plaintext = ciphertext;
5505
5506                 debug_hexdump(stdout, "plaintext:", plaintext,
5507                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5508                 debug_hexdump(stdout, "plaintext expected:",
5509                         tdata->plaintext.data,
5510                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5511         } else {
5512                 if (ut_params->obuf)
5513                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5514                                                         uint8_t *);
5515                 else
5516                         ciphertext = plaintext;
5517
5518                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5519                         ciphertext_len);
5520                 debug_hexdump(stdout, "ciphertext expected:",
5521                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5522
5523                 ut_params->digest = rte_pktmbuf_mtod(
5524                         ut_params->obuf, uint8_t *) +
5525                         (tdata->digest.offset_bytes == 0 ?
5526                         plaintext_pad_len : tdata->digest.offset_bytes);
5527
5528                 debug_hexdump(stdout, "digest:", ut_params->digest,
5529                         tdata->digest.len);
5530                 debug_hexdump(stdout, "digest expected:",
5531                         tdata->digest.data, tdata->digest.len);
5532         }
5533
5534         /* Validate obuf */
5535         if (verify) {
5536                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5537                         plaintext,
5538                         tdata->plaintext.data,
5539                         tdata->plaintext.len >> 3,
5540                         "KASUMI Plaintext data not as expected");
5541         } else {
5542                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5543                         ciphertext,
5544                         tdata->ciphertext.data,
5545                         tdata->ciphertext.len >> 3,
5546                         "KASUMI Ciphertext data not as expected");
5547
5548                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5549                         ut_params->digest,
5550                         tdata->digest.data,
5551                         DIGEST_BYTE_LENGTH_KASUMI_F9,
5552                         "KASUMI Generated auth tag not as expected");
5553         }
5554         return 0;
5555 }
5556
5557 static int
5558 test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata,
5559         uint8_t op_mode, uint8_t verify)
5560 {
5561         struct crypto_testsuite_params *ts_params = &testsuite_params;
5562         struct crypto_unittest_params *ut_params = &unittest_params;
5563
5564         int retval;
5565
5566         const uint8_t *plaintext = NULL;
5567         const uint8_t *ciphertext = NULL;
5568         const uint8_t *digest = NULL;
5569         unsigned int plaintext_pad_len;
5570         unsigned int plaintext_len;
5571         unsigned int ciphertext_pad_len;
5572         unsigned int ciphertext_len;
5573         uint8_t buffer[10000];
5574         uint8_t digest_buffer[10000];
5575
5576         struct rte_cryptodev_info dev_info;
5577
5578         /* Verify the capabilities */
5579         struct rte_cryptodev_sym_capability_idx cap_idx;
5580         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5581         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5582         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5583                         &cap_idx) == NULL)
5584                 return TEST_SKIPPED;
5585         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5586         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5587         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5588                         &cap_idx) == NULL)
5589                 return TEST_SKIPPED;
5590
5591         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5592                 return TEST_SKIPPED;
5593
5594         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5595
5596         uint64_t feat_flags = dev_info.feature_flags;
5597
5598         if (op_mode == IN_PLACE) {
5599                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5600                         printf("Device doesn't support in-place scatter-gather "
5601                                         "in both input and output mbufs.\n");
5602                         return TEST_SKIPPED;
5603                 }
5604                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5605                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5606                         printf("Device doesn't support RAW data-path APIs.\n");
5607                         return TEST_SKIPPED;
5608                 }
5609         } else {
5610                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5611                         return TEST_SKIPPED;
5612                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5613                         printf("Device doesn't support out-of-place scatter-gather "
5614                                         "in both input and output mbufs.\n");
5615                         return TEST_SKIPPED;
5616                 }
5617                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5618                         printf("Device doesn't support digest encrypted.\n");
5619                         return TEST_SKIPPED;
5620                 }
5621         }
5622
5623         /* Create KASUMI session */
5624         retval = create_wireless_algo_auth_cipher_session(
5625                         ts_params->valid_devs[0],
5626                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5627                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5628                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5629                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5630                         RTE_CRYPTO_AUTH_KASUMI_F9,
5631                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5632                         tdata->key.data, tdata->key.len,
5633                         0, tdata->digest.len,
5634                         tdata->cipher_iv.len);
5635
5636         if (retval != 0)
5637                 return retval;
5638
5639         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5640         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5641         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5642         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5643
5644         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5645                         plaintext_pad_len, 15, 0);
5646         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5647                         "Failed to allocate input buffer in mempool");
5648
5649         if (op_mode == OUT_OF_PLACE) {
5650                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5651                                 plaintext_pad_len, 15, 0);
5652                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5653                                 "Failed to allocate output buffer in mempool");
5654         }
5655
5656         if (verify) {
5657                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
5658                         tdata->ciphertext.data);
5659                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5660                                         ciphertext_len, buffer);
5661                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5662                         ciphertext_len);
5663         } else {
5664                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5665                         tdata->plaintext.data);
5666                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5667                                         plaintext_len, buffer);
5668                 debug_hexdump(stdout, "plaintext:", plaintext,
5669                         plaintext_len);
5670         }
5671         memset(buffer, 0, sizeof(buffer));
5672
5673         /* Create KASUMI operation */
5674         retval = create_wireless_algo_auth_cipher_operation(
5675                 tdata->digest.data, tdata->digest.len,
5676                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5677                 NULL, 0,
5678                 (tdata->digest.offset_bytes == 0 ?
5679                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5680                         : tdata->digest.offset_bytes),
5681                 tdata->validCipherLenInBits.len,
5682                 tdata->validCipherOffsetInBits.len,
5683                 tdata->validAuthLenInBits.len,
5684                 0,
5685                 op_mode, 1, verify);
5686
5687         if (retval < 0)
5688                 return retval;
5689
5690         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5691                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5692                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5693         else
5694                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5695                         ut_params->op);
5696
5697         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5698
5699         ut_params->obuf = (op_mode == IN_PLACE ?
5700                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5701
5702         if (verify) {
5703                 if (ut_params->obuf)
5704                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
5705                                         plaintext_len, buffer);
5706                 else
5707                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5708                                         plaintext_len, buffer);
5709
5710                 debug_hexdump(stdout, "plaintext:", plaintext,
5711                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5712                 debug_hexdump(stdout, "plaintext expected:",
5713                         tdata->plaintext.data,
5714                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5715         } else {
5716                 if (ut_params->obuf)
5717                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
5718                                         ciphertext_len, buffer);
5719                 else
5720                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5721                                         ciphertext_len, buffer);
5722
5723                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5724                         ciphertext_len);
5725                 debug_hexdump(stdout, "ciphertext expected:",
5726                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5727
5728                 if (ut_params->obuf)
5729                         digest = rte_pktmbuf_read(ut_params->obuf,
5730                                 (tdata->digest.offset_bytes == 0 ?
5731                                 plaintext_pad_len : tdata->digest.offset_bytes),
5732                                 tdata->digest.len, digest_buffer);
5733                 else
5734                         digest = rte_pktmbuf_read(ut_params->ibuf,
5735                                 (tdata->digest.offset_bytes == 0 ?
5736                                 plaintext_pad_len : tdata->digest.offset_bytes),
5737                                 tdata->digest.len, digest_buffer);
5738
5739                 debug_hexdump(stdout, "digest:", digest,
5740                         tdata->digest.len);
5741                 debug_hexdump(stdout, "digest expected:",
5742                         tdata->digest.data, tdata->digest.len);
5743         }
5744
5745         /* Validate obuf */
5746         if (verify) {
5747                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5748                         plaintext,
5749                         tdata->plaintext.data,
5750                         tdata->plaintext.len >> 3,
5751                         "KASUMI Plaintext data not as expected");
5752         } else {
5753                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5754                         ciphertext,
5755                         tdata->ciphertext.data,
5756                         tdata->validDataLenInBits.len,
5757                         "KASUMI Ciphertext data not as expected");
5758
5759                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5760                         digest,
5761                         tdata->digest.data,
5762                         DIGEST_BYTE_LENGTH_KASUMI_F9,
5763                         "KASUMI Generated auth tag not as expected");
5764         }
5765         return 0;
5766 }
5767
5768 static int
5769 test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
5770 {
5771         struct crypto_testsuite_params *ts_params = &testsuite_params;
5772         struct crypto_unittest_params *ut_params = &unittest_params;
5773
5774         int retval;
5775
5776         uint8_t *plaintext, *ciphertext;
5777         unsigned plaintext_pad_len;
5778         unsigned plaintext_len;
5779         struct rte_cryptodev_info dev_info;
5780
5781         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5782         uint64_t feat_flags = dev_info.feature_flags;
5783
5784         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5785                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5786                 printf("Device doesn't support RAW data-path APIs.\n");
5787                 return TEST_SKIPPED;
5788         }
5789
5790         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5791                 return TEST_SKIPPED;
5792
5793         /* Verify the capabilities */
5794         struct rte_cryptodev_sym_capability_idx cap_idx;
5795         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5796         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5797         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5798                         &cap_idx) == NULL)
5799                 return TEST_SKIPPED;
5800         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5801         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5802         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5803                         &cap_idx) == NULL)
5804                 return TEST_SKIPPED;
5805
5806         /* Create KASUMI session */
5807         retval = create_wireless_algo_cipher_auth_session(
5808                         ts_params->valid_devs[0],
5809                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5810                         RTE_CRYPTO_AUTH_OP_GENERATE,
5811                         RTE_CRYPTO_AUTH_KASUMI_F9,
5812                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5813                         tdata->key.data, tdata->key.len,
5814                         0, tdata->digest.len,
5815                         tdata->cipher_iv.len);
5816         if (retval != 0)
5817                 return retval;
5818
5819         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5820
5821         /* clear mbuf payload */
5822         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5823                         rte_pktmbuf_tailroom(ut_params->ibuf));
5824
5825         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5826         /* Append data which is padded to a multiple of */
5827         /* the algorithms block size */
5828         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5829         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5830                                 plaintext_pad_len);
5831         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5832
5833         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5834
5835         /* Create KASUMI operation */
5836         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
5837                                 tdata->digest.len, NULL, 0,
5838                                 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
5839                                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5840                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
5841                                 tdata->validCipherOffsetInBits.len,
5842                                 tdata->validAuthLenInBits.len,
5843                                 0
5844                                 );
5845         if (retval < 0)
5846                 return retval;
5847
5848         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5849                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5850                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5851         else
5852                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5853                         ut_params->op);
5854         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5855
5856         if (ut_params->op->sym->m_dst)
5857                 ut_params->obuf = ut_params->op->sym->m_dst;
5858         else
5859                 ut_params->obuf = ut_params->op->sym->m_src;
5860
5861         ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
5862                                 tdata->validCipherOffsetInBits.len >> 3);
5863
5864         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5865                         + plaintext_pad_len;
5866
5867         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
5868                                 (tdata->validCipherOffsetInBits.len >> 3);
5869         /* Validate obuf */
5870         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5871                 ciphertext,
5872                 reference_ciphertext,
5873                 tdata->validCipherLenInBits.len,
5874                 "KASUMI Ciphertext data not as expected");
5875
5876         /* Validate obuf */
5877         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5878                 ut_params->digest,
5879                 tdata->digest.data,
5880                 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5881                 "KASUMI Generated auth tag not as expected");
5882         return 0;
5883 }
5884
5885 static int
5886 check_cipher_capability(const struct crypto_testsuite_params *ts_params,
5887                         const enum rte_crypto_cipher_algorithm cipher_algo,
5888                         const uint16_t key_size, const uint16_t iv_size)
5889 {
5890         struct rte_cryptodev_sym_capability_idx cap_idx;
5891         const struct rte_cryptodev_symmetric_capability *cap;
5892
5893         /* Check if device supports the algorithm */
5894         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5895         cap_idx.algo.cipher = cipher_algo;
5896
5897         cap = rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5898                         &cap_idx);
5899
5900         if (cap == NULL)
5901                 return -1;
5902
5903         /* Check if device supports key size and IV size */
5904         if (rte_cryptodev_sym_capability_check_cipher(cap, key_size,
5905                         iv_size) < 0) {
5906                 return -1;
5907         }
5908
5909         return 0;
5910 }
5911
5912 static int
5913 check_auth_capability(const struct crypto_testsuite_params *ts_params,
5914                         const enum rte_crypto_auth_algorithm auth_algo,
5915                         const uint16_t key_size, const uint16_t iv_size,
5916                         const uint16_t tag_size)
5917 {
5918         struct rte_cryptodev_sym_capability_idx cap_idx;
5919         const struct rte_cryptodev_symmetric_capability *cap;
5920
5921         /* Check if device supports the algorithm */
5922         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5923         cap_idx.algo.auth = auth_algo;
5924
5925         cap = rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5926                         &cap_idx);
5927
5928         if (cap == NULL)
5929                 return -1;
5930
5931         /* Check if device supports key size and IV size */
5932         if (rte_cryptodev_sym_capability_check_auth(cap, key_size,
5933                         tag_size, iv_size) < 0) {
5934                 return -1;
5935         }
5936
5937         return 0;
5938 }
5939
5940 static int
5941 test_zuc_encryption(const struct wireless_test_data *tdata)
5942 {
5943         struct crypto_testsuite_params *ts_params = &testsuite_params;
5944         struct crypto_unittest_params *ut_params = &unittest_params;
5945
5946         int retval;
5947         uint8_t *plaintext, *ciphertext;
5948         unsigned plaintext_pad_len;
5949         unsigned plaintext_len;
5950         struct rte_cryptodev_info dev_info;
5951
5952         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5953         uint64_t feat_flags = dev_info.feature_flags;
5954
5955         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5956                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5957                 printf("Device doesn't support RAW data-path APIs.\n");
5958                 return TEST_SKIPPED;
5959         }
5960
5961         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5962                 return TEST_SKIPPED;
5963
5964         /* Check if device supports ZUC EEA3 */
5965         if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
5966                         tdata->key.len, tdata->cipher_iv.len) < 0)
5967                 return TEST_SKIPPED;
5968
5969         /* Create ZUC session */
5970         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
5971                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5972                                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
5973                                         tdata->key.data, tdata->key.len,
5974                                         tdata->cipher_iv.len);
5975         if (retval != 0)
5976                 return retval;
5977
5978         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5979
5980         /* Clear mbuf payload */
5981         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5982                rte_pktmbuf_tailroom(ut_params->ibuf));
5983
5984         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5985         /* Append data which is padded to a multiple */
5986         /* of the algorithms block size */
5987         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
5988         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5989                                 plaintext_pad_len);
5990         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5991
5992         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5993
5994         /* Create ZUC operation */
5995         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
5996                                         tdata->cipher_iv.len,
5997                                         tdata->plaintext.len,
5998                                         0);
5999         if (retval < 0)
6000                 return retval;
6001
6002         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6003                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6004                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
6005         else
6006                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6007                                                 ut_params->op);
6008         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6009
6010         ut_params->obuf = ut_params->op->sym->m_dst;
6011         if (ut_params->obuf)
6012                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
6013         else
6014                 ciphertext = plaintext;
6015
6016         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
6017
6018         /* Validate obuf */
6019         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6020                 ciphertext,
6021                 tdata->ciphertext.data,
6022                 tdata->validCipherLenInBits.len,
6023                 "ZUC Ciphertext data not as expected");
6024         return 0;
6025 }
6026
6027 static int
6028 test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
6029 {
6030         struct crypto_testsuite_params *ts_params = &testsuite_params;
6031         struct crypto_unittest_params *ut_params = &unittest_params;
6032
6033         int retval;
6034
6035         unsigned int plaintext_pad_len;
6036         unsigned int plaintext_len;
6037         const uint8_t *ciphertext;
6038         uint8_t ciphertext_buffer[2048];
6039         struct rte_cryptodev_info dev_info;
6040
6041         /* Check if device supports ZUC EEA3 */
6042         if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
6043                         tdata->key.len, tdata->cipher_iv.len) < 0)
6044                 return TEST_SKIPPED;
6045
6046         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
6047                 return TEST_SKIPPED;
6048
6049         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6050
6051         uint64_t feat_flags = dev_info.feature_flags;
6052
6053         if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6054                 printf("Device doesn't support in-place scatter-gather. "
6055                                 "Test Skipped.\n");
6056                 return TEST_SKIPPED;
6057         }
6058
6059         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6060                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6061                 printf("Device doesn't support RAW data-path APIs.\n");
6062                 return TEST_SKIPPED;
6063         }
6064
6065         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6066
6067         /* Append data which is padded to a multiple */
6068         /* of the algorithms block size */
6069         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
6070
6071         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
6072                         plaintext_pad_len, 10, 0);
6073
6074         pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
6075                         tdata->plaintext.data);
6076
6077         /* Create ZUC session */
6078         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
6079                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
6080                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
6081                         tdata->key.data, tdata->key.len,
6082                         tdata->cipher_iv.len);
6083         if (retval < 0)
6084                 return retval;
6085
6086         /* Clear mbuf payload */
6087
6088         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
6089
6090         /* Create ZUC operation */
6091         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
6092                         tdata->cipher_iv.len, tdata->plaintext.len,
6093                         0);
6094         if (retval < 0)
6095                 return retval;
6096
6097         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6098                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6099                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
6100         else
6101                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6102                                                 ut_params->op);
6103         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6104
6105         ut_params->obuf = ut_params->op->sym->m_dst;
6106         if (ut_params->obuf)
6107                 ciphertext = rte_pktmbuf_read(ut_params->obuf,
6108                         0, plaintext_len, ciphertext_buffer);
6109         else
6110                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
6111                         0, plaintext_len, ciphertext_buffer);
6112
6113         /* Validate obuf */
6114         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
6115
6116         /* Validate obuf */
6117         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6118                 ciphertext,
6119                 tdata->ciphertext.data,
6120                 tdata->validCipherLenInBits.len,
6121                 "ZUC Ciphertext data not as expected");
6122
6123         return 0;
6124 }
6125
6126 static int
6127 test_zuc_authentication(const struct wireless_test_data *tdata)
6128 {
6129         struct crypto_testsuite_params *ts_params = &testsuite_params;
6130         struct crypto_unittest_params *ut_params = &unittest_params;
6131
6132         int retval;
6133         unsigned plaintext_pad_len;
6134         unsigned plaintext_len;
6135         uint8_t *plaintext;
6136
6137         struct rte_cryptodev_info dev_info;
6138
6139         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6140         uint64_t feat_flags = dev_info.feature_flags;
6141
6142         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
6143                         (tdata->validAuthLenInBits.len % 8 != 0)) {
6144                 printf("Device doesn't support NON-Byte Aligned Data.\n");
6145                 return TEST_SKIPPED;
6146         }
6147
6148         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6149                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6150                 printf("Device doesn't support RAW data-path APIs.\n");
6151                 return TEST_SKIPPED;
6152         }
6153
6154         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
6155                 return TEST_SKIPPED;
6156
6157         /* Check if device supports ZUC EIA3 */
6158         if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3,
6159                         tdata->key.len, tdata->auth_iv.len,
6160                         tdata->digest.len) < 0)
6161                 return TEST_SKIPPED;
6162
6163         /* Create ZUC session */
6164         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
6165                         tdata->key.data, tdata->key.len,
6166                         tdata->auth_iv.len, tdata->digest.len,
6167                         RTE_CRYPTO_AUTH_OP_GENERATE,
6168                         RTE_CRYPTO_AUTH_ZUC_EIA3);
6169         if (retval != 0)
6170                 return retval;
6171
6172         /* alloc mbuf and set payload */
6173         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6174
6175         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6176         rte_pktmbuf_tailroom(ut_params->ibuf));
6177
6178         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6179         /* Append data which is padded to a multiple of */
6180         /* the algorithms block size */
6181         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
6182         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6183                                 plaintext_pad_len);
6184         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6185
6186         /* Create ZUC operation */
6187         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
6188                         tdata->auth_iv.data, tdata->auth_iv.len,
6189                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
6190                         tdata->validAuthLenInBits.len,
6191                         0);
6192         if (retval < 0)
6193                 return retval;
6194
6195         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6196                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6197                                 ut_params->op, 0, 1, 1, 0);
6198         else
6199                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6200                                 ut_params->op);
6201         ut_params->obuf = ut_params->op->sym->m_src;
6202         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6203         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
6204                         + plaintext_pad_len;
6205
6206         /* Validate obuf */
6207         TEST_ASSERT_BUFFERS_ARE_EQUAL(
6208         ut_params->digest,
6209         tdata->digest.data,
6210         tdata->digest.len,
6211         "ZUC Generated auth tag not as expected");
6212
6213         return 0;
6214 }
6215
6216 static int
6217 test_zuc_auth_cipher(const struct wireless_test_data *tdata,
6218         uint8_t op_mode, uint8_t verify)
6219 {
6220         struct crypto_testsuite_params *ts_params = &testsuite_params;
6221         struct crypto_unittest_params *ut_params = &unittest_params;
6222
6223         int retval;
6224
6225         uint8_t *plaintext = NULL, *ciphertext = NULL;
6226         unsigned int plaintext_pad_len;
6227         unsigned int plaintext_len;
6228         unsigned int ciphertext_pad_len;
6229         unsigned int ciphertext_len;
6230
6231         struct rte_cryptodev_info dev_info;
6232
6233         /* Check if device supports ZUC EEA3 */
6234         if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
6235                         tdata->key.len, tdata->cipher_iv.len) < 0)
6236                 return TEST_SKIPPED;
6237
6238         /* Check if device supports ZUC EIA3 */
6239         if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3,
6240                         tdata->key.len, tdata->auth_iv.len,
6241                         tdata->digest.len) < 0)
6242                 return TEST_SKIPPED;
6243
6244         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6245
6246         uint64_t feat_flags = dev_info.feature_flags;
6247
6248         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6249                 printf("Device doesn't support digest encrypted.\n");
6250                 return TEST_SKIPPED;
6251         }
6252         if (op_mode == IN_PLACE) {
6253                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6254                         printf("Device doesn't support in-place scatter-gather "
6255                                         "in both input and output mbufs.\n");
6256                         return TEST_SKIPPED;
6257                 }
6258
6259                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6260                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6261                         printf("Device doesn't support RAW data-path APIs.\n");
6262                         return TEST_SKIPPED;
6263                 }
6264         } else {
6265                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6266                         return TEST_SKIPPED;
6267                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
6268                         printf("Device doesn't support out-of-place scatter-gather "
6269                                         "in both input and output mbufs.\n");
6270                         return TEST_SKIPPED;
6271                 }
6272         }
6273
6274         /* Create ZUC session */
6275         retval = create_wireless_algo_auth_cipher_session(
6276                         ts_params->valid_devs[0],
6277                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
6278                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
6279                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
6280                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
6281                         RTE_CRYPTO_AUTH_ZUC_EIA3,
6282                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
6283                         tdata->key.data, tdata->key.len,
6284                         tdata->auth_iv.len, tdata->digest.len,
6285                         tdata->cipher_iv.len);
6286
6287         if (retval != 0)
6288                 return retval;
6289
6290         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6291         if (op_mode == OUT_OF_PLACE)
6292                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6293
6294         /* clear mbuf payload */
6295         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6296                 rte_pktmbuf_tailroom(ut_params->ibuf));
6297         if (op_mode == OUT_OF_PLACE)
6298                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
6299                         rte_pktmbuf_tailroom(ut_params->obuf));
6300
6301         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
6302         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6303         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6304         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6305
6306         if (verify) {
6307                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6308                                         ciphertext_pad_len);
6309                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
6310                 if (op_mode == OUT_OF_PLACE)
6311                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
6312                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6313                         ciphertext_len);
6314         } else {
6315                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6316                                         plaintext_pad_len);
6317                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6318                 if (op_mode == OUT_OF_PLACE)
6319                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
6320                 debug_hexdump(stdout, "plaintext:", plaintext,
6321                         plaintext_len);
6322         }
6323
6324         /* Create ZUC operation */
6325         retval = create_wireless_algo_auth_cipher_operation(
6326                 tdata->digest.data, tdata->digest.len,
6327                 tdata->cipher_iv.data, tdata->cipher_iv.len,
6328                 tdata->auth_iv.data, tdata->auth_iv.len,
6329                 (tdata->digest.offset_bytes == 0 ?
6330                 (verify ? ciphertext_pad_len : plaintext_pad_len)
6331                         : tdata->digest.offset_bytes),
6332                 tdata->validCipherLenInBits.len,
6333                 tdata->validCipherOffsetInBits.len,
6334                 tdata->validAuthLenInBits.len,
6335                 0,
6336                 op_mode, 0, verify);
6337
6338         if (retval < 0)
6339                 return retval;
6340
6341         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6342                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6343                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
6344         else
6345                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6346                         ut_params->op);
6347
6348         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6349
6350         ut_params->obuf = (op_mode == IN_PLACE ?
6351                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6352
6353
6354         if (verify) {
6355                 if (ut_params->obuf)
6356                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
6357                                                         uint8_t *);
6358                 else
6359                         plaintext = ciphertext;
6360
6361                 debug_hexdump(stdout, "plaintext:", plaintext,
6362                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6363                 debug_hexdump(stdout, "plaintext expected:",
6364                         tdata->plaintext.data,
6365                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6366         } else {
6367                 if (ut_params->obuf)
6368                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
6369                                                         uint8_t *);
6370                 else
6371                         ciphertext = plaintext;
6372
6373                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6374                         ciphertext_len);
6375                 debug_hexdump(stdout, "ciphertext expected:",
6376                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
6377
6378                 ut_params->digest = rte_pktmbuf_mtod(
6379                         ut_params->obuf, uint8_t *) +
6380                         (tdata->digest.offset_bytes == 0 ?
6381                         plaintext_pad_len : tdata->digest.offset_bytes);
6382
6383                 debug_hexdump(stdout, "digest:", ut_params->digest,
6384                         tdata->digest.len);
6385                 debug_hexdump(stdout, "digest expected:",
6386                         tdata->digest.data, tdata->digest.len);
6387         }
6388
6389         /* Validate obuf */
6390         if (verify) {
6391                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6392                         plaintext,
6393                         tdata->plaintext.data,
6394                         tdata->plaintext.len >> 3,
6395                         "ZUC Plaintext data not as expected");
6396         } else {
6397                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6398                         ciphertext,
6399                         tdata->ciphertext.data,
6400                         tdata->ciphertext.len >> 3,
6401                         "ZUC Ciphertext data not as expected");
6402
6403                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6404                         ut_params->digest,
6405                         tdata->digest.data,
6406                         DIGEST_BYTE_LENGTH_KASUMI_F9,
6407                         "ZUC Generated auth tag not as expected");
6408         }
6409         return 0;
6410 }
6411
6412 static int
6413 test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata,
6414         uint8_t op_mode, uint8_t verify)
6415 {
6416         struct crypto_testsuite_params *ts_params = &testsuite_params;
6417         struct crypto_unittest_params *ut_params = &unittest_params;
6418
6419         int retval;
6420
6421         const uint8_t *plaintext = NULL;
6422         const uint8_t *ciphertext = NULL;
6423         const uint8_t *digest = NULL;
6424         unsigned int plaintext_pad_len;
6425         unsigned int plaintext_len;
6426         unsigned int ciphertext_pad_len;
6427         unsigned int ciphertext_len;
6428         uint8_t buffer[10000];
6429         uint8_t digest_buffer[10000];
6430
6431         struct rte_cryptodev_info dev_info;
6432
6433         /* Check if device supports ZUC EEA3 */
6434         if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
6435                         tdata->key.len, tdata->cipher_iv.len) < 0)
6436                 return TEST_SKIPPED;
6437
6438         /* Check if device supports ZUC EIA3 */
6439         if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3,
6440                         tdata->key.len, tdata->auth_iv.len,
6441                         tdata->digest.len) < 0)
6442                 return TEST_SKIPPED;
6443
6444         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6445
6446         uint64_t feat_flags = dev_info.feature_flags;
6447
6448         if (op_mode == IN_PLACE) {
6449                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6450                         printf("Device doesn't support in-place scatter-gather "
6451                                         "in both input and output mbufs.\n");
6452                         return TEST_SKIPPED;
6453                 }
6454
6455                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6456                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6457                         printf("Device doesn't support RAW data-path APIs.\n");
6458                         return TEST_SKIPPED;
6459                 }
6460         } else {
6461                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6462                         return TEST_SKIPPED;
6463                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
6464                         printf("Device doesn't support out-of-place scatter-gather "
6465                                         "in both input and output mbufs.\n");
6466                         return TEST_SKIPPED;
6467                 }
6468                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6469                         printf("Device doesn't support digest encrypted.\n");
6470                         return TEST_SKIPPED;
6471                 }
6472         }
6473
6474         /* Create ZUC session */
6475         retval = create_wireless_algo_auth_cipher_session(
6476                         ts_params->valid_devs[0],
6477                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
6478                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
6479                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
6480                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
6481                         RTE_CRYPTO_AUTH_ZUC_EIA3,
6482                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
6483                         tdata->key.data, tdata->key.len,
6484                         tdata->auth_iv.len, tdata->digest.len,
6485                         tdata->cipher_iv.len);
6486
6487         if (retval != 0)
6488                 return retval;
6489
6490         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
6491         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6492         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6493         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6494
6495         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
6496                         plaintext_pad_len, 15, 0);
6497         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
6498                         "Failed to allocate input buffer in mempool");
6499
6500         if (op_mode == OUT_OF_PLACE) {
6501                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
6502                                 plaintext_pad_len, 15, 0);
6503                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
6504                                 "Failed to allocate output buffer in mempool");
6505         }
6506
6507         if (verify) {
6508                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
6509                         tdata->ciphertext.data);
6510                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6511                                         ciphertext_len, buffer);
6512                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6513                         ciphertext_len);
6514         } else {
6515                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
6516                         tdata->plaintext.data);
6517                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6518                                         plaintext_len, buffer);
6519                 debug_hexdump(stdout, "plaintext:", plaintext,
6520                         plaintext_len);
6521         }
6522         memset(buffer, 0, sizeof(buffer));
6523
6524         /* Create ZUC operation */
6525         retval = create_wireless_algo_auth_cipher_operation(
6526                 tdata->digest.data, tdata->digest.len,
6527                 tdata->cipher_iv.data, tdata->cipher_iv.len,
6528                 NULL, 0,
6529                 (tdata->digest.offset_bytes == 0 ?
6530                 (verify ? ciphertext_pad_len : plaintext_pad_len)
6531                         : tdata->digest.offset_bytes),
6532                 tdata->validCipherLenInBits.len,
6533                 tdata->validCipherOffsetInBits.len,
6534                 tdata->validAuthLenInBits.len,
6535                 0,
6536                 op_mode, 1, verify);
6537
6538         if (retval < 0)
6539                 return retval;
6540
6541         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6542                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6543                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
6544         else
6545                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6546                         ut_params->op);
6547
6548         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6549
6550         ut_params->obuf = (op_mode == IN_PLACE ?
6551                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6552
6553         if (verify) {
6554                 if (ut_params->obuf)
6555                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
6556                                         plaintext_len, buffer);
6557                 else
6558                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6559                                         plaintext_len, buffer);
6560
6561                 debug_hexdump(stdout, "plaintext:", plaintext,
6562                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6563                 debug_hexdump(stdout, "plaintext expected:",
6564                         tdata->plaintext.data,
6565                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6566         } else {
6567                 if (ut_params->obuf)
6568                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
6569                                         ciphertext_len, buffer);
6570                 else
6571                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6572                                         ciphertext_len, buffer);
6573
6574                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6575                         ciphertext_len);
6576                 debug_hexdump(stdout, "ciphertext expected:",
6577                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
6578
6579                 if (ut_params->obuf)
6580                         digest = rte_pktmbuf_read(ut_params->obuf,
6581                                 (tdata->digest.offset_bytes == 0 ?
6582                                 plaintext_pad_len : tdata->digest.offset_bytes),
6583                                 tdata->digest.len, digest_buffer);
6584                 else
6585                         digest = rte_pktmbuf_read(ut_params->ibuf,
6586                                 (tdata->digest.offset_bytes == 0 ?
6587                                 plaintext_pad_len : tdata->digest.offset_bytes),
6588                                 tdata->digest.len, digest_buffer);
6589
6590                 debug_hexdump(stdout, "digest:", digest,
6591                         tdata->digest.len);
6592                 debug_hexdump(stdout, "digest expected:",
6593                         tdata->digest.data, tdata->digest.len);
6594         }
6595
6596         /* Validate obuf */
6597         if (verify) {
6598                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6599                         plaintext,
6600                         tdata->plaintext.data,
6601                         tdata->plaintext.len >> 3,
6602                         "ZUC Plaintext data not as expected");
6603         } else {
6604                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6605                         ciphertext,
6606                         tdata->ciphertext.data,
6607                         tdata->validDataLenInBits.len,
6608                         "ZUC Ciphertext data not as expected");
6609
6610                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6611                         digest,
6612                         tdata->digest.data,
6613                         DIGEST_BYTE_LENGTH_KASUMI_F9,
6614                         "ZUC Generated auth tag not as expected");
6615         }
6616         return 0;
6617 }
6618
6619 static int
6620 test_kasumi_encryption_test_case_1(void)
6621 {
6622         return test_kasumi_encryption(&kasumi_test_case_1);
6623 }
6624
6625 static int
6626 test_kasumi_encryption_test_case_1_sgl(void)
6627 {
6628         return test_kasumi_encryption_sgl(&kasumi_test_case_1);
6629 }
6630
6631 static int
6632 test_kasumi_encryption_test_case_1_oop(void)
6633 {
6634         return test_kasumi_encryption_oop(&kasumi_test_case_1);
6635 }
6636
6637 static int
6638 test_kasumi_encryption_test_case_1_oop_sgl(void)
6639 {
6640         return test_kasumi_encryption_oop_sgl(&kasumi_test_case_1);
6641 }
6642
6643 static int
6644 test_kasumi_encryption_test_case_2(void)
6645 {
6646         return test_kasumi_encryption(&kasumi_test_case_2);
6647 }
6648
6649 static int
6650 test_kasumi_encryption_test_case_3(void)
6651 {
6652         return test_kasumi_encryption(&kasumi_test_case_3);
6653 }
6654
6655 static int
6656 test_kasumi_encryption_test_case_4(void)
6657 {
6658         return test_kasumi_encryption(&kasumi_test_case_4);
6659 }
6660
6661 static int
6662 test_kasumi_encryption_test_case_5(void)
6663 {
6664         return test_kasumi_encryption(&kasumi_test_case_5);
6665 }
6666
6667 static int
6668 test_kasumi_decryption_test_case_1(void)
6669 {
6670         return test_kasumi_decryption(&kasumi_test_case_1);
6671 }
6672
6673 static int
6674 test_kasumi_decryption_test_case_1_oop(void)
6675 {
6676         return test_kasumi_decryption_oop(&kasumi_test_case_1);
6677 }
6678
6679 static int
6680 test_kasumi_decryption_test_case_2(void)
6681 {
6682         return test_kasumi_decryption(&kasumi_test_case_2);
6683 }
6684
6685 static int
6686 test_kasumi_decryption_test_case_3(void)
6687 {
6688         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6689         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6690                 return TEST_SKIPPED;
6691         return test_kasumi_decryption(&kasumi_test_case_3);
6692 }
6693
6694 static int
6695 test_kasumi_decryption_test_case_4(void)
6696 {
6697         return test_kasumi_decryption(&kasumi_test_case_4);
6698 }
6699
6700 static int
6701 test_kasumi_decryption_test_case_5(void)
6702 {
6703         return test_kasumi_decryption(&kasumi_test_case_5);
6704 }
6705 static int
6706 test_snow3g_encryption_test_case_1(void)
6707 {
6708         return test_snow3g_encryption(&snow3g_test_case_1);
6709 }
6710
6711 static int
6712 test_snow3g_encryption_test_case_1_oop(void)
6713 {
6714         return test_snow3g_encryption_oop(&snow3g_test_case_1);
6715 }
6716
6717 static int
6718 test_snow3g_encryption_test_case_1_oop_sgl(void)
6719 {
6720         return test_snow3g_encryption_oop_sgl(&snow3g_test_case_1);
6721 }
6722
6723
6724 static int
6725 test_snow3g_encryption_test_case_1_offset_oop(void)
6726 {
6727         return test_snow3g_encryption_offset_oop(&snow3g_test_case_1);
6728 }
6729
6730 static int
6731 test_snow3g_encryption_test_case_2(void)
6732 {
6733         return test_snow3g_encryption(&snow3g_test_case_2);
6734 }
6735
6736 static int
6737 test_snow3g_encryption_test_case_3(void)
6738 {
6739         return test_snow3g_encryption(&snow3g_test_case_3);
6740 }
6741
6742 static int
6743 test_snow3g_encryption_test_case_4(void)
6744 {
6745         return test_snow3g_encryption(&snow3g_test_case_4);
6746 }
6747
6748 static int
6749 test_snow3g_encryption_test_case_5(void)
6750 {
6751         return test_snow3g_encryption(&snow3g_test_case_5);
6752 }
6753
6754 static int
6755 test_snow3g_decryption_test_case_1(void)
6756 {
6757         return test_snow3g_decryption(&snow3g_test_case_1);
6758 }
6759
6760 static int
6761 test_snow3g_decryption_test_case_1_oop(void)
6762 {
6763         return test_snow3g_decryption_oop(&snow3g_test_case_1);
6764 }
6765
6766 static int
6767 test_snow3g_decryption_test_case_2(void)
6768 {
6769         return test_snow3g_decryption(&snow3g_test_case_2);
6770 }
6771
6772 static int
6773 test_snow3g_decryption_test_case_3(void)
6774 {
6775         return test_snow3g_decryption(&snow3g_test_case_3);
6776 }
6777
6778 static int
6779 test_snow3g_decryption_test_case_4(void)
6780 {
6781         return test_snow3g_decryption(&snow3g_test_case_4);
6782 }
6783
6784 static int
6785 test_snow3g_decryption_test_case_5(void)
6786 {
6787         return test_snow3g_decryption(&snow3g_test_case_5);
6788 }
6789
6790 /*
6791  * Function prepares snow3g_hash_test_data from snow3g_test_data.
6792  * Pattern digest from snow3g_test_data must be allocated as
6793  * 4 last bytes in plaintext.
6794  */
6795 static void
6796 snow3g_hash_test_vector_setup(const struct snow3g_test_data *pattern,
6797                 struct snow3g_hash_test_data *output)
6798 {
6799         if ((pattern != NULL) && (output != NULL)) {
6800                 output->key.len = pattern->key.len;
6801
6802                 memcpy(output->key.data,
6803                 pattern->key.data, pattern->key.len);
6804
6805                 output->auth_iv.len = pattern->auth_iv.len;
6806
6807                 memcpy(output->auth_iv.data,
6808                 pattern->auth_iv.data, pattern->auth_iv.len);
6809
6810                 output->plaintext.len = pattern->plaintext.len;
6811
6812                 memcpy(output->plaintext.data,
6813                 pattern->plaintext.data, pattern->plaintext.len >> 3);
6814
6815                 output->digest.len = pattern->digest.len;
6816
6817                 memcpy(output->digest.data,
6818                 &pattern->plaintext.data[pattern->digest.offset_bytes],
6819                 pattern->digest.len);
6820
6821                 output->validAuthLenInBits.len =
6822                 pattern->validAuthLenInBits.len;
6823         }
6824 }
6825
6826 /*
6827  * Test case verify computed cipher and digest from snow3g_test_case_7 data.
6828  */
6829 static int
6830 test_snow3g_decryption_with_digest_test_case_1(void)
6831 {
6832         struct snow3g_hash_test_data snow3g_hash_data;
6833         struct rte_cryptodev_info dev_info;
6834         struct crypto_testsuite_params *ts_params = &testsuite_params;
6835
6836         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6837         uint64_t feat_flags = dev_info.feature_flags;
6838
6839         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6840                 printf("Device doesn't support encrypted digest operations.\n");
6841                 return TEST_SKIPPED;
6842         }
6843
6844         /*
6845          * Function prepare data for hash veryfication test case.
6846          * Digest is allocated in 4 last bytes in plaintext, pattern.
6847          */
6848         snow3g_hash_test_vector_setup(&snow3g_test_case_7, &snow3g_hash_data);
6849
6850         return test_snow3g_decryption(&snow3g_test_case_7) &
6851                         test_snow3g_authentication_verify(&snow3g_hash_data);
6852 }
6853
6854 static int
6855 test_snow3g_cipher_auth_test_case_1(void)
6856 {
6857         return test_snow3g_cipher_auth(&snow3g_test_case_3);
6858 }
6859
6860 static int
6861 test_snow3g_auth_cipher_test_case_1(void)
6862 {
6863         return test_snow3g_auth_cipher(
6864                 &snow3g_auth_cipher_test_case_1, IN_PLACE, 0);
6865 }
6866
6867 static int
6868 test_snow3g_auth_cipher_test_case_2(void)
6869 {
6870         return test_snow3g_auth_cipher(
6871                 &snow3g_auth_cipher_test_case_2, IN_PLACE, 0);
6872 }
6873
6874 static int
6875 test_snow3g_auth_cipher_test_case_2_oop(void)
6876 {
6877         return test_snow3g_auth_cipher(
6878                 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
6879 }
6880
6881 static int
6882 test_snow3g_auth_cipher_part_digest_enc(void)
6883 {
6884         return test_snow3g_auth_cipher(
6885                 &snow3g_auth_cipher_partial_digest_encryption,
6886                         IN_PLACE, 0);
6887 }
6888
6889 static int
6890 test_snow3g_auth_cipher_part_digest_enc_oop(void)
6891 {
6892         return test_snow3g_auth_cipher(
6893                 &snow3g_auth_cipher_partial_digest_encryption,
6894                         OUT_OF_PLACE, 0);
6895 }
6896
6897 static int
6898 test_snow3g_auth_cipher_test_case_3_sgl(void)
6899 {
6900         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6901         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6902                 return TEST_SKIPPED;
6903         return test_snow3g_auth_cipher_sgl(
6904                 &snow3g_auth_cipher_test_case_3, IN_PLACE, 0);
6905 }
6906
6907 static int
6908 test_snow3g_auth_cipher_test_case_3_oop_sgl(void)
6909 {
6910         return test_snow3g_auth_cipher_sgl(
6911                 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 0);
6912 }
6913
6914 static int
6915 test_snow3g_auth_cipher_part_digest_enc_sgl(void)
6916 {
6917         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6918         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6919                 return TEST_SKIPPED;
6920         return test_snow3g_auth_cipher_sgl(
6921                 &snow3g_auth_cipher_partial_digest_encryption,
6922                         IN_PLACE, 0);
6923 }
6924
6925 static int
6926 test_snow3g_auth_cipher_part_digest_enc_oop_sgl(void)
6927 {
6928         return test_snow3g_auth_cipher_sgl(
6929                 &snow3g_auth_cipher_partial_digest_encryption,
6930                         OUT_OF_PLACE, 0);
6931 }
6932
6933 static int
6934 test_snow3g_auth_cipher_verify_test_case_1(void)
6935 {
6936         return test_snow3g_auth_cipher(
6937                 &snow3g_auth_cipher_test_case_1, IN_PLACE, 1);
6938 }
6939
6940 static int
6941 test_snow3g_auth_cipher_verify_test_case_2(void)
6942 {
6943         return test_snow3g_auth_cipher(
6944                 &snow3g_auth_cipher_test_case_2, IN_PLACE, 1);
6945 }
6946
6947 static int
6948 test_snow3g_auth_cipher_verify_test_case_2_oop(void)
6949 {
6950         return test_snow3g_auth_cipher(
6951                 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
6952 }
6953
6954 static int
6955 test_snow3g_auth_cipher_verify_part_digest_enc(void)
6956 {
6957         return test_snow3g_auth_cipher(
6958                 &snow3g_auth_cipher_partial_digest_encryption,
6959                         IN_PLACE, 1);
6960 }
6961
6962 static int
6963 test_snow3g_auth_cipher_verify_part_digest_enc_oop(void)
6964 {
6965         return test_snow3g_auth_cipher(
6966                 &snow3g_auth_cipher_partial_digest_encryption,
6967                         OUT_OF_PLACE, 1);
6968 }
6969
6970 static int
6971 test_snow3g_auth_cipher_verify_test_case_3_sgl(void)
6972 {
6973         return test_snow3g_auth_cipher_sgl(
6974                 &snow3g_auth_cipher_test_case_3, IN_PLACE, 1);
6975 }
6976
6977 static int
6978 test_snow3g_auth_cipher_verify_test_case_3_oop_sgl(void)
6979 {
6980         return test_snow3g_auth_cipher_sgl(
6981                 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 1);
6982 }
6983
6984 static int
6985 test_snow3g_auth_cipher_verify_part_digest_enc_sgl(void)
6986 {
6987         return test_snow3g_auth_cipher_sgl(
6988                 &snow3g_auth_cipher_partial_digest_encryption,
6989                         IN_PLACE, 1);
6990 }
6991
6992 static int
6993 test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl(void)
6994 {
6995         return test_snow3g_auth_cipher_sgl(
6996                 &snow3g_auth_cipher_partial_digest_encryption,
6997                         OUT_OF_PLACE, 1);
6998 }
6999
7000 static int
7001 test_snow3g_auth_cipher_with_digest_test_case_1(void)
7002 {
7003         return test_snow3g_auth_cipher(
7004                 &snow3g_test_case_7, IN_PLACE, 0);
7005 }
7006
7007 static int
7008 test_kasumi_auth_cipher_test_case_1(void)
7009 {
7010         return test_kasumi_auth_cipher(
7011                 &kasumi_test_case_3, IN_PLACE, 0);
7012 }
7013
7014 static int
7015 test_kasumi_auth_cipher_test_case_2(void)
7016 {
7017         return test_kasumi_auth_cipher(
7018                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
7019 }
7020
7021 static int
7022 test_kasumi_auth_cipher_test_case_2_oop(void)
7023 {
7024         return test_kasumi_auth_cipher(
7025                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
7026 }
7027
7028 static int
7029 test_kasumi_auth_cipher_test_case_2_sgl(void)
7030 {
7031         return test_kasumi_auth_cipher_sgl(
7032                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
7033 }
7034
7035 static int
7036 test_kasumi_auth_cipher_test_case_2_oop_sgl(void)
7037 {
7038         return test_kasumi_auth_cipher_sgl(
7039                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
7040 }
7041
7042 static int
7043 test_kasumi_auth_cipher_verify_test_case_1(void)
7044 {
7045         return test_kasumi_auth_cipher(
7046                 &kasumi_test_case_3, IN_PLACE, 1);
7047 }
7048
7049 static int
7050 test_kasumi_auth_cipher_verify_test_case_2(void)
7051 {
7052         return test_kasumi_auth_cipher(
7053                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
7054 }
7055
7056 static int
7057 test_kasumi_auth_cipher_verify_test_case_2_oop(void)
7058 {
7059         return test_kasumi_auth_cipher(
7060                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
7061 }
7062
7063 static int
7064 test_kasumi_auth_cipher_verify_test_case_2_sgl(void)
7065 {
7066         return test_kasumi_auth_cipher_sgl(
7067                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
7068 }
7069
7070 static int
7071 test_kasumi_auth_cipher_verify_test_case_2_oop_sgl(void)
7072 {
7073         return test_kasumi_auth_cipher_sgl(
7074                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
7075 }
7076
7077 static int
7078 test_kasumi_cipher_auth_test_case_1(void)
7079 {
7080         return test_kasumi_cipher_auth(&kasumi_test_case_6);
7081 }
7082
7083 static int
7084 test_zuc_encryption_test_case_1(void)
7085 {
7086         return test_zuc_encryption(&zuc_test_case_cipher_193b);
7087 }
7088
7089 static int
7090 test_zuc_encryption_test_case_2(void)
7091 {
7092         return test_zuc_encryption(&zuc_test_case_cipher_800b);
7093 }
7094
7095 static int
7096 test_zuc_encryption_test_case_3(void)
7097 {
7098         return test_zuc_encryption(&zuc_test_case_cipher_1570b);
7099 }
7100
7101 static int
7102 test_zuc_encryption_test_case_4(void)
7103 {
7104         return test_zuc_encryption(&zuc_test_case_cipher_2798b);
7105 }
7106
7107 static int
7108 test_zuc_encryption_test_case_5(void)
7109 {
7110         return test_zuc_encryption(&zuc_test_case_cipher_4019b);
7111 }
7112
7113 static int
7114 test_zuc_encryption_test_case_6_sgl(void)
7115 {
7116         return test_zuc_encryption_sgl(&zuc_test_case_cipher_193b);
7117 }
7118
7119 static int
7120 test_zuc_encryption_test_case_7(void)
7121 {
7122         return test_zuc_encryption(&zuc_test_case_cipher_800b_key_256b);
7123 }
7124
7125 static int
7126 test_zuc_hash_generate_test_case_1(void)
7127 {
7128         return test_zuc_authentication(&zuc_test_case_auth_1b);
7129 }
7130
7131 static int
7132 test_zuc_hash_generate_test_case_2(void)
7133 {
7134         return test_zuc_authentication(&zuc_test_case_auth_90b);
7135 }
7136
7137 static int
7138 test_zuc_hash_generate_test_case_3(void)
7139 {
7140         return test_zuc_authentication(&zuc_test_case_auth_577b);
7141 }
7142
7143 static int
7144 test_zuc_hash_generate_test_case_4(void)
7145 {
7146         return test_zuc_authentication(&zuc_test_case_auth_2079b);
7147 }
7148
7149 static int
7150 test_zuc_hash_generate_test_case_5(void)
7151 {
7152         return test_zuc_authentication(&zuc_test_auth_5670b);
7153 }
7154
7155 static int
7156 test_zuc_hash_generate_test_case_6(void)
7157 {
7158         return test_zuc_authentication(&zuc_test_case_auth_128b);
7159 }
7160
7161 static int
7162 test_zuc_hash_generate_test_case_7(void)
7163 {
7164         return test_zuc_authentication(&zuc_test_case_auth_2080b);
7165 }
7166
7167 static int
7168 test_zuc_hash_generate_test_case_8(void)
7169 {
7170         return test_zuc_authentication(&zuc_test_case_auth_584b);
7171 }
7172
7173 static int
7174 test_zuc_hash_generate_test_case_9(void)
7175 {
7176         return test_zuc_authentication(&zuc_test_case_auth_584b_mac_64b);
7177 }
7178
7179 static int
7180 test_zuc_hash_generate_test_case_10(void)
7181 {
7182         return test_zuc_authentication(&zuc_test_case_auth_2080b_mac_128b);
7183 }
7184
7185 static int
7186 test_zuc_cipher_auth_test_case_1(void)
7187 {
7188         return test_zuc_cipher_auth(&zuc_test_case_cipher_200b_auth_200b);
7189 }
7190
7191 static int
7192 test_zuc_cipher_auth_test_case_2(void)
7193 {
7194         return test_zuc_cipher_auth(&zuc_test_case_cipher_800b_auth_120b);
7195 }
7196
7197 static int
7198 test_zuc_auth_cipher_test_case_1(void)
7199 {
7200         return test_zuc_auth_cipher(
7201                 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
7202 }
7203
7204 static int
7205 test_zuc_auth_cipher_test_case_1_oop(void)
7206 {
7207         return test_zuc_auth_cipher(
7208                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
7209 }
7210
7211 static int
7212 test_zuc_auth_cipher_test_case_1_sgl(void)
7213 {
7214         return test_zuc_auth_cipher_sgl(
7215                 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
7216 }
7217
7218 static int
7219 test_zuc_auth_cipher_test_case_1_oop_sgl(void)
7220 {
7221         return test_zuc_auth_cipher_sgl(
7222                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
7223 }
7224
7225 static int
7226 test_zuc_auth_cipher_verify_test_case_1(void)
7227 {
7228         return test_zuc_auth_cipher(
7229                 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
7230 }
7231
7232 static int
7233 test_zuc_auth_cipher_verify_test_case_1_oop(void)
7234 {
7235         return test_zuc_auth_cipher(
7236                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
7237 }
7238
7239 static int
7240 test_zuc_auth_cipher_verify_test_case_1_sgl(void)
7241 {
7242         return test_zuc_auth_cipher_sgl(
7243                 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
7244 }
7245
7246 static int
7247 test_zuc_auth_cipher_verify_test_case_1_oop_sgl(void)
7248 {
7249         return test_zuc_auth_cipher_sgl(
7250                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
7251 }
7252
7253 static int
7254 test_mixed_check_if_unsupported(const struct mixed_cipher_auth_test_data *tdata)
7255 {
7256         uint8_t dev_id = testsuite_params.valid_devs[0];
7257
7258         struct rte_cryptodev_sym_capability_idx cap_idx;
7259
7260         /* Check if device supports particular cipher algorithm */
7261         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
7262         cap_idx.algo.cipher = tdata->cipher_algo;
7263         if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
7264                 return TEST_SKIPPED;
7265
7266         /* Check if device supports particular hash algorithm */
7267         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
7268         cap_idx.algo.auth = tdata->auth_algo;
7269         if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
7270                 return TEST_SKIPPED;
7271
7272         return 0;
7273 }
7274
7275 static int
7276 test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata,
7277         uint8_t op_mode, uint8_t verify)
7278 {
7279         struct crypto_testsuite_params *ts_params = &testsuite_params;
7280         struct crypto_unittest_params *ut_params = &unittest_params;
7281
7282         int retval;
7283
7284         uint8_t *plaintext = NULL, *ciphertext = NULL;
7285         unsigned int plaintext_pad_len;
7286         unsigned int plaintext_len;
7287         unsigned int ciphertext_pad_len;
7288         unsigned int ciphertext_len;
7289
7290         struct rte_cryptodev_info dev_info;
7291         struct rte_crypto_op *op;
7292
7293         /* Check if device supports particular algorithms separately */
7294         if (test_mixed_check_if_unsupported(tdata))
7295                 return TEST_SKIPPED;
7296         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
7297                 return TEST_SKIPPED;
7298
7299         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
7300
7301         uint64_t feat_flags = dev_info.feature_flags;
7302
7303         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
7304                 printf("Device doesn't support digest encrypted.\n");
7305                 return TEST_SKIPPED;
7306         }
7307
7308         /* Create the session */
7309         if (verify)
7310                 retval = create_wireless_algo_cipher_auth_session(
7311                                 ts_params->valid_devs[0],
7312                                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
7313                                 RTE_CRYPTO_AUTH_OP_VERIFY,
7314                                 tdata->auth_algo,
7315                                 tdata->cipher_algo,
7316                                 tdata->auth_key.data, tdata->auth_key.len,
7317                                 tdata->auth_iv.len, tdata->digest_enc.len,
7318                                 tdata->cipher_iv.len);
7319         else
7320                 retval = create_wireless_algo_auth_cipher_session(
7321                                 ts_params->valid_devs[0],
7322                                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7323                                 RTE_CRYPTO_AUTH_OP_GENERATE,
7324                                 tdata->auth_algo,
7325                                 tdata->cipher_algo,
7326                                 tdata->auth_key.data, tdata->auth_key.len,
7327                                 tdata->auth_iv.len, tdata->digest_enc.len,
7328                                 tdata->cipher_iv.len);
7329         if (retval != 0)
7330                 return retval;
7331
7332         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7333         if (op_mode == OUT_OF_PLACE)
7334                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7335
7336         /* clear mbuf payload */
7337         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7338                 rte_pktmbuf_tailroom(ut_params->ibuf));
7339         if (op_mode == OUT_OF_PLACE) {
7340
7341                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
7342                                 rte_pktmbuf_tailroom(ut_params->obuf));
7343         }
7344
7345         ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
7346         plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
7347         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
7348         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
7349
7350         if (verify) {
7351                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7352                                 ciphertext_pad_len);
7353                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
7354                 if (op_mode == OUT_OF_PLACE)
7355                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
7356                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7357                                 ciphertext_len);
7358         } else {
7359                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7360                                 plaintext_pad_len);
7361                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
7362                 if (op_mode == OUT_OF_PLACE)
7363                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
7364                 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
7365         }
7366
7367         /* Create the operation */
7368         retval = create_wireless_algo_auth_cipher_operation(
7369                         tdata->digest_enc.data, tdata->digest_enc.len,
7370                         tdata->cipher_iv.data, tdata->cipher_iv.len,
7371                         tdata->auth_iv.data, tdata->auth_iv.len,
7372                         (tdata->digest_enc.offset == 0 ?
7373                                 plaintext_pad_len
7374                                 : tdata->digest_enc.offset),
7375                         tdata->validCipherLen.len_bits,
7376                         tdata->cipher.offset_bits,
7377                         tdata->validAuthLen.len_bits,
7378                         tdata->auth.offset_bits,
7379                         op_mode, 0, verify);
7380
7381         if (retval < 0)
7382                 return retval;
7383
7384         op = process_crypto_request(ts_params->valid_devs[0], ut_params->op);
7385
7386         /* Check if the op failed because the device doesn't */
7387         /* support this particular combination of algorithms */
7388         if (op == NULL && ut_params->op->status ==
7389                         RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
7390                 printf("Device doesn't support this mixed combination. "
7391                                 "Test Skipped.\n");
7392                 return TEST_SKIPPED;
7393         }
7394         ut_params->op = op;
7395
7396         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
7397
7398         ut_params->obuf = (op_mode == IN_PLACE ?
7399                         ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
7400
7401         if (verify) {
7402                 if (ut_params->obuf)
7403                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
7404                                                         uint8_t *);
7405                 else
7406                         plaintext = ciphertext +
7407                                         (tdata->cipher.offset_bits >> 3);
7408
7409                 debug_hexdump(stdout, "plaintext:", plaintext,
7410                                 tdata->plaintext.len_bits >> 3);
7411                 debug_hexdump(stdout, "plaintext expected:",
7412                                 tdata->plaintext.data,
7413                                 tdata->plaintext.len_bits >> 3);
7414         } else {
7415                 if (ut_params->obuf)
7416                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
7417                                         uint8_t *);
7418                 else
7419                         ciphertext = plaintext;
7420
7421                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7422                                 ciphertext_len);
7423                 debug_hexdump(stdout, "ciphertext expected:",
7424                                 tdata->ciphertext.data,
7425                                 tdata->ciphertext.len_bits >> 3);
7426
7427                 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
7428                                 + (tdata->digest_enc.offset == 0 ?
7429                 plaintext_pad_len : tdata->digest_enc.offset);
7430
7431                 debug_hexdump(stdout, "digest:", ut_params->digest,
7432                                 tdata->digest_enc.len);
7433                 debug_hexdump(stdout, "digest expected:",
7434                                 tdata->digest_enc.data,
7435                                 tdata->digest_enc.len);
7436         }
7437
7438         /* Validate obuf */
7439         if (verify) {
7440                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7441                                 plaintext,
7442                                 tdata->plaintext.data,
7443                                 tdata->plaintext.len_bits >> 3,
7444                                 "Plaintext data not as expected");
7445         } else {
7446                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7447                                 ciphertext,
7448                                 tdata->ciphertext.data,
7449                                 tdata->validDataLen.len_bits,
7450                                 "Ciphertext data not as expected");
7451
7452                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7453                                 ut_params->digest,
7454                                 tdata->digest_enc.data,
7455                                 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
7456                                 "Generated auth tag not as expected");
7457         }
7458
7459         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7460                         "crypto op processing failed");
7461
7462         return 0;
7463 }
7464
7465 static int
7466 test_mixed_auth_cipher_sgl(const struct mixed_cipher_auth_test_data *tdata,
7467         uint8_t op_mode, uint8_t verify)
7468 {
7469         struct crypto_testsuite_params *ts_params = &testsuite_params;
7470         struct crypto_unittest_params *ut_params = &unittest_params;
7471
7472         int retval;
7473
7474         const uint8_t *plaintext = NULL;
7475         const uint8_t *ciphertext = NULL;
7476         const uint8_t *digest = NULL;
7477         unsigned int plaintext_pad_len;
7478         unsigned int plaintext_len;
7479         unsigned int ciphertext_pad_len;
7480         unsigned int ciphertext_len;
7481         uint8_t buffer[10000];
7482         uint8_t digest_buffer[10000];
7483
7484         struct rte_cryptodev_info dev_info;
7485         struct rte_crypto_op *op;
7486
7487         /* Check if device supports particular algorithms */
7488         if (test_mixed_check_if_unsupported(tdata))
7489                 return TEST_SKIPPED;
7490         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
7491                 return TEST_SKIPPED;
7492
7493         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
7494
7495         uint64_t feat_flags = dev_info.feature_flags;
7496
7497         if (op_mode == IN_PLACE) {
7498                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
7499                         printf("Device doesn't support in-place scatter-gather "
7500                                         "in both input and output mbufs.\n");
7501                         return TEST_SKIPPED;
7502                 }
7503         } else {
7504                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
7505                         printf("Device doesn't support out-of-place scatter-gather "
7506                                         "in both input and output mbufs.\n");
7507                         return TEST_SKIPPED;
7508                 }
7509                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
7510                         printf("Device doesn't support digest encrypted.\n");
7511                         return TEST_SKIPPED;
7512                 }
7513         }
7514
7515         /* Create the session */
7516         if (verify)
7517                 retval = create_wireless_algo_cipher_auth_session(
7518                                 ts_params->valid_devs[0],
7519                                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
7520                                 RTE_CRYPTO_AUTH_OP_VERIFY,
7521                                 tdata->auth_algo,
7522                                 tdata->cipher_algo,
7523                                 tdata->auth_key.data, tdata->auth_key.len,
7524                                 tdata->auth_iv.len, tdata->digest_enc.len,
7525                                 tdata->cipher_iv.len);
7526         else
7527                 retval = create_wireless_algo_auth_cipher_session(
7528                                 ts_params->valid_devs[0],
7529                                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7530                                 RTE_CRYPTO_AUTH_OP_GENERATE,
7531                                 tdata->auth_algo,
7532                                 tdata->cipher_algo,
7533                                 tdata->auth_key.data, tdata->auth_key.len,
7534                                 tdata->auth_iv.len, tdata->digest_enc.len,
7535                                 tdata->cipher_iv.len);
7536         if (retval != 0)
7537                 return retval;
7538
7539         ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
7540         plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
7541         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
7542         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
7543
7544         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
7545                         ciphertext_pad_len, 15, 0);
7546         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
7547                         "Failed to allocate input buffer in mempool");
7548
7549         if (op_mode == OUT_OF_PLACE) {
7550                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
7551                                 plaintext_pad_len, 15, 0);
7552                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
7553                                 "Failed to allocate output buffer in mempool");
7554         }
7555
7556         if (verify) {
7557                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
7558                         tdata->ciphertext.data);
7559                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
7560                                         ciphertext_len, buffer);
7561                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7562                         ciphertext_len);
7563         } else {
7564                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
7565                         tdata->plaintext.data);
7566                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
7567                                         plaintext_len, buffer);
7568                 debug_hexdump(stdout, "plaintext:", plaintext,
7569                         plaintext_len);
7570         }
7571         memset(buffer, 0, sizeof(buffer));
7572
7573         /* Create the operation */
7574         retval = create_wireless_algo_auth_cipher_operation(
7575                         tdata->digest_enc.data, tdata->digest_enc.len,
7576                         tdata->cipher_iv.data, tdata->cipher_iv.len,
7577                         tdata->auth_iv.data, tdata->auth_iv.len,
7578                         (tdata->digest_enc.offset == 0 ?
7579                                 plaintext_pad_len
7580                                 : tdata->digest_enc.offset),
7581                         tdata->validCipherLen.len_bits,
7582                         tdata->cipher.offset_bits,
7583                         tdata->validAuthLen.len_bits,
7584                         tdata->auth.offset_bits,
7585                         op_mode, 1, verify);
7586
7587         if (retval < 0)
7588                 return retval;
7589
7590         op = process_crypto_request(ts_params->valid_devs[0], ut_params->op);
7591
7592         /* Check if the op failed because the device doesn't */
7593         /* support this particular combination of algorithms */
7594         if (op == NULL && ut_params->op->status ==
7595                         RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
7596                 printf("Device doesn't support this mixed combination. "
7597                                 "Test Skipped.\n");
7598                 return TEST_SKIPPED;
7599         }
7600         ut_params->op = op;
7601
7602         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
7603
7604         ut_params->obuf = (op_mode == IN_PLACE ?
7605                         ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
7606
7607         if (verify) {
7608                 if (ut_params->obuf)
7609                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
7610                                         plaintext_len, buffer);
7611                 else
7612                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
7613                                         plaintext_len, buffer);
7614
7615                 debug_hexdump(stdout, "plaintext:", plaintext,
7616                                 (tdata->plaintext.len_bits >> 3) -
7617                                 tdata->digest_enc.len);
7618                 debug_hexdump(stdout, "plaintext expected:",
7619                                 tdata->plaintext.data,
7620                                 (tdata->plaintext.len_bits >> 3) -
7621                                 tdata->digest_enc.len);
7622         } else {
7623                 if (ut_params->obuf)
7624                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
7625                                         ciphertext_len, buffer);
7626                 else
7627                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
7628                                         ciphertext_len, buffer);
7629
7630                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7631                         ciphertext_len);
7632                 debug_hexdump(stdout, "ciphertext expected:",
7633                         tdata->ciphertext.data,
7634                         tdata->ciphertext.len_bits >> 3);
7635
7636                 if (ut_params->obuf)
7637                         digest = rte_pktmbuf_read(ut_params->obuf,
7638                                         (tdata->digest_enc.offset == 0 ?
7639                                                 plaintext_pad_len :
7640                                                 tdata->digest_enc.offset),
7641                                         tdata->digest_enc.len, digest_buffer);
7642                 else
7643                         digest = rte_pktmbuf_read(ut_params->ibuf,
7644                                         (tdata->digest_enc.offset == 0 ?
7645                                                 plaintext_pad_len :
7646                                                 tdata->digest_enc.offset),
7647                                         tdata->digest_enc.len, digest_buffer);
7648
7649                 debug_hexdump(stdout, "digest:", digest,
7650                                 tdata->digest_enc.len);
7651                 debug_hexdump(stdout, "digest expected:",
7652                                 tdata->digest_enc.data, tdata->digest_enc.len);
7653         }
7654
7655         /* Validate obuf */
7656         if (verify) {
7657                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7658                                 plaintext,
7659                                 tdata->plaintext.data,
7660                                 tdata->plaintext.len_bits >> 3,
7661                                 "Plaintext data not as expected");
7662         } else {
7663                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7664                                 ciphertext,
7665                                 tdata->ciphertext.data,
7666                                 tdata->validDataLen.len_bits,
7667                                 "Ciphertext data not as expected");
7668                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7669                                 digest,
7670                                 tdata->digest_enc.data,
7671                                 tdata->digest_enc.len,
7672                                 "Generated auth tag not as expected");
7673         }
7674
7675         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7676                         "crypto op processing failed");
7677
7678         return 0;
7679 }
7680
7681 /** AUTH AES CMAC + CIPHER AES CTR */
7682
7683 static int
7684 test_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7685 {
7686         return test_mixed_auth_cipher(
7687                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7688 }
7689
7690 static int
7691 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7692 {
7693         return test_mixed_auth_cipher(
7694                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7695 }
7696
7697 static int
7698 test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7699 {
7700         return test_mixed_auth_cipher_sgl(
7701                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7702 }
7703
7704 static int
7705 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7706 {
7707         return test_mixed_auth_cipher_sgl(
7708                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7709 }
7710
7711 static int
7712 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7713 {
7714         return test_mixed_auth_cipher(
7715                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7716 }
7717
7718 static int
7719 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7720 {
7721         return test_mixed_auth_cipher(
7722                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7723 }
7724
7725 static int
7726 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7727 {
7728         return test_mixed_auth_cipher_sgl(
7729                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7730 }
7731
7732 static int
7733 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7734 {
7735         return test_mixed_auth_cipher_sgl(
7736                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7737 }
7738
7739 /** MIXED AUTH + CIPHER */
7740
7741 static int
7742 test_auth_zuc_cipher_snow_test_case_1(void)
7743 {
7744         return test_mixed_auth_cipher(
7745                 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7746 }
7747
7748 static int
7749 test_verify_auth_zuc_cipher_snow_test_case_1(void)
7750 {
7751         return test_mixed_auth_cipher(
7752                 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7753 }
7754
7755 static int
7756 test_auth_aes_cmac_cipher_snow_test_case_1(void)
7757 {
7758         return test_mixed_auth_cipher(
7759                 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7760 }
7761
7762 static int
7763 test_verify_auth_aes_cmac_cipher_snow_test_case_1(void)
7764 {
7765         return test_mixed_auth_cipher(
7766                 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7767 }
7768
7769 static int
7770 test_auth_zuc_cipher_aes_ctr_test_case_1(void)
7771 {
7772         return test_mixed_auth_cipher(
7773                 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7774 }
7775
7776 static int
7777 test_verify_auth_zuc_cipher_aes_ctr_test_case_1(void)
7778 {
7779         return test_mixed_auth_cipher(
7780                 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7781 }
7782
7783 static int
7784 test_auth_snow_cipher_aes_ctr_test_case_1(void)
7785 {
7786         return test_mixed_auth_cipher(
7787                 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7788 }
7789
7790 static int
7791 test_verify_auth_snow_cipher_aes_ctr_test_case_1(void)
7792 {
7793         return test_mixed_auth_cipher(
7794                 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7795 }
7796
7797 static int
7798 test_auth_snow_cipher_zuc_test_case_1(void)
7799 {
7800         return test_mixed_auth_cipher(
7801                 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7802 }
7803
7804 static int
7805 test_verify_auth_snow_cipher_zuc_test_case_1(void)
7806 {
7807         return test_mixed_auth_cipher(
7808                 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7809 }
7810
7811 static int
7812 test_auth_aes_cmac_cipher_zuc_test_case_1(void)
7813 {
7814         return test_mixed_auth_cipher(
7815                 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7816 }
7817
7818 static int
7819 test_verify_auth_aes_cmac_cipher_zuc_test_case_1(void)
7820 {
7821         return test_mixed_auth_cipher(
7822                 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7823 }
7824
7825 static int
7826 test_auth_null_cipher_snow_test_case_1(void)
7827 {
7828         return test_mixed_auth_cipher(
7829                 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7830 }
7831
7832 static int
7833 test_verify_auth_null_cipher_snow_test_case_1(void)
7834 {
7835         return test_mixed_auth_cipher(
7836                 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7837 }
7838
7839 static int
7840 test_auth_null_cipher_zuc_test_case_1(void)
7841 {
7842         return test_mixed_auth_cipher(
7843                 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7844 }
7845
7846 static int
7847 test_verify_auth_null_cipher_zuc_test_case_1(void)
7848 {
7849         return test_mixed_auth_cipher(
7850                 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7851 }
7852
7853 static int
7854 test_auth_snow_cipher_null_test_case_1(void)
7855 {
7856         return test_mixed_auth_cipher(
7857                 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7858 }
7859
7860 static int
7861 test_verify_auth_snow_cipher_null_test_case_1(void)
7862 {
7863         return test_mixed_auth_cipher(
7864                 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7865 }
7866
7867 static int
7868 test_auth_zuc_cipher_null_test_case_1(void)
7869 {
7870         return test_mixed_auth_cipher(
7871                 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7872 }
7873
7874 static int
7875 test_verify_auth_zuc_cipher_null_test_case_1(void)
7876 {
7877         return test_mixed_auth_cipher(
7878                 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7879 }
7880
7881 static int
7882 test_auth_null_cipher_aes_ctr_test_case_1(void)
7883 {
7884         return test_mixed_auth_cipher(
7885                 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7886 }
7887
7888 static int
7889 test_verify_auth_null_cipher_aes_ctr_test_case_1(void)
7890 {
7891         return test_mixed_auth_cipher(
7892                 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7893 }
7894
7895 static int
7896 test_auth_aes_cmac_cipher_null_test_case_1(void)
7897 {
7898         return test_mixed_auth_cipher(
7899                 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7900 }
7901
7902 static int
7903 test_verify_auth_aes_cmac_cipher_null_test_case_1(void)
7904 {
7905         return test_mixed_auth_cipher(
7906                 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7907 }
7908
7909 /* ***** AEAD algorithm Tests ***** */
7910
7911 static int
7912 create_aead_session(uint8_t dev_id, enum rte_crypto_aead_algorithm algo,
7913                 enum rte_crypto_aead_operation op,
7914                 const uint8_t *key, const uint8_t key_len,
7915                 const uint16_t aad_len, const uint8_t auth_len,
7916                 uint8_t iv_len)
7917 {
7918         uint8_t aead_key[key_len];
7919
7920         struct crypto_testsuite_params *ts_params = &testsuite_params;
7921         struct crypto_unittest_params *ut_params = &unittest_params;
7922
7923         memcpy(aead_key, key, key_len);
7924
7925         /* Setup AEAD Parameters */
7926         ut_params->aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD;
7927         ut_params->aead_xform.next = NULL;
7928         ut_params->aead_xform.aead.algo = algo;
7929         ut_params->aead_xform.aead.op = op;
7930         ut_params->aead_xform.aead.key.data = aead_key;
7931         ut_params->aead_xform.aead.key.length = key_len;
7932         ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
7933         ut_params->aead_xform.aead.iv.length = iv_len;
7934         ut_params->aead_xform.aead.digest_length = auth_len;
7935         ut_params->aead_xform.aead.aad_length = aad_len;
7936
7937         debug_hexdump(stdout, "key:", key, key_len);
7938
7939         /* Create Crypto session*/
7940         ut_params->sess = rte_cryptodev_sym_session_create(
7941                         ts_params->session_mpool);
7942
7943         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
7944                         &ut_params->aead_xform,
7945                         ts_params->session_priv_mpool);
7946
7947         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
7948
7949         return 0;
7950 }
7951
7952 static int
7953 create_aead_xform(struct rte_crypto_op *op,
7954                 enum rte_crypto_aead_algorithm algo,
7955                 enum rte_crypto_aead_operation aead_op,
7956                 uint8_t *key, const uint8_t key_len,
7957                 const uint8_t aad_len, const uint8_t auth_len,
7958                 uint8_t iv_len)
7959 {
7960         TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 1),
7961                         "failed to allocate space for crypto transform");
7962
7963         struct rte_crypto_sym_op *sym_op = op->sym;
7964
7965         /* Setup AEAD Parameters */
7966         sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_AEAD;
7967         sym_op->xform->next = NULL;
7968         sym_op->xform->aead.algo = algo;
7969         sym_op->xform->aead.op = aead_op;
7970         sym_op->xform->aead.key.data = key;
7971         sym_op->xform->aead.key.length = key_len;
7972         sym_op->xform->aead.iv.offset = IV_OFFSET;
7973         sym_op->xform->aead.iv.length = iv_len;
7974         sym_op->xform->aead.digest_length = auth_len;
7975         sym_op->xform->aead.aad_length = aad_len;
7976
7977         debug_hexdump(stdout, "key:", key, key_len);
7978
7979         return 0;
7980 }
7981
7982 static int
7983 create_aead_operation(enum rte_crypto_aead_operation op,
7984                 const struct aead_test_data *tdata)
7985 {
7986         struct crypto_testsuite_params *ts_params = &testsuite_params;
7987         struct crypto_unittest_params *ut_params = &unittest_params;
7988
7989         uint8_t *plaintext, *ciphertext;
7990         unsigned int aad_pad_len, plaintext_pad_len;
7991
7992         /* Generate Crypto op data structure */
7993         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7994                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7995         TEST_ASSERT_NOT_NULL(ut_params->op,
7996                         "Failed to allocate symmetric crypto operation struct");
7997
7998         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
7999
8000         /* Append aad data */
8001         if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
8002                 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len + 18, 16);
8003                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8004                                 aad_pad_len);
8005                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
8006                                 "no room to append aad");
8007
8008                 sym_op->aead.aad.phys_addr =
8009                                 rte_pktmbuf_iova(ut_params->ibuf);
8010                 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
8011                 memcpy(sym_op->aead.aad.data + 18, tdata->aad.data, tdata->aad.len);
8012                 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
8013                         tdata->aad.len);
8014
8015                 /* Append IV at the end of the crypto operation*/
8016                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
8017                                 uint8_t *, IV_OFFSET);
8018
8019                 /* Copy IV 1 byte after the IV pointer, according to the API */
8020                 rte_memcpy(iv_ptr + 1, tdata->iv.data, tdata->iv.len);
8021                 debug_hexdump(stdout, "iv:", iv_ptr,
8022                         tdata->iv.len);
8023         } else {
8024                 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
8025                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8026                                 aad_pad_len);
8027                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
8028                                 "no room to append aad");
8029
8030                 sym_op->aead.aad.phys_addr =
8031                                 rte_pktmbuf_iova(ut_params->ibuf);
8032                 memcpy(sym_op->aead.aad.data, tdata->aad.data, tdata->aad.len);
8033                 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
8034                         tdata->aad.len);
8035
8036                 /* Append IV at the end of the crypto operation*/
8037                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
8038                                 uint8_t *, IV_OFFSET);
8039
8040                 if (tdata->iv.len == 0) {
8041                         rte_memcpy(iv_ptr, tdata->iv.data, AES_GCM_J0_LENGTH);
8042                         debug_hexdump(stdout, "iv:", iv_ptr,
8043                                 AES_GCM_J0_LENGTH);
8044                 } else {
8045                         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
8046                         debug_hexdump(stdout, "iv:", iv_ptr,
8047                                 tdata->iv.len);
8048                 }
8049         }
8050
8051         /* Append plaintext/ciphertext */
8052         if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
8053                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
8054                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8055                                 plaintext_pad_len);
8056                 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
8057
8058                 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
8059                 debug_hexdump(stdout, "plaintext:", plaintext,
8060                                 tdata->plaintext.len);
8061
8062                 if (ut_params->obuf) {
8063                         ciphertext = (uint8_t *)rte_pktmbuf_append(
8064                                         ut_params->obuf,
8065                                         plaintext_pad_len + aad_pad_len);
8066                         TEST_ASSERT_NOT_NULL(ciphertext,
8067                                         "no room to append ciphertext");
8068
8069                         memset(ciphertext + aad_pad_len, 0,
8070                                         tdata->ciphertext.len);
8071                 }
8072         } else {
8073                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16);
8074                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8075                                 plaintext_pad_len);
8076                 TEST_ASSERT_NOT_NULL(ciphertext,
8077                                 "no room to append ciphertext");
8078
8079                 memcpy(ciphertext, tdata->ciphertext.data,
8080                                 tdata->ciphertext.len);
8081                 debug_hexdump(stdout, "ciphertext:", ciphertext,
8082                                 tdata->ciphertext.len);
8083
8084                 if (ut_params->obuf) {
8085                         plaintext = (uint8_t *)rte_pktmbuf_append(
8086                                         ut_params->obuf,
8087                                         plaintext_pad_len + aad_pad_len);
8088                         TEST_ASSERT_NOT_NULL(plaintext,
8089                                         "no room to append plaintext");
8090
8091                         memset(plaintext + aad_pad_len, 0,
8092                                         tdata->plaintext.len);
8093                 }
8094         }
8095
8096         /* Append digest data */
8097         if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
8098                 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
8099                                 ut_params->obuf ? ut_params->obuf :
8100                                                 ut_params->ibuf,
8101                                                 tdata->auth_tag.len);
8102                 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
8103                                 "no room to append digest");
8104                 memset(sym_op->aead.digest.data, 0, tdata->auth_tag.len);
8105                 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
8106                                 ut_params->obuf ? ut_params->obuf :
8107                                                 ut_params->ibuf,
8108                                                 plaintext_pad_len +
8109                                                 aad_pad_len);
8110         } else {
8111                 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
8112                                 ut_params->ibuf, tdata->auth_tag.len);
8113                 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
8114                                 "no room to append digest");
8115                 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
8116                                 ut_params->ibuf,
8117                                 plaintext_pad_len + aad_pad_len);
8118
8119                 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
8120                         tdata->auth_tag.len);
8121                 debug_hexdump(stdout, "digest:",
8122                         sym_op->aead.digest.data,
8123                         tdata->auth_tag.len);
8124         }
8125
8126         sym_op->aead.data.length = tdata->plaintext.len;
8127         sym_op->aead.data.offset = aad_pad_len;
8128
8129         return 0;
8130 }
8131
8132 static int
8133 test_authenticated_encryption(const struct aead_test_data *tdata)
8134 {
8135         struct crypto_testsuite_params *ts_params = &testsuite_params;
8136         struct crypto_unittest_params *ut_params = &unittest_params;
8137
8138         int retval;
8139         uint8_t *ciphertext, *auth_tag;
8140         uint16_t plaintext_pad_len;
8141         uint32_t i;
8142         struct rte_cryptodev_info dev_info;
8143
8144         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8145         uint64_t feat_flags = dev_info.feature_flags;
8146
8147         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
8148                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
8149                 printf("Device doesn't support RAW data-path APIs.\n");
8150                 return TEST_SKIPPED;
8151         }
8152
8153         /* Verify the capabilities */
8154         struct rte_cryptodev_sym_capability_idx cap_idx;
8155         const struct rte_cryptodev_symmetric_capability *capability;
8156         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
8157         cap_idx.algo.aead = tdata->algo;
8158         capability = rte_cryptodev_sym_capability_get(
8159                         ts_params->valid_devs[0], &cap_idx);
8160         if (capability == NULL)
8161                 return TEST_SKIPPED;
8162         if (rte_cryptodev_sym_capability_check_aead(
8163                         capability, tdata->key.len, tdata->auth_tag.len,
8164                         tdata->aad.len, tdata->iv.len))
8165                 return TEST_SKIPPED;
8166
8167         /* Create AEAD session */
8168         retval = create_aead_session(ts_params->valid_devs[0],
8169                         tdata->algo,
8170                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
8171                         tdata->key.data, tdata->key.len,
8172                         tdata->aad.len, tdata->auth_tag.len,
8173                         tdata->iv.len);
8174         if (retval < 0)
8175                 return retval;
8176
8177         if (tdata->aad.len > MBUF_SIZE) {
8178                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
8179                 /* Populate full size of add data */
8180                 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
8181                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
8182         } else
8183                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8184
8185         /* clear mbuf payload */
8186         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8187                         rte_pktmbuf_tailroom(ut_params->ibuf));
8188
8189         /* Create AEAD operation */
8190         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
8191         if (retval < 0)
8192                 return retval;
8193
8194         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
8195
8196         ut_params->op->sym->m_src = ut_params->ibuf;
8197
8198         /* Process crypto operation */
8199         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
8200                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
8201         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
8202                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
8203                                 ut_params->op, 0, 0, 0, 0);
8204         else
8205                 TEST_ASSERT_NOT_NULL(
8206                         process_crypto_request(ts_params->valid_devs[0],
8207                         ut_params->op), "failed to process sym crypto op");
8208
8209         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8210                         "crypto op processing failed");
8211
8212         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
8213
8214         if (ut_params->op->sym->m_dst) {
8215                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8216                                 uint8_t *);
8217                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
8218                                 uint8_t *, plaintext_pad_len);
8219         } else {
8220                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
8221                                 uint8_t *,
8222                                 ut_params->op->sym->cipher.data.offset);
8223                 auth_tag = ciphertext + plaintext_pad_len;
8224         }
8225
8226         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
8227         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
8228
8229         /* Validate obuf */
8230         TEST_ASSERT_BUFFERS_ARE_EQUAL(
8231                         ciphertext,
8232                         tdata->ciphertext.data,
8233                         tdata->ciphertext.len,
8234                         "Ciphertext data not as expected");
8235
8236         TEST_ASSERT_BUFFERS_ARE_EQUAL(
8237                         auth_tag,
8238                         tdata->auth_tag.data,
8239                         tdata->auth_tag.len,
8240                         "Generated auth tag not as expected");
8241
8242         return 0;
8243
8244 }
8245
8246 #ifdef RTE_LIB_SECURITY
8247 static int
8248 security_proto_supported(enum rte_security_session_action_type action,
8249         enum rte_security_session_protocol proto)
8250 {
8251         struct crypto_testsuite_params *ts_params = &testsuite_params;
8252
8253         const struct rte_security_capability *capabilities;
8254         const struct rte_security_capability *capability;
8255         uint16_t i = 0;
8256
8257         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8258                                 rte_cryptodev_get_sec_ctx(
8259                                 ts_params->valid_devs[0]);
8260
8261
8262         capabilities = rte_security_capabilities_get(ctx);
8263
8264         if (capabilities == NULL)
8265                 return -ENOTSUP;
8266
8267         while ((capability = &capabilities[i++])->action !=
8268                         RTE_SECURITY_ACTION_TYPE_NONE) {
8269                 if (capability->action == action &&
8270                                 capability->protocol == proto)
8271                         return 0;
8272         }
8273
8274         return -ENOTSUP;
8275 }
8276
8277 /* Basic algorithm run function for async inplace mode.
8278  * Creates a session from input parameters and runs one operation
8279  * on input_vec. Checks the output of the crypto operation against
8280  * output_vec.
8281  */
8282 static int test_pdcp_proto(int i, int oop, enum rte_crypto_cipher_operation opc,
8283                            enum rte_crypto_auth_operation opa,
8284                            const uint8_t *input_vec, unsigned int input_vec_len,
8285                            const uint8_t *output_vec,
8286                            unsigned int output_vec_len,
8287                            enum rte_crypto_cipher_algorithm cipher_alg,
8288                            const uint8_t *cipher_key, uint32_t cipher_key_len,
8289                            enum rte_crypto_auth_algorithm auth_alg,
8290                            const uint8_t *auth_key, uint32_t auth_key_len,
8291                            uint8_t bearer, enum rte_security_pdcp_domain domain,
8292                            uint8_t packet_direction, uint8_t sn_size,
8293                            uint32_t hfn, uint32_t hfn_threshold, uint8_t sdap)
8294 {
8295         struct crypto_testsuite_params *ts_params = &testsuite_params;
8296         struct crypto_unittest_params *ut_params = &unittest_params;
8297         uint8_t *plaintext;
8298         int ret = TEST_SUCCESS;
8299         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8300                                 rte_cryptodev_get_sec_ctx(
8301                                 ts_params->valid_devs[0]);
8302
8303         /* Verify the capabilities */
8304         struct rte_security_capability_idx sec_cap_idx;
8305
8306         sec_cap_idx.action = ut_params->type;
8307         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
8308         sec_cap_idx.pdcp.domain = domain;
8309         if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
8310                 return TEST_SKIPPED;
8311
8312         /* Generate test mbuf data */
8313         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8314
8315         /* clear mbuf payload */
8316         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8317                         rte_pktmbuf_tailroom(ut_params->ibuf));
8318
8319         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8320                                                   input_vec_len);
8321         memcpy(plaintext, input_vec, input_vec_len);
8322
8323         /* Out of place support */
8324         if (oop) {
8325                 /*
8326                  * For out-op-place we need to alloc another mbuf
8327                  */
8328                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8329                 rte_pktmbuf_append(ut_params->obuf, output_vec_len);
8330         }
8331
8332         /* Setup Cipher Parameters */
8333         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8334         ut_params->cipher_xform.cipher.algo = cipher_alg;
8335         ut_params->cipher_xform.cipher.op = opc;
8336         ut_params->cipher_xform.cipher.key.data = cipher_key;
8337         ut_params->cipher_xform.cipher.key.length = cipher_key_len;
8338         ut_params->cipher_xform.cipher.iv.length =
8339                                 packet_direction ? 4 : 0;
8340         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
8341
8342         /* Setup HMAC Parameters if ICV header is required */
8343         if (auth_alg != 0) {
8344                 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8345                 ut_params->auth_xform.next = NULL;
8346                 ut_params->auth_xform.auth.algo = auth_alg;
8347                 ut_params->auth_xform.auth.op = opa;
8348                 ut_params->auth_xform.auth.key.data = auth_key;
8349                 ut_params->auth_xform.auth.key.length = auth_key_len;
8350
8351                 ut_params->cipher_xform.next = &ut_params->auth_xform;
8352         } else {
8353                 ut_params->cipher_xform.next = NULL;
8354         }
8355
8356         struct rte_security_session_conf sess_conf = {
8357                 .action_type = ut_params->type,
8358                 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
8359                 {.pdcp = {
8360                         .bearer = bearer,
8361                         .domain = domain,
8362                         .pkt_dir = packet_direction,
8363                         .sn_size = sn_size,
8364                         .hfn = packet_direction ? 0 : hfn,
8365                         /**
8366                          * hfn can be set as pdcp_test_hfn[i]
8367                          * if hfn_ovrd is not set. Here, PDCP
8368                          * packet direction is just used to
8369                          * run half of the cases with session
8370                          * HFN and other half with per packet
8371                          * HFN.
8372                          */
8373                         .hfn_threshold = hfn_threshold,
8374                         .hfn_ovrd = packet_direction ? 1 : 0,
8375                         .sdap_enabled = sdap,
8376                 } },
8377                 .crypto_xform = &ut_params->cipher_xform
8378         };
8379
8380         /* Create security session */
8381         ut_params->sec_session = rte_security_session_create(ctx,
8382                                 &sess_conf, ts_params->session_mpool,
8383                                 ts_params->session_priv_mpool);
8384
8385         if (!ut_params->sec_session) {
8386                 printf("TestCase %s()-%d line %d failed %s: ",
8387                         __func__, i, __LINE__, "Failed to allocate session");
8388                 ret = TEST_FAILED;
8389                 goto on_err;
8390         }
8391
8392         /* Generate crypto op data structure */
8393         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8394                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8395         if (!ut_params->op) {
8396                 printf("TestCase %s()-%d line %d failed %s: ",
8397                         __func__, i, __LINE__,
8398                         "Failed to allocate symmetric crypto operation struct");
8399                 ret = TEST_FAILED;
8400                 goto on_err;
8401         }
8402
8403         uint32_t *per_pkt_hfn = rte_crypto_op_ctod_offset(ut_params->op,
8404                                         uint32_t *, IV_OFFSET);
8405         *per_pkt_hfn = packet_direction ? hfn : 0;
8406
8407         rte_security_attach_session(ut_params->op, ut_params->sec_session);
8408
8409         /* set crypto operation source mbuf */
8410         ut_params->op->sym->m_src = ut_params->ibuf;
8411         if (oop)
8412                 ut_params->op->sym->m_dst = ut_params->obuf;
8413
8414         /* Process crypto operation */
8415         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op)
8416                 == NULL) {
8417                 printf("TestCase %s()-%d line %d failed %s: ",
8418                         __func__, i, __LINE__,
8419                         "failed to process sym crypto op");
8420                 ret = TEST_FAILED;
8421                 goto on_err;
8422         }
8423
8424         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8425                 printf("TestCase %s()-%d line %d failed %s: ",
8426                         __func__, i, __LINE__, "crypto op processing failed");
8427                 ret = TEST_FAILED;
8428                 goto on_err;
8429         }
8430
8431         /* Validate obuf */
8432         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
8433                         uint8_t *);
8434         if (oop) {
8435                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8436                                 uint8_t *);
8437         }
8438
8439         if (memcmp(ciphertext, output_vec, output_vec_len)) {
8440                 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8441                 rte_hexdump(stdout, "encrypted", ciphertext, output_vec_len);
8442                 rte_hexdump(stdout, "reference", output_vec, output_vec_len);
8443                 ret = TEST_FAILED;
8444                 goto on_err;
8445         }
8446
8447 on_err:
8448         rte_crypto_op_free(ut_params->op);
8449         ut_params->op = NULL;
8450
8451         if (ut_params->sec_session)
8452                 rte_security_session_destroy(ctx, ut_params->sec_session);
8453         ut_params->sec_session = NULL;
8454
8455         rte_pktmbuf_free(ut_params->ibuf);
8456         ut_params->ibuf = NULL;
8457         if (oop) {
8458                 rte_pktmbuf_free(ut_params->obuf);
8459                 ut_params->obuf = NULL;
8460         }
8461
8462         return ret;
8463 }
8464
8465 static int
8466 test_pdcp_proto_SGL(int i, int oop,
8467         enum rte_crypto_cipher_operation opc,
8468         enum rte_crypto_auth_operation opa,
8469         uint8_t *input_vec,
8470         unsigned int input_vec_len,
8471         uint8_t *output_vec,
8472         unsigned int output_vec_len,
8473         uint32_t fragsz,
8474         uint32_t fragsz_oop)
8475 {
8476         struct crypto_testsuite_params *ts_params = &testsuite_params;
8477         struct crypto_unittest_params *ut_params = &unittest_params;
8478         uint8_t *plaintext;
8479         struct rte_mbuf *buf, *buf_oop = NULL;
8480         int ret = TEST_SUCCESS;
8481         int to_trn = 0;
8482         int to_trn_tbl[16];
8483         int segs = 1;
8484         unsigned int trn_data = 0;
8485         struct rte_cryptodev_info dev_info;
8486         uint64_t feat_flags;
8487         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8488                                 rte_cryptodev_get_sec_ctx(
8489                                 ts_params->valid_devs[0]);
8490         struct rte_mbuf *temp_mbuf;
8491
8492         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8493         feat_flags = dev_info.feature_flags;
8494
8495         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
8496                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
8497                 printf("Device does not support RAW data-path APIs.\n");
8498                 return -ENOTSUP;
8499         }
8500         /* Verify the capabilities */
8501         struct rte_security_capability_idx sec_cap_idx;
8502
8503         sec_cap_idx.action = ut_params->type;
8504         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
8505         sec_cap_idx.pdcp.domain = pdcp_test_params[i].domain;
8506         if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
8507                 return TEST_SKIPPED;
8508
8509         if (fragsz > input_vec_len)
8510                 fragsz = input_vec_len;
8511
8512         uint16_t plaintext_len = fragsz;
8513         uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
8514
8515         if (fragsz_oop > output_vec_len)
8516                 frag_size_oop = output_vec_len;
8517
8518         int ecx = 0;
8519         if (input_vec_len % fragsz != 0) {
8520                 if (input_vec_len / fragsz + 1 > 16)
8521                         return 1;
8522         } else if (input_vec_len / fragsz > 16)
8523                 return 1;
8524
8525         /* Out of place support */
8526         if (oop) {
8527                 /*
8528                  * For out-op-place we need to alloc another mbuf
8529                  */
8530                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8531                 rte_pktmbuf_append(ut_params->obuf, frag_size_oop);
8532                 buf_oop = ut_params->obuf;
8533         }
8534
8535         /* Generate test mbuf data */
8536         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8537
8538         /* clear mbuf payload */
8539         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8540                         rte_pktmbuf_tailroom(ut_params->ibuf));
8541
8542         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8543                                                   plaintext_len);
8544         memcpy(plaintext, input_vec, plaintext_len);
8545         trn_data += plaintext_len;
8546
8547         buf = ut_params->ibuf;
8548
8549         /*
8550          * Loop until no more fragments
8551          */
8552
8553         while (trn_data < input_vec_len) {
8554                 ++segs;
8555                 to_trn = (input_vec_len - trn_data < fragsz) ?
8556                                 (input_vec_len - trn_data) : fragsz;
8557
8558                 to_trn_tbl[ecx++] = to_trn;
8559
8560                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8561                 buf = buf->next;
8562
8563                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
8564                                 rte_pktmbuf_tailroom(buf));
8565
8566                 /* OOP */
8567                 if (oop && !fragsz_oop) {
8568                         buf_oop->next =
8569                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
8570                         buf_oop = buf_oop->next;
8571                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8572                                         0, rte_pktmbuf_tailroom(buf_oop));
8573                         rte_pktmbuf_append(buf_oop, to_trn);
8574                 }
8575
8576                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
8577                                 to_trn);
8578
8579                 memcpy(plaintext, input_vec + trn_data, to_trn);
8580                 trn_data += to_trn;
8581         }
8582
8583         ut_params->ibuf->nb_segs = segs;
8584
8585         segs = 1;
8586         if (fragsz_oop && oop) {
8587                 to_trn = 0;
8588                 ecx = 0;
8589
8590                 trn_data = frag_size_oop;
8591                 while (trn_data < output_vec_len) {
8592                         ++segs;
8593                         to_trn =
8594                                 (output_vec_len - trn_data <
8595                                                 frag_size_oop) ?
8596                                 (output_vec_len - trn_data) :
8597                                                 frag_size_oop;
8598
8599                         to_trn_tbl[ecx++] = to_trn;
8600
8601                         buf_oop->next =
8602                                 rte_pktmbuf_alloc(ts_params->mbuf_pool);
8603                         buf_oop = buf_oop->next;
8604                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8605                                         0, rte_pktmbuf_tailroom(buf_oop));
8606                         rte_pktmbuf_append(buf_oop, to_trn);
8607
8608                         trn_data += to_trn;
8609                 }
8610                 ut_params->obuf->nb_segs = segs;
8611         }
8612
8613         /* Setup Cipher Parameters */
8614         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8615         ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg;
8616         ut_params->cipher_xform.cipher.op = opc;
8617         ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i];
8618         ut_params->cipher_xform.cipher.key.length =
8619                                         pdcp_test_params[i].cipher_key_len;
8620         ut_params->cipher_xform.cipher.iv.length = 0;
8621
8622         /* Setup HMAC Parameters if ICV header is required */
8623         if (pdcp_test_params[i].auth_alg != 0) {
8624                 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8625                 ut_params->auth_xform.next = NULL;
8626                 ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg;
8627                 ut_params->auth_xform.auth.op = opa;
8628                 ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i];
8629                 ut_params->auth_xform.auth.key.length =
8630                                         pdcp_test_params[i].auth_key_len;
8631
8632                 ut_params->cipher_xform.next = &ut_params->auth_xform;
8633         } else {
8634                 ut_params->cipher_xform.next = NULL;
8635         }
8636
8637         struct rte_security_session_conf sess_conf = {
8638                 .action_type = ut_params->type,
8639                 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
8640                 {.pdcp = {
8641                         .bearer = pdcp_test_bearer[i],
8642                         .domain = pdcp_test_params[i].domain,
8643                         .pkt_dir = pdcp_test_packet_direction[i],
8644                         .sn_size = pdcp_test_data_sn_size[i],
8645                         .hfn = pdcp_test_hfn[i],
8646                         .hfn_threshold = pdcp_test_hfn_threshold[i],
8647                         .hfn_ovrd = 0,
8648                 } },
8649                 .crypto_xform = &ut_params->cipher_xform
8650         };
8651
8652         /* Create security session */
8653         ut_params->sec_session = rte_security_session_create(ctx,
8654                                 &sess_conf, ts_params->session_mpool,
8655                                 ts_params->session_priv_mpool);
8656
8657         if (!ut_params->sec_session) {
8658                 printf("TestCase %s()-%d line %d failed %s: ",
8659                         __func__, i, __LINE__, "Failed to allocate session");
8660                 ret = TEST_FAILED;
8661                 goto on_err;
8662         }
8663
8664         /* Generate crypto op data structure */
8665         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8666                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8667         if (!ut_params->op) {
8668                 printf("TestCase %s()-%d line %d failed %s: ",
8669                         __func__, i, __LINE__,
8670                         "Failed to allocate symmetric crypto operation struct");
8671                 ret = TEST_FAILED;
8672                 goto on_err;
8673         }
8674
8675         rte_security_attach_session(ut_params->op, ut_params->sec_session);
8676
8677         /* set crypto operation source mbuf */
8678         ut_params->op->sym->m_src = ut_params->ibuf;
8679         if (oop)
8680                 ut_params->op->sym->m_dst = ut_params->obuf;
8681
8682         /* Process crypto operation */
8683         temp_mbuf = ut_params->op->sym->m_src;
8684         if (global_api_test_type == CRYPTODEV_RAW_API_TEST) {
8685                 /* filling lengths */
8686                 while (temp_mbuf) {
8687                         ut_params->op->sym->cipher.data.length
8688                                 += temp_mbuf->pkt_len;
8689                         ut_params->op->sym->auth.data.length
8690                                 += temp_mbuf->pkt_len;
8691                         temp_mbuf = temp_mbuf->next;
8692                 }
8693                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
8694                         ut_params->op, 1, 1, 0, 0);
8695         } else {
8696                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
8697                                                         ut_params->op);
8698         }
8699         if (ut_params->op == NULL) {
8700                 printf("TestCase %s()-%d line %d failed %s: ",
8701                         __func__, i, __LINE__,
8702                         "failed to process sym crypto op");
8703                 ret = TEST_FAILED;
8704                 goto on_err;
8705         }
8706
8707         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8708                 printf("TestCase %s()-%d line %d failed %s: ",
8709                         __func__, i, __LINE__, "crypto op processing failed");
8710                 ret = TEST_FAILED;
8711                 goto on_err;
8712         }
8713
8714         /* Validate obuf */
8715         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
8716                         uint8_t *);
8717         if (oop) {
8718                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8719                                 uint8_t *);
8720         }
8721         if (fragsz_oop)
8722                 fragsz = frag_size_oop;
8723         if (memcmp(ciphertext, output_vec, fragsz)) {
8724                 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8725                 rte_hexdump(stdout, "encrypted", ciphertext, fragsz);
8726                 rte_hexdump(stdout, "reference", output_vec, fragsz);
8727                 ret = TEST_FAILED;
8728                 goto on_err;
8729         }
8730
8731         buf = ut_params->op->sym->m_src->next;
8732         if (oop)
8733                 buf = ut_params->op->sym->m_dst->next;
8734
8735         unsigned int off = fragsz;
8736
8737         ecx = 0;
8738         while (buf) {
8739                 ciphertext = rte_pktmbuf_mtod(buf,
8740                                 uint8_t *);
8741                 if (memcmp(ciphertext, output_vec + off, to_trn_tbl[ecx])) {
8742                         printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8743                         rte_hexdump(stdout, "encrypted", ciphertext, to_trn_tbl[ecx]);
8744                         rte_hexdump(stdout, "reference", output_vec + off,
8745                                         to_trn_tbl[ecx]);
8746                         ret = TEST_FAILED;
8747                         goto on_err;
8748                 }
8749                 off += to_trn_tbl[ecx++];
8750                 buf = buf->next;
8751         }
8752 on_err:
8753         rte_crypto_op_free(ut_params->op);
8754         ut_params->op = NULL;
8755
8756         if (ut_params->sec_session)
8757                 rte_security_session_destroy(ctx, ut_params->sec_session);
8758         ut_params->sec_session = NULL;
8759
8760         rte_pktmbuf_free(ut_params->ibuf);
8761         ut_params->ibuf = NULL;
8762         if (oop) {
8763                 rte_pktmbuf_free(ut_params->obuf);
8764                 ut_params->obuf = NULL;
8765         }
8766
8767         return ret;
8768 }
8769
8770 int
8771 test_pdcp_proto_cplane_encap(int i)
8772 {
8773         return test_pdcp_proto(
8774                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8775                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8776                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8777                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8778                 pdcp_test_params[i].cipher_key_len,
8779                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8780                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8781                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8782                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8783                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8784 }
8785
8786 int
8787 test_pdcp_proto_uplane_encap(int i)
8788 {
8789         return test_pdcp_proto(
8790                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8791                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8792                 pdcp_test_data_out[i], pdcp_test_data_in_len[i],
8793                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8794                 pdcp_test_params[i].cipher_key_len,
8795                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8796                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8797                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8798                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8799                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8800 }
8801
8802 int
8803 test_pdcp_proto_uplane_encap_with_int(int i)
8804 {
8805         return test_pdcp_proto(
8806                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8807                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8808                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8809                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8810                 pdcp_test_params[i].cipher_key_len,
8811                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8812                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8813                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8814                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8815                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8816 }
8817
8818 int
8819 test_pdcp_proto_cplane_decap(int i)
8820 {
8821         return test_pdcp_proto(
8822                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8823                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8824                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8825                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8826                 pdcp_test_params[i].cipher_key_len,
8827                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8828                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8829                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8830                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8831                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8832 }
8833
8834 int
8835 test_pdcp_proto_uplane_decap(int i)
8836 {
8837         return test_pdcp_proto(
8838                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8839                 pdcp_test_data_out[i], pdcp_test_data_in_len[i],
8840                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8841                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8842                 pdcp_test_params[i].cipher_key_len,
8843                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8844                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8845                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8846                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8847                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8848 }
8849
8850 int
8851 test_pdcp_proto_uplane_decap_with_int(int i)
8852 {
8853         return test_pdcp_proto(
8854                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8855                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8856                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8857                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8858                 pdcp_test_params[i].cipher_key_len,
8859                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8860                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8861                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8862                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8863                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8864 }
8865
8866 static int
8867 test_PDCP_PROTO_SGL_in_place_32B(void)
8868 {
8869         /* i can be used for running any PDCP case
8870          * In this case it is uplane 12-bit AES-SNOW DL encap
8871          */
8872         int i = PDCP_UPLANE_12BIT_OFFSET + AES_ENC + SNOW_AUTH + DOWNLINK;
8873         return test_pdcp_proto_SGL(i, IN_PLACE,
8874                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8875                         RTE_CRYPTO_AUTH_OP_GENERATE,
8876                         pdcp_test_data_in[i],
8877                         pdcp_test_data_in_len[i],
8878                         pdcp_test_data_out[i],
8879                         pdcp_test_data_in_len[i]+4,
8880                         32, 0);
8881 }
8882 static int
8883 test_PDCP_PROTO_SGL_oop_32B_128B(void)
8884 {
8885         /* i can be used for running any PDCP case
8886          * In this case it is uplane 18-bit NULL-NULL DL encap
8887          */
8888         int i = PDCP_UPLANE_18BIT_OFFSET + NULL_ENC + NULL_AUTH + DOWNLINK;
8889         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8890                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8891                         RTE_CRYPTO_AUTH_OP_GENERATE,
8892                         pdcp_test_data_in[i],
8893                         pdcp_test_data_in_len[i],
8894                         pdcp_test_data_out[i],
8895                         pdcp_test_data_in_len[i]+4,
8896                         32, 128);
8897 }
8898 static int
8899 test_PDCP_PROTO_SGL_oop_32B_40B(void)
8900 {
8901         /* i can be used for running any PDCP case
8902          * In this case it is uplane 18-bit AES DL encap
8903          */
8904         int i = PDCP_UPLANE_OFFSET + AES_ENC + EIGHTEEN_BIT_SEQ_NUM_OFFSET
8905                         + DOWNLINK;
8906         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8907                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8908                         RTE_CRYPTO_AUTH_OP_GENERATE,
8909                         pdcp_test_data_in[i],
8910                         pdcp_test_data_in_len[i],
8911                         pdcp_test_data_out[i],
8912                         pdcp_test_data_in_len[i],
8913                         32, 40);
8914 }
8915 static int
8916 test_PDCP_PROTO_SGL_oop_128B_32B(void)
8917 {
8918         /* i can be used for running any PDCP case
8919          * In this case it is cplane 12-bit AES-ZUC DL encap
8920          */
8921         int i = PDCP_CPLANE_LONG_SN_OFFSET + AES_ENC + ZUC_AUTH + DOWNLINK;
8922         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8923                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8924                         RTE_CRYPTO_AUTH_OP_GENERATE,
8925                         pdcp_test_data_in[i],
8926                         pdcp_test_data_in_len[i],
8927                         pdcp_test_data_out[i],
8928                         pdcp_test_data_in_len[i]+4,
8929                         128, 32);
8930 }
8931
8932 static int
8933 test_PDCP_SDAP_PROTO_encap_all(void)
8934 {
8935         int i = 0, size = 0;
8936         int err, all_err = TEST_SUCCESS;
8937         const struct pdcp_sdap_test *cur_test;
8938
8939         size = RTE_DIM(list_pdcp_sdap_tests);
8940
8941         for (i = 0; i < size; i++) {
8942                 cur_test = &list_pdcp_sdap_tests[i];
8943                 err = test_pdcp_proto(
8944                         i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8945                         RTE_CRYPTO_AUTH_OP_GENERATE, cur_test->data_in,
8946                         cur_test->in_len, cur_test->data_out,
8947                         cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
8948                         cur_test->param.cipher_alg, cur_test->cipher_key,
8949                         cur_test->param.cipher_key_len,
8950                         cur_test->param.auth_alg,
8951                         cur_test->auth_key, cur_test->param.auth_key_len,
8952                         cur_test->bearer, cur_test->param.domain,
8953                         cur_test->packet_direction, cur_test->sn_size,
8954                         cur_test->hfn,
8955                         cur_test->hfn_threshold, SDAP_ENABLED);
8956                 if (err) {
8957                         printf("\t%d) %s: Encapsulation failed\n",
8958                                         cur_test->test_idx,
8959                                         cur_test->param.name);
8960                         err = TEST_FAILED;
8961                 } else {
8962                         printf("\t%d) %s: Encap PASS\n", cur_test->test_idx,
8963                                         cur_test->param.name);
8964                         err = TEST_SUCCESS;
8965                 }
8966                 all_err += err;
8967         }
8968
8969         printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
8970
8971         return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
8972 }
8973
8974 static int
8975 test_PDCP_PROTO_short_mac(void)
8976 {
8977         int i = 0, size = 0;
8978         int err, all_err = TEST_SUCCESS;
8979         const struct pdcp_short_mac_test *cur_test;
8980
8981         size = RTE_DIM(list_pdcp_smac_tests);
8982
8983         for (i = 0; i < size; i++) {
8984                 cur_test = &list_pdcp_smac_tests[i];
8985                 err = test_pdcp_proto(
8986                         i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8987                         RTE_CRYPTO_AUTH_OP_GENERATE, cur_test->data_in,
8988                         cur_test->in_len, cur_test->data_out,
8989                         cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
8990                         RTE_CRYPTO_CIPHER_NULL, NULL,
8991                         0, cur_test->param.auth_alg,
8992                         cur_test->auth_key, cur_test->param.auth_key_len,
8993                         0, cur_test->param.domain, 0, 0,
8994                         0, 0, 0);
8995                 if (err) {
8996                         printf("\t%d) %s: Short MAC test failed\n",
8997                                         cur_test->test_idx,
8998                                         cur_test->param.name);
8999                         err = TEST_FAILED;
9000                 } else {
9001                         printf("\t%d) %s: Short MAC test PASS\n",
9002                                         cur_test->test_idx,
9003                                         cur_test->param.name);
9004                         rte_hexdump(stdout, "MAC I",
9005                                     cur_test->data_out + cur_test->in_len + 2,
9006                                     2);
9007                         err = TEST_SUCCESS;
9008                 }
9009                 all_err += err;
9010         }
9011
9012         printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
9013
9014         return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
9015
9016 }
9017
9018 static int
9019 test_PDCP_SDAP_PROTO_decap_all(void)
9020 {
9021         int i = 0, size = 0;
9022         int err, all_err = TEST_SUCCESS;
9023         const struct pdcp_sdap_test *cur_test;
9024
9025         size = RTE_DIM(list_pdcp_sdap_tests);
9026
9027         for (i = 0; i < size; i++) {
9028                 cur_test = &list_pdcp_sdap_tests[i];
9029                 err = test_pdcp_proto(
9030                         i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT,
9031                         RTE_CRYPTO_AUTH_OP_VERIFY,
9032                         cur_test->data_out,
9033                         cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
9034                         cur_test->data_in, cur_test->in_len,
9035                         cur_test->param.cipher_alg,
9036                         cur_test->cipher_key, cur_test->param.cipher_key_len,
9037                         cur_test->param.auth_alg, cur_test->auth_key,
9038                         cur_test->param.auth_key_len, cur_test->bearer,
9039                         cur_test->param.domain, cur_test->packet_direction,
9040                         cur_test->sn_size, cur_test->hfn,
9041                         cur_test->hfn_threshold, SDAP_ENABLED);
9042                 if (err) {
9043                         printf("\t%d) %s: Decapsulation failed\n",
9044                                         cur_test->test_idx,
9045                                         cur_test->param.name);
9046                         err = TEST_FAILED;
9047                 } else {
9048                         printf("\t%d) %s: Decap PASS\n", cur_test->test_idx,
9049                                         cur_test->param.name);
9050                         err = TEST_SUCCESS;
9051                 }
9052                 all_err += err;
9053         }
9054
9055         printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
9056
9057         return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
9058 }
9059
9060 static int
9061 test_ipsec_proto_process(const struct ipsec_test_data td[],
9062                          struct ipsec_test_data res_d[],
9063                          int nb_td,
9064                          bool silent,
9065                          const struct ipsec_test_flags *flags)
9066 {
9067         struct crypto_testsuite_params *ts_params = &testsuite_params;
9068         struct crypto_unittest_params *ut_params = &unittest_params;
9069         struct rte_security_capability_idx sec_cap_idx;
9070         const struct rte_security_capability *sec_cap;
9071         struct rte_security_ipsec_xform ipsec_xform;
9072         uint8_t dev_id = ts_params->valid_devs[0];
9073         enum rte_security_ipsec_sa_direction dir;
9074         struct ipsec_test_data *res_d_tmp = NULL;
9075         uint32_t src = RTE_IPV4(192, 168, 1, 0);
9076         uint32_t dst = RTE_IPV4(192, 168, 1, 1);
9077         int salt_len, i, ret = TEST_SUCCESS;
9078         struct rte_security_ctx *ctx;
9079         uint8_t *input_text;
9080         uint32_t verify;
9081
9082         ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
9083         gbl_action_type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
9084
9085         /* Use first test data to create session */
9086
9087         /* Copy IPsec xform */
9088         memcpy(&ipsec_xform, &td[0].ipsec_xform, sizeof(ipsec_xform));
9089
9090         dir = ipsec_xform.direction;
9091         verify = flags->tunnel_hdr_verify;
9092
9093         if ((dir == RTE_SECURITY_IPSEC_SA_DIR_INGRESS) && verify) {
9094                 if (verify == RTE_SECURITY_IPSEC_TUNNEL_VERIFY_SRC_DST_ADDR)
9095                         src += 1;
9096                 else if (verify == RTE_SECURITY_IPSEC_TUNNEL_VERIFY_DST_ADDR)
9097                         dst += 1;
9098         }
9099
9100         memcpy(&ipsec_xform.tunnel.ipv4.src_ip, &src, sizeof(src));
9101         memcpy(&ipsec_xform.tunnel.ipv4.dst_ip, &dst, sizeof(dst));
9102
9103         ctx = rte_cryptodev_get_sec_ctx(dev_id);
9104
9105         sec_cap_idx.action = ut_params->type;
9106         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_IPSEC;
9107         sec_cap_idx.ipsec.proto = ipsec_xform.proto;
9108         sec_cap_idx.ipsec.mode = ipsec_xform.mode;
9109         sec_cap_idx.ipsec.direction = ipsec_xform.direction;
9110
9111         if (flags->udp_encap)
9112                 ipsec_xform.options.udp_encap = 1;
9113
9114         sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
9115         if (sec_cap == NULL)
9116                 return TEST_SKIPPED;
9117
9118         /* Copy cipher session parameters */
9119         if (td[0].aead) {
9120                 memcpy(&ut_params->aead_xform, &td[0].xform.aead,
9121                        sizeof(ut_params->aead_xform));
9122                 ut_params->aead_xform.aead.key.data = td[0].key.data;
9123                 ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
9124
9125                 /* Verify crypto capabilities */
9126                 if (test_ipsec_crypto_caps_aead_verify(
9127                                 sec_cap,
9128                                 &ut_params->aead_xform) != 0) {
9129                         if (!silent)
9130                                 RTE_LOG(INFO, USER1,
9131                                         "Crypto capabilities not supported\n");
9132                         return TEST_SKIPPED;
9133                 }
9134         } else {
9135                 /* Only AEAD supported now */
9136                 return TEST_SKIPPED;
9137         }
9138
9139         if (test_ipsec_sec_caps_verify(&ipsec_xform, sec_cap, silent) != 0)
9140                 return TEST_SKIPPED;
9141
9142         salt_len = RTE_MIN(sizeof(ipsec_xform.salt), td[0].salt.len);
9143         memcpy(&ipsec_xform.salt, td[0].salt.data, salt_len);
9144
9145         struct rte_security_session_conf sess_conf = {
9146                 .action_type = ut_params->type,
9147                 .protocol = RTE_SECURITY_PROTOCOL_IPSEC,
9148                 .ipsec = ipsec_xform,
9149                 .crypto_xform = &ut_params->aead_xform,
9150         };
9151
9152         /* Create security session */
9153         ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
9154                                         ts_params->session_mpool,
9155                                         ts_params->session_priv_mpool);
9156
9157         if (ut_params->sec_session == NULL)
9158                 return TEST_SKIPPED;
9159
9160         for (i = 0; i < nb_td; i++) {
9161                 /* Setup source mbuf payload */
9162                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9163                 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9164                                 rte_pktmbuf_tailroom(ut_params->ibuf));
9165
9166                 input_text = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9167                                 td[i].input_text.len);
9168
9169                 memcpy(input_text, td[i].input_text.data,
9170                        td[i].input_text.len);
9171
9172                 /* Generate crypto op data structure */
9173                 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9174                                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9175                 if (!ut_params->op) {
9176                         printf("TestCase %s line %d: %s\n",
9177                                 __func__, __LINE__,
9178                                 "failed to allocate crypto op");
9179                         ret = TEST_FAILED;
9180                         goto crypto_op_free;
9181                 }
9182
9183                 /* Attach session to operation */
9184                 rte_security_attach_session(ut_params->op,
9185                                             ut_params->sec_session);
9186
9187                 /* Set crypto operation mbufs */
9188                 ut_params->op->sym->m_src = ut_params->ibuf;
9189                 ut_params->op->sym->m_dst = NULL;
9190
9191                 /* Copy IV in crypto operation when IV generation is disabled */
9192                 if (dir == RTE_SECURITY_IPSEC_SA_DIR_EGRESS &&
9193                     ipsec_xform.options.iv_gen_disable == 1) {
9194                         uint8_t *iv = rte_crypto_op_ctod_offset(ut_params->op,
9195                                                                 uint8_t *,
9196                                                                 IV_OFFSET);
9197                         int len;
9198
9199                         if (td[i].aead)
9200                                 len = td[i].xform.aead.aead.iv.length;
9201                         else
9202                                 len = td[i].xform.chain.cipher.cipher.iv.length;
9203
9204                         memcpy(iv, td[i].iv.data, len);
9205                 }
9206
9207                 /* Process crypto operation */
9208                 process_crypto_request(dev_id, ut_params->op);
9209
9210                 ret = test_ipsec_status_check(ut_params->op, flags, dir, i + 1);
9211                 if (ret != TEST_SUCCESS)
9212                         goto crypto_op_free;
9213
9214                 if (res_d != NULL)
9215                         res_d_tmp = &res_d[i];
9216
9217                 ret = test_ipsec_post_process(ut_params->ibuf, &td[i],
9218                                               res_d_tmp, silent, flags);
9219                 if (ret != TEST_SUCCESS)
9220                         goto crypto_op_free;
9221
9222                 rte_crypto_op_free(ut_params->op);
9223                 ut_params->op = NULL;
9224
9225                 rte_pktmbuf_free(ut_params->ibuf);
9226                 ut_params->ibuf = NULL;
9227         }
9228
9229 crypto_op_free:
9230         rte_crypto_op_free(ut_params->op);
9231         ut_params->op = NULL;
9232
9233         rte_pktmbuf_free(ut_params->ibuf);
9234         ut_params->ibuf = NULL;
9235
9236         if (ut_params->sec_session)
9237                 rte_security_session_destroy(ctx, ut_params->sec_session);
9238         ut_params->sec_session = NULL;
9239
9240         return ret;
9241 }
9242
9243 static int
9244 test_ipsec_proto_known_vec(const void *test_data)
9245 {
9246         struct ipsec_test_data td_outb;
9247         struct ipsec_test_flags flags;
9248
9249         memset(&flags, 0, sizeof(flags));
9250
9251         memcpy(&td_outb, test_data, sizeof(td_outb));
9252
9253         /* Disable IV gen to be able to test with known vectors */
9254         td_outb.ipsec_xform.options.iv_gen_disable = 1;
9255
9256         return test_ipsec_proto_process(&td_outb, NULL, 1, false, &flags);
9257 }
9258
9259 static int
9260 test_ipsec_proto_known_vec_inb(const void *td_outb)
9261 {
9262         struct ipsec_test_flags flags;
9263         struct ipsec_test_data td_inb;
9264
9265         memset(&flags, 0, sizeof(flags));
9266
9267         test_ipsec_td_in_from_out(td_outb, &td_inb);
9268
9269         return test_ipsec_proto_process(&td_inb, NULL, 1, false, &flags);
9270 }
9271
9272 static int
9273 test_ipsec_proto_all(const struct ipsec_test_flags *flags)
9274 {
9275         struct ipsec_test_data td_outb[IPSEC_TEST_PACKETS_MAX];
9276         struct ipsec_test_data td_inb[IPSEC_TEST_PACKETS_MAX];
9277         unsigned int i, nb_pkts = 1, pass_cnt = 0;
9278         int ret;
9279
9280         if (flags->iv_gen ||
9281             flags->sa_expiry_pkts_soft ||
9282             flags->sa_expiry_pkts_hard)
9283                 nb_pkts = IPSEC_TEST_PACKETS_MAX;
9284
9285         for (i = 0; i < RTE_DIM(aead_list); i++) {
9286                 test_ipsec_td_prepare(&aead_list[i],
9287                                       NULL,
9288                                       flags,
9289                                       td_outb,
9290                                       nb_pkts);
9291
9292                 ret = test_ipsec_proto_process(td_outb, td_inb, nb_pkts, true,
9293                                                flags);
9294                 if (ret == TEST_SKIPPED)
9295                         continue;
9296
9297                 if (ret == TEST_FAILED)
9298                         return TEST_FAILED;
9299
9300                 test_ipsec_td_update(td_inb, td_outb, nb_pkts, flags);
9301
9302                 ret = test_ipsec_proto_process(td_inb, NULL, nb_pkts, true,
9303                                                flags);
9304                 if (ret == TEST_SKIPPED)
9305                         continue;
9306
9307                 if (ret == TEST_FAILED)
9308                         return TEST_FAILED;
9309
9310                 if (flags->display_alg)
9311                         test_ipsec_display_alg(&aead_list[i], NULL);
9312
9313                 pass_cnt++;
9314         }
9315
9316         if (pass_cnt > 0)
9317                 return TEST_SUCCESS;
9318         else
9319                 return TEST_SKIPPED;
9320 }
9321
9322 static int
9323 test_ipsec_proto_display_list(const void *data __rte_unused)
9324 {
9325         struct ipsec_test_flags flags;
9326
9327         memset(&flags, 0, sizeof(flags));
9328
9329         flags.display_alg = true;
9330
9331         return test_ipsec_proto_all(&flags);
9332 }
9333
9334 static int
9335 test_ipsec_proto_iv_gen(const void *data __rte_unused)
9336 {
9337         struct ipsec_test_flags flags;
9338
9339         memset(&flags, 0, sizeof(flags));
9340
9341         flags.iv_gen = true;
9342
9343         return test_ipsec_proto_all(&flags);
9344 }
9345
9346 static int
9347 test_ipsec_proto_sa_exp_pkts_soft(const void *data __rte_unused)
9348 {
9349         struct ipsec_test_flags flags;
9350
9351         memset(&flags, 0, sizeof(flags));
9352
9353         flags.sa_expiry_pkts_soft = true;
9354
9355         return test_ipsec_proto_all(&flags);
9356 }
9357
9358 static int
9359 test_ipsec_proto_sa_exp_pkts_hard(const void *data __rte_unused)
9360 {
9361         struct ipsec_test_flags flags;
9362
9363         memset(&flags, 0, sizeof(flags));
9364
9365         flags.sa_expiry_pkts_hard = true;
9366
9367         return test_ipsec_proto_all(&flags);
9368 }
9369
9370 static int
9371 test_ipsec_proto_err_icv_corrupt(const void *data __rte_unused)
9372 {
9373         struct ipsec_test_flags flags;
9374
9375         memset(&flags, 0, sizeof(flags));
9376
9377         flags.icv_corrupt = true;
9378
9379         return test_ipsec_proto_all(&flags);
9380 }
9381
9382 static int
9383 test_ipsec_proto_udp_encap(const void *data __rte_unused)
9384 {
9385         struct ipsec_test_flags flags;
9386
9387         memset(&flags, 0, sizeof(flags));
9388
9389         flags.udp_encap = true;
9390
9391         return test_ipsec_proto_all(&flags);
9392 }
9393
9394 static int
9395 test_ipsec_proto_tunnel_src_dst_addr_verify(const void *data __rte_unused)
9396 {
9397         struct ipsec_test_flags flags;
9398
9399         memset(&flags, 0, sizeof(flags));
9400
9401         flags.tunnel_hdr_verify = RTE_SECURITY_IPSEC_TUNNEL_VERIFY_SRC_DST_ADDR;
9402
9403         return test_ipsec_proto_all(&flags);
9404 }
9405
9406 static int
9407 test_ipsec_proto_tunnel_dst_addr_verify(const void *data __rte_unused)
9408 {
9409         struct ipsec_test_flags flags;
9410
9411         memset(&flags, 0, sizeof(flags));
9412
9413         flags.tunnel_hdr_verify = RTE_SECURITY_IPSEC_TUNNEL_VERIFY_DST_ADDR;
9414
9415         return test_ipsec_proto_all(&flags);
9416 }
9417
9418 static int
9419 test_ipsec_proto_udp_ports_verify(const void *data __rte_unused)
9420 {
9421         struct ipsec_test_flags flags;
9422
9423         memset(&flags, 0, sizeof(flags));
9424
9425         flags.udp_encap = true;
9426         flags.udp_ports_verify = true;
9427
9428         return test_ipsec_proto_all(&flags);
9429 }
9430
9431 static int
9432 test_ipsec_proto_inner_ip_csum(const void *data __rte_unused)
9433 {
9434         struct ipsec_test_flags flags;
9435
9436         memset(&flags, 0, sizeof(flags));
9437
9438         flags.ip_csum = true;
9439
9440         return test_ipsec_proto_all(&flags);
9441 }
9442
9443 static int
9444 test_ipsec_proto_inner_l4_csum(const void *data __rte_unused)
9445 {
9446         struct ipsec_test_flags flags;
9447
9448         memset(&flags, 0, sizeof(flags));
9449
9450         flags.l4_csum = true;
9451
9452         return test_ipsec_proto_all(&flags);
9453 }
9454
9455 static int
9456 test_PDCP_PROTO_all(void)
9457 {
9458         struct crypto_testsuite_params *ts_params = &testsuite_params;
9459         struct crypto_unittest_params *ut_params = &unittest_params;
9460         struct rte_cryptodev_info dev_info;
9461         int status;
9462
9463         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
9464         uint64_t feat_flags = dev_info.feature_flags;
9465
9466         if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY))
9467                 return TEST_SKIPPED;
9468
9469         /* Set action type */
9470         ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
9471                 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
9472                 gbl_action_type;
9473
9474         if (security_proto_supported(ut_params->type,
9475                         RTE_SECURITY_PROTOCOL_PDCP) < 0)
9476                 return TEST_SKIPPED;
9477
9478         status = test_PDCP_PROTO_cplane_encap_all();
9479         status += test_PDCP_PROTO_cplane_decap_all();
9480         status += test_PDCP_PROTO_uplane_encap_all();
9481         status += test_PDCP_PROTO_uplane_decap_all();
9482         status += test_PDCP_PROTO_SGL_in_place_32B();
9483         status += test_PDCP_PROTO_SGL_oop_32B_128B();
9484         status += test_PDCP_PROTO_SGL_oop_32B_40B();
9485         status += test_PDCP_PROTO_SGL_oop_128B_32B();
9486         status += test_PDCP_SDAP_PROTO_encap_all();
9487         status += test_PDCP_SDAP_PROTO_decap_all();
9488         status += test_PDCP_PROTO_short_mac();
9489
9490         if (status)
9491                 return TEST_FAILED;
9492         else
9493                 return TEST_SUCCESS;
9494 }
9495
9496 static int
9497 test_docsis_proto_uplink(int i, struct docsis_test_data *d_td)
9498 {
9499         struct crypto_testsuite_params *ts_params = &testsuite_params;
9500         struct crypto_unittest_params *ut_params = &unittest_params;
9501         uint8_t *plaintext, *ciphertext;
9502         uint8_t *iv_ptr;
9503         int32_t cipher_len, crc_len;
9504         uint32_t crc_data_len;
9505         int ret = TEST_SUCCESS;
9506
9507         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
9508                                         rte_cryptodev_get_sec_ctx(
9509                                                 ts_params->valid_devs[0]);
9510
9511         /* Verify the capabilities */
9512         struct rte_security_capability_idx sec_cap_idx;
9513         const struct rte_security_capability *sec_cap;
9514         const struct rte_cryptodev_capabilities *crypto_cap;
9515         const struct rte_cryptodev_symmetric_capability *sym_cap;
9516         int j = 0;
9517
9518         sec_cap_idx.action = ut_params->type;
9519         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
9520         sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_UPLINK;
9521
9522         sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
9523         if (sec_cap == NULL)
9524                 return TEST_SKIPPED;
9525
9526         while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
9527                         RTE_CRYPTO_OP_TYPE_UNDEFINED) {
9528                 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
9529                                 crypto_cap->sym.xform_type ==
9530                                         RTE_CRYPTO_SYM_XFORM_CIPHER &&
9531                                 crypto_cap->sym.cipher.algo ==
9532                                         RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
9533                         sym_cap = &crypto_cap->sym;
9534                         if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
9535                                                 d_td->key.len,
9536                                                 d_td->iv.len) == 0)
9537                                 break;
9538                 }
9539         }
9540
9541         if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
9542                 return TEST_SKIPPED;
9543
9544         /* Setup source mbuf payload */
9545         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9546         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9547                         rte_pktmbuf_tailroom(ut_params->ibuf));
9548
9549         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9550                         d_td->ciphertext.len);
9551
9552         memcpy(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len);
9553
9554         /* Setup cipher session parameters */
9555         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
9556         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
9557         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
9558         ut_params->cipher_xform.cipher.key.data = d_td->key.data;
9559         ut_params->cipher_xform.cipher.key.length = d_td->key.len;
9560         ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
9561         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
9562         ut_params->cipher_xform.next = NULL;
9563
9564         /* Setup DOCSIS session parameters */
9565         ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_UPLINK;
9566
9567         struct rte_security_session_conf sess_conf = {
9568                 .action_type = ut_params->type,
9569                 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
9570                 .docsis = ut_params->docsis_xform,
9571                 .crypto_xform = &ut_params->cipher_xform,
9572         };
9573
9574         /* Create security session */
9575         ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
9576                                         ts_params->session_mpool,
9577                                         ts_params->session_priv_mpool);
9578
9579         if (!ut_params->sec_session) {
9580                 printf("TestCase %s(%d) line %d: %s\n",
9581                         __func__, i, __LINE__, "failed to allocate session");
9582                 ret = TEST_FAILED;
9583                 goto on_err;
9584         }
9585
9586         /* Generate crypto op data structure */
9587         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9588                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9589         if (!ut_params->op) {
9590                 printf("TestCase %s(%d) line %d: %s\n",
9591                         __func__, i, __LINE__,
9592                         "failed to allocate symmetric crypto operation");
9593                 ret = TEST_FAILED;
9594                 goto on_err;
9595         }
9596
9597         /* Setup CRC operation parameters */
9598         crc_len = d_td->ciphertext.no_crc == false ?
9599                         (d_td->ciphertext.len -
9600                                 d_td->ciphertext.crc_offset -
9601                                 RTE_ETHER_CRC_LEN) :
9602                         0;
9603         crc_len = crc_len > 0 ? crc_len : 0;
9604         crc_data_len = crc_len == 0 ? 0 : RTE_ETHER_CRC_LEN;
9605         ut_params->op->sym->auth.data.length = crc_len;
9606         ut_params->op->sym->auth.data.offset = d_td->ciphertext.crc_offset;
9607
9608         /* Setup cipher operation parameters */
9609         cipher_len = d_td->ciphertext.no_cipher == false ?
9610                         (d_td->ciphertext.len -
9611                                 d_td->ciphertext.cipher_offset) :
9612                         0;
9613         cipher_len = cipher_len > 0 ? cipher_len : 0;
9614         ut_params->op->sym->cipher.data.length = cipher_len;
9615         ut_params->op->sym->cipher.data.offset = d_td->ciphertext.cipher_offset;
9616
9617         /* Setup cipher IV */
9618         iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
9619         rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
9620
9621         /* Attach session to operation */
9622         rte_security_attach_session(ut_params->op, ut_params->sec_session);
9623
9624         /* Set crypto operation mbufs */
9625         ut_params->op->sym->m_src = ut_params->ibuf;
9626         ut_params->op->sym->m_dst = NULL;
9627
9628         /* Process crypto operation */
9629         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
9630                         NULL) {
9631                 printf("TestCase %s(%d) line %d: %s\n",
9632                         __func__, i, __LINE__,
9633                         "failed to process security crypto op");
9634                 ret = TEST_FAILED;
9635                 goto on_err;
9636         }
9637
9638         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
9639                 printf("TestCase %s(%d) line %d: %s\n",
9640                         __func__, i, __LINE__, "crypto op processing failed");
9641                 ret = TEST_FAILED;
9642                 goto on_err;
9643         }
9644
9645         /* Validate plaintext */
9646         plaintext = ciphertext;
9647
9648         if (memcmp(plaintext, d_td->plaintext.data,
9649                         d_td->plaintext.len - crc_data_len)) {
9650                 printf("TestCase %s(%d) line %d: %s\n",
9651                         __func__, i, __LINE__, "plaintext not as expected\n");
9652                 rte_hexdump(stdout, "expected", d_td->plaintext.data,
9653                                 d_td->plaintext.len);
9654                 rte_hexdump(stdout, "actual", plaintext, d_td->plaintext.len);
9655                 ret = TEST_FAILED;
9656                 goto on_err;
9657         }
9658
9659 on_err:
9660         rte_crypto_op_free(ut_params->op);
9661         ut_params->op = NULL;
9662
9663         if (ut_params->sec_session)
9664                 rte_security_session_destroy(ctx, ut_params->sec_session);
9665         ut_params->sec_session = NULL;
9666
9667         rte_pktmbuf_free(ut_params->ibuf);
9668         ut_params->ibuf = NULL;
9669
9670         return ret;
9671 }
9672
9673 static int
9674 test_docsis_proto_downlink(int i, struct docsis_test_data *d_td)
9675 {
9676         struct crypto_testsuite_params *ts_params = &testsuite_params;
9677         struct crypto_unittest_params *ut_params = &unittest_params;
9678         uint8_t *plaintext, *ciphertext;
9679         uint8_t *iv_ptr;
9680         int32_t cipher_len, crc_len;
9681         int ret = TEST_SUCCESS;
9682
9683         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
9684                                         rte_cryptodev_get_sec_ctx(
9685                                                 ts_params->valid_devs[0]);
9686
9687         /* Verify the capabilities */
9688         struct rte_security_capability_idx sec_cap_idx;
9689         const struct rte_security_capability *sec_cap;
9690         const struct rte_cryptodev_capabilities *crypto_cap;
9691         const struct rte_cryptodev_symmetric_capability *sym_cap;
9692         int j = 0;
9693
9694         sec_cap_idx.action = ut_params->type;
9695         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
9696         sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
9697
9698         sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
9699         if (sec_cap == NULL)
9700                 return TEST_SKIPPED;
9701
9702         while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
9703                         RTE_CRYPTO_OP_TYPE_UNDEFINED) {
9704                 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
9705                                 crypto_cap->sym.xform_type ==
9706                                         RTE_CRYPTO_SYM_XFORM_CIPHER &&
9707                                 crypto_cap->sym.cipher.algo ==
9708                                         RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
9709                         sym_cap = &crypto_cap->sym;
9710                         if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
9711                                                 d_td->key.len,
9712                                                 d_td->iv.len) == 0)
9713                                 break;
9714                 }
9715         }
9716
9717         if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
9718                 return TEST_SKIPPED;
9719
9720         /* Setup source mbuf payload */
9721         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9722         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9723                         rte_pktmbuf_tailroom(ut_params->ibuf));
9724
9725         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9726                         d_td->plaintext.len);
9727
9728         memcpy(plaintext, d_td->plaintext.data, d_td->plaintext.len);
9729
9730         /* Setup cipher session parameters */
9731         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
9732         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
9733         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
9734         ut_params->cipher_xform.cipher.key.data = d_td->key.data;
9735         ut_params->cipher_xform.cipher.key.length = d_td->key.len;
9736         ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
9737         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
9738         ut_params->cipher_xform.next = NULL;
9739
9740         /* Setup DOCSIS session parameters */
9741         ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
9742
9743         struct rte_security_session_conf sess_conf = {
9744                 .action_type = ut_params->type,
9745                 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
9746                 .docsis = ut_params->docsis_xform,
9747                 .crypto_xform = &ut_params->cipher_xform,
9748         };
9749
9750         /* Create security session */
9751         ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
9752                                         ts_params->session_mpool,
9753                                         ts_params->session_priv_mpool);
9754
9755         if (!ut_params->sec_session) {
9756                 printf("TestCase %s(%d) line %d: %s\n",
9757                         __func__, i, __LINE__, "failed to allocate session");
9758                 ret = TEST_FAILED;
9759                 goto on_err;
9760         }
9761
9762         /* Generate crypto op data structure */
9763         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9764                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9765         if (!ut_params->op) {
9766                 printf("TestCase %s(%d) line %d: %s\n",
9767                         __func__, i, __LINE__,
9768                         "failed to allocate security crypto operation");
9769                 ret = TEST_FAILED;
9770                 goto on_err;
9771         }
9772
9773         /* Setup CRC operation parameters */
9774         crc_len = d_td->plaintext.no_crc == false ?
9775                         (d_td->plaintext.len -
9776                                 d_td->plaintext.crc_offset -
9777                                 RTE_ETHER_CRC_LEN) :
9778                         0;
9779         crc_len = crc_len > 0 ? crc_len : 0;
9780         ut_params->op->sym->auth.data.length = crc_len;
9781         ut_params->op->sym->auth.data.offset = d_td->plaintext.crc_offset;
9782
9783         /* Setup cipher operation parameters */
9784         cipher_len = d_td->plaintext.no_cipher == false ?
9785                         (d_td->plaintext.len -
9786                                 d_td->plaintext.cipher_offset) :
9787                         0;
9788         cipher_len = cipher_len > 0 ? cipher_len : 0;
9789         ut_params->op->sym->cipher.data.length = cipher_len;
9790         ut_params->op->sym->cipher.data.offset = d_td->plaintext.cipher_offset;
9791
9792         /* Setup cipher IV */
9793         iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
9794         rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
9795
9796         /* Attach session to operation */
9797         rte_security_attach_session(ut_params->op, ut_params->sec_session);
9798
9799         /* Set crypto operation mbufs */
9800         ut_params->op->sym->m_src = ut_params->ibuf;
9801         ut_params->op->sym->m_dst = NULL;
9802
9803         /* Process crypto operation */
9804         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
9805                         NULL) {
9806                 printf("TestCase %s(%d) line %d: %s\n",
9807                         __func__, i, __LINE__,
9808                         "failed to process security crypto op");
9809                 ret = TEST_FAILED;
9810                 goto on_err;
9811         }
9812
9813         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
9814                 printf("TestCase %s(%d) line %d: %s\n",
9815                         __func__, i, __LINE__, "crypto op processing failed");
9816                 ret = TEST_FAILED;
9817                 goto on_err;
9818         }
9819
9820         /* Validate ciphertext */
9821         ciphertext = plaintext;
9822
9823         if (memcmp(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len)) {
9824                 printf("TestCase %s(%d) line %d: %s\n",
9825                         __func__, i, __LINE__, "ciphertext not as expected\n");
9826                 rte_hexdump(stdout, "expected", d_td->ciphertext.data,
9827                                 d_td->ciphertext.len);
9828                 rte_hexdump(stdout, "actual", ciphertext, d_td->ciphertext.len);
9829                 ret = TEST_FAILED;
9830                 goto on_err;
9831         }
9832
9833 on_err:
9834         rte_crypto_op_free(ut_params->op);
9835         ut_params->op = NULL;
9836
9837         if (ut_params->sec_session)
9838                 rte_security_session_destroy(ctx, ut_params->sec_session);
9839         ut_params->sec_session = NULL;
9840
9841         rte_pktmbuf_free(ut_params->ibuf);
9842         ut_params->ibuf = NULL;
9843
9844         return ret;
9845 }
9846
9847 #define TEST_DOCSIS_COUNT(func) do {                    \
9848         int ret = func;                                 \
9849         if (ret == TEST_SUCCESS)  {                     \
9850                 printf("\t%2d)", n++);                  \
9851                 printf("+++++ PASSED:" #func"\n");      \
9852                 p++;                                    \
9853         } else if (ret == TEST_SKIPPED) {               \
9854                 printf("\t%2d)", n++);                  \
9855                 printf("~~~~~ SKIPPED:" #func"\n");     \
9856                 s++;                                    \
9857         } else {                                        \
9858                 printf("\t%2d)", n++);                  \
9859                 printf("----- FAILED:" #func"\n");      \
9860                 f++;                                    \
9861         }                                               \
9862 } while (0)
9863
9864 static int
9865 test_DOCSIS_PROTO_uplink_all(void)
9866 {
9867         int p = 0, s = 0, f = 0, n = 0;
9868
9869         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(1, &docsis_test_case_1));
9870         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(2, &docsis_test_case_2));
9871         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(3, &docsis_test_case_3));
9872         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(4, &docsis_test_case_4));
9873         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(5, &docsis_test_case_5));
9874         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(6, &docsis_test_case_6));
9875         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(7, &docsis_test_case_7));
9876         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(8, &docsis_test_case_8));
9877         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(9, &docsis_test_case_9));
9878         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(10, &docsis_test_case_10));
9879         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(11, &docsis_test_case_11));
9880         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(12, &docsis_test_case_12));
9881         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(13, &docsis_test_case_13));
9882         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(14, &docsis_test_case_14));
9883         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(15, &docsis_test_case_15));
9884         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(16, &docsis_test_case_16));
9885         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(17, &docsis_test_case_17));
9886         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(18, &docsis_test_case_18));
9887         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(19, &docsis_test_case_19));
9888         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(20, &docsis_test_case_20));
9889         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(21, &docsis_test_case_21));
9890         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(22, &docsis_test_case_22));
9891         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(23, &docsis_test_case_23));
9892         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(24, &docsis_test_case_24));
9893         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(25, &docsis_test_case_25));
9894         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(26, &docsis_test_case_26));
9895
9896         if (f)
9897                 printf("## %s: %d passed out of %d (%d skipped)\n",
9898                         __func__, p, n, s);
9899
9900         return f;
9901 };
9902
9903 static int
9904 test_DOCSIS_PROTO_downlink_all(void)
9905 {
9906         int p = 0, s = 0, f = 0, n = 0;
9907
9908         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(1, &docsis_test_case_1));
9909         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(2, &docsis_test_case_2));
9910         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(3, &docsis_test_case_3));
9911         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(4, &docsis_test_case_4));
9912         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(5, &docsis_test_case_5));
9913         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(6, &docsis_test_case_6));
9914         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(7, &docsis_test_case_7));
9915         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(8, &docsis_test_case_8));
9916         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(9, &docsis_test_case_9));
9917         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(10, &docsis_test_case_10));
9918         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(11, &docsis_test_case_11));
9919         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(12, &docsis_test_case_12));
9920         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(13, &docsis_test_case_13));
9921         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(14, &docsis_test_case_14));
9922         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(15, &docsis_test_case_15));
9923         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(16, &docsis_test_case_16));
9924         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(17, &docsis_test_case_17));
9925         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(18, &docsis_test_case_18));
9926         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(19, &docsis_test_case_19));
9927         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(20, &docsis_test_case_20));
9928         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(21, &docsis_test_case_21));
9929         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(22, &docsis_test_case_22));
9930         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(23, &docsis_test_case_23));
9931         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(24, &docsis_test_case_24));
9932         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(25, &docsis_test_case_25));
9933         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(26, &docsis_test_case_26));
9934
9935         if (f)
9936                 printf("## %s: %d passed out of %d (%d skipped)\n",
9937                         __func__, p, n, s);
9938
9939         return f;
9940 };
9941
9942 static int
9943 test_DOCSIS_PROTO_all(void)
9944 {
9945         struct crypto_testsuite_params *ts_params = &testsuite_params;
9946         struct crypto_unittest_params *ut_params = &unittest_params;
9947         struct rte_cryptodev_info dev_info;
9948         int status;
9949
9950         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
9951         uint64_t feat_flags = dev_info.feature_flags;
9952
9953         if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY))
9954                 return TEST_SKIPPED;
9955
9956         /* Set action type */
9957         ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
9958                 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
9959                 gbl_action_type;
9960
9961         if (security_proto_supported(ut_params->type,
9962                         RTE_SECURITY_PROTOCOL_DOCSIS) < 0)
9963                 return TEST_SKIPPED;
9964
9965         status = test_DOCSIS_PROTO_uplink_all();
9966         status += test_DOCSIS_PROTO_downlink_all();
9967
9968         if (status)
9969                 return TEST_FAILED;
9970         else
9971                 return TEST_SUCCESS;
9972 }
9973 #endif
9974
9975 static int
9976 test_AES_GCM_authenticated_encryption_test_case_1(void)
9977 {
9978         return test_authenticated_encryption(&gcm_test_case_1);
9979 }
9980
9981 static int
9982 test_AES_GCM_authenticated_encryption_test_case_2(void)
9983 {
9984         return test_authenticated_encryption(&gcm_test_case_2);
9985 }
9986
9987 static int
9988 test_AES_GCM_authenticated_encryption_test_case_3(void)
9989 {
9990         return test_authenticated_encryption(&gcm_test_case_3);
9991 }
9992
9993 static int
9994 test_AES_GCM_authenticated_encryption_test_case_4(void)
9995 {
9996         return test_authenticated_encryption(&gcm_test_case_4);
9997 }
9998
9999 static int
10000 test_AES_GCM_authenticated_encryption_test_case_5(void)
10001 {
10002         return test_authenticated_encryption(&gcm_test_case_5);
10003 }
10004
10005 static int
10006 test_AES_GCM_authenticated_encryption_test_case_6(void)
10007 {
10008         return test_authenticated_encryption(&gcm_test_case_6);
10009 }
10010
10011 static int
10012 test_AES_GCM_authenticated_encryption_test_case_7(void)
10013 {
10014         return test_authenticated_encryption(&gcm_test_case_7);
10015 }
10016
10017 static int
10018 test_AES_GCM_authenticated_encryption_test_case_8(void)
10019 {
10020         return test_authenticated_encryption(&gcm_test_case_8);
10021 }
10022
10023 static int
10024 test_AES_GCM_J0_authenticated_encryption_test_case_1(void)
10025 {
10026         return test_authenticated_encryption(&gcm_J0_test_case_1);
10027 }
10028
10029 static int
10030 test_AES_GCM_auth_encryption_test_case_192_1(void)
10031 {
10032         return test_authenticated_encryption(&gcm_test_case_192_1);
10033 }
10034
10035 static int
10036 test_AES_GCM_auth_encryption_test_case_192_2(void)
10037 {
10038         return test_authenticated_encryption(&gcm_test_case_192_2);
10039 }
10040
10041 static int
10042 test_AES_GCM_auth_encryption_test_case_192_3(void)
10043 {
10044         return test_authenticated_encryption(&gcm_test_case_192_3);
10045 }
10046
10047 static int
10048 test_AES_GCM_auth_encryption_test_case_192_4(void)
10049 {
10050         return test_authenticated_encryption(&gcm_test_case_192_4);
10051 }
10052
10053 static int
10054 test_AES_GCM_auth_encryption_test_case_192_5(void)
10055 {
10056         return test_authenticated_encryption(&gcm_test_case_192_5);
10057 }
10058
10059 static int
10060 test_AES_GCM_auth_encryption_test_case_192_6(void)
10061 {
10062         return test_authenticated_encryption(&gcm_test_case_192_6);
10063 }
10064
10065 static int
10066 test_AES_GCM_auth_encryption_test_case_192_7(void)
10067 {
10068         return test_authenticated_encryption(&gcm_test_case_192_7);
10069 }
10070
10071 static int
10072 test_AES_GCM_auth_encryption_test_case_256_1(void)
10073 {
10074         return test_authenticated_encryption(&gcm_test_case_256_1);
10075 }
10076
10077 static int
10078 test_AES_GCM_auth_encryption_test_case_256_2(void)
10079 {
10080         return test_authenticated_encryption(&gcm_test_case_256_2);
10081 }
10082
10083 static int
10084 test_AES_GCM_auth_encryption_test_case_256_3(void)
10085 {
10086         return test_authenticated_encryption(&gcm_test_case_256_3);
10087 }
10088
10089 static int
10090 test_AES_GCM_auth_encryption_test_case_256_4(void)
10091 {
10092         return test_authenticated_encryption(&gcm_test_case_256_4);
10093 }
10094
10095 static int
10096 test_AES_GCM_auth_encryption_test_case_256_5(void)
10097 {
10098         return test_authenticated_encryption(&gcm_test_case_256_5);
10099 }
10100
10101 static int
10102 test_AES_GCM_auth_encryption_test_case_256_6(void)
10103 {
10104         return test_authenticated_encryption(&gcm_test_case_256_6);
10105 }
10106
10107 static int
10108 test_AES_GCM_auth_encryption_test_case_256_7(void)
10109 {
10110         return test_authenticated_encryption(&gcm_test_case_256_7);
10111 }
10112
10113 static int
10114 test_AES_GCM_auth_encryption_test_case_aad_1(void)
10115 {
10116         return test_authenticated_encryption(&gcm_test_case_aad_1);
10117 }
10118
10119 static int
10120 test_AES_GCM_auth_encryption_test_case_aad_2(void)
10121 {
10122         return test_authenticated_encryption(&gcm_test_case_aad_2);
10123 }
10124
10125 static int
10126 test_AES_GCM_auth_encryption_fail_iv_corrupt(void)
10127 {
10128         struct aead_test_data tdata;
10129         int res;
10130
10131         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10132         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10133         tdata.iv.data[0] += 1;
10134         res = test_authenticated_encryption(&tdata);
10135         if (res == TEST_SKIPPED)
10136                 return res;
10137         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10138         return TEST_SUCCESS;
10139 }
10140
10141 static int
10142 test_AES_GCM_auth_encryption_fail_in_data_corrupt(void)
10143 {
10144         struct aead_test_data tdata;
10145         int res;
10146
10147         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10148         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10149         tdata.plaintext.data[0] += 1;
10150         res = test_authenticated_encryption(&tdata);
10151         if (res == TEST_SKIPPED)
10152                 return res;
10153         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10154         return TEST_SUCCESS;
10155 }
10156
10157 static int
10158 test_AES_GCM_auth_encryption_fail_out_data_corrupt(void)
10159 {
10160         struct aead_test_data tdata;
10161         int res;
10162
10163         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10164         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10165         tdata.ciphertext.data[0] += 1;
10166         res = test_authenticated_encryption(&tdata);
10167         if (res == TEST_SKIPPED)
10168                 return res;
10169         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10170         return TEST_SUCCESS;
10171 }
10172
10173 static int
10174 test_AES_GCM_auth_encryption_fail_aad_len_corrupt(void)
10175 {
10176         struct aead_test_data tdata;
10177         int res;
10178
10179         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10180         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10181         tdata.aad.len += 1;
10182         res = test_authenticated_encryption(&tdata);
10183         if (res == TEST_SKIPPED)
10184                 return res;
10185         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10186         return TEST_SUCCESS;
10187 }
10188
10189 static int
10190 test_AES_GCM_auth_encryption_fail_aad_corrupt(void)
10191 {
10192         struct aead_test_data tdata;
10193         uint8_t aad[gcm_test_case_7.aad.len];
10194         int res;
10195
10196         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10197         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10198         memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
10199         aad[0] += 1;
10200         tdata.aad.data = aad;
10201         res = test_authenticated_encryption(&tdata);
10202         if (res == TEST_SKIPPED)
10203                 return res;
10204         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10205         return TEST_SUCCESS;
10206 }
10207
10208 static int
10209 test_AES_GCM_auth_encryption_fail_tag_corrupt(void)
10210 {
10211         struct aead_test_data tdata;
10212         int res;
10213
10214         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10215         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10216         tdata.auth_tag.data[0] += 1;
10217         res = test_authenticated_encryption(&tdata);
10218         if (res == TEST_SKIPPED)
10219                 return res;
10220         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10221         return TEST_SUCCESS;
10222 }
10223
10224 static int
10225 test_authenticated_decryption(const struct aead_test_data *tdata)
10226 {
10227         struct crypto_testsuite_params *ts_params = &testsuite_params;
10228         struct crypto_unittest_params *ut_params = &unittest_params;
10229
10230         int retval;
10231         uint8_t *plaintext;
10232         uint32_t i;
10233         struct rte_cryptodev_info dev_info;
10234
10235         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10236         uint64_t feat_flags = dev_info.feature_flags;
10237
10238         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10239                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10240                 printf("Device doesn't support RAW data-path APIs.\n");
10241                 return TEST_SKIPPED;
10242         }
10243
10244         /* Verify the capabilities */
10245         struct rte_cryptodev_sym_capability_idx cap_idx;
10246         const struct rte_cryptodev_symmetric_capability *capability;
10247         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10248         cap_idx.algo.aead = tdata->algo;
10249         capability = rte_cryptodev_sym_capability_get(
10250                         ts_params->valid_devs[0], &cap_idx);
10251         if (capability == NULL)
10252                 return TEST_SKIPPED;
10253         if (rte_cryptodev_sym_capability_check_aead(
10254                         capability, tdata->key.len, tdata->auth_tag.len,
10255                         tdata->aad.len, tdata->iv.len))
10256                 return TEST_SKIPPED;
10257
10258         /* Create AEAD session */
10259         retval = create_aead_session(ts_params->valid_devs[0],
10260                         tdata->algo,
10261                         RTE_CRYPTO_AEAD_OP_DECRYPT,
10262                         tdata->key.data, tdata->key.len,
10263                         tdata->aad.len, tdata->auth_tag.len,
10264                         tdata->iv.len);
10265         if (retval < 0)
10266                 return retval;
10267
10268         /* alloc mbuf and set payload */
10269         if (tdata->aad.len > MBUF_SIZE) {
10270                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
10271                 /* Populate full size of add data */
10272                 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
10273                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
10274         } else
10275                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10276
10277         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10278                         rte_pktmbuf_tailroom(ut_params->ibuf));
10279
10280         /* Create AEAD operation */
10281         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
10282         if (retval < 0)
10283                 return retval;
10284
10285         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10286
10287         ut_params->op->sym->m_src = ut_params->ibuf;
10288
10289         /* Process crypto operation */
10290         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10291                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
10292         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10293                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10294                                 ut_params->op, 0, 0, 0, 0);
10295         else
10296                 TEST_ASSERT_NOT_NULL(
10297                         process_crypto_request(ts_params->valid_devs[0],
10298                         ut_params->op), "failed to process sym crypto op");
10299
10300         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10301                         "crypto op processing failed");
10302
10303         if (ut_params->op->sym->m_dst)
10304                 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
10305                                 uint8_t *);
10306         else
10307                 plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
10308                                 uint8_t *,
10309                                 ut_params->op->sym->cipher.data.offset);
10310
10311         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
10312
10313         /* Validate obuf */
10314         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10315                         plaintext,
10316                         tdata->plaintext.data,
10317                         tdata->plaintext.len,
10318                         "Plaintext data not as expected");
10319
10320         TEST_ASSERT_EQUAL(ut_params->op->status,
10321                         RTE_CRYPTO_OP_STATUS_SUCCESS,
10322                         "Authentication failed");
10323
10324         return 0;
10325 }
10326
10327 static int
10328 test_AES_GCM_authenticated_decryption_test_case_1(void)
10329 {
10330         return test_authenticated_decryption(&gcm_test_case_1);
10331 }
10332
10333 static int
10334 test_AES_GCM_authenticated_decryption_test_case_2(void)
10335 {
10336         return test_authenticated_decryption(&gcm_test_case_2);
10337 }
10338
10339 static int
10340 test_AES_GCM_authenticated_decryption_test_case_3(void)
10341 {
10342         return test_authenticated_decryption(&gcm_test_case_3);
10343 }
10344
10345 static int
10346 test_AES_GCM_authenticated_decryption_test_case_4(void)
10347 {
10348         return test_authenticated_decryption(&gcm_test_case_4);
10349 }
10350
10351 static int
10352 test_AES_GCM_authenticated_decryption_test_case_5(void)
10353 {
10354         return test_authenticated_decryption(&gcm_test_case_5);
10355 }
10356
10357 static int
10358 test_AES_GCM_authenticated_decryption_test_case_6(void)
10359 {
10360         return test_authenticated_decryption(&gcm_test_case_6);
10361 }
10362
10363 static int
10364 test_AES_GCM_authenticated_decryption_test_case_7(void)
10365 {
10366         return test_authenticated_decryption(&gcm_test_case_7);
10367 }
10368
10369 static int
10370 test_AES_GCM_authenticated_decryption_test_case_8(void)
10371 {
10372         return test_authenticated_decryption(&gcm_test_case_8);
10373 }
10374
10375 static int
10376 test_AES_GCM_J0_authenticated_decryption_test_case_1(void)
10377 {
10378         return test_authenticated_decryption(&gcm_J0_test_case_1);
10379 }
10380
10381 static int
10382 test_AES_GCM_auth_decryption_test_case_192_1(void)
10383 {
10384         return test_authenticated_decryption(&gcm_test_case_192_1);
10385 }
10386
10387 static int
10388 test_AES_GCM_auth_decryption_test_case_192_2(void)
10389 {
10390         return test_authenticated_decryption(&gcm_test_case_192_2);
10391 }
10392
10393 static int
10394 test_AES_GCM_auth_decryption_test_case_192_3(void)
10395 {
10396         return test_authenticated_decryption(&gcm_test_case_192_3);
10397 }
10398
10399 static int
10400 test_AES_GCM_auth_decryption_test_case_192_4(void)
10401 {
10402         return test_authenticated_decryption(&gcm_test_case_192_4);
10403 }
10404
10405 static int
10406 test_AES_GCM_auth_decryption_test_case_192_5(void)
10407 {
10408         return test_authenticated_decryption(&gcm_test_case_192_5);
10409 }
10410
10411 static int
10412 test_AES_GCM_auth_decryption_test_case_192_6(void)
10413 {
10414         return test_authenticated_decryption(&gcm_test_case_192_6);
10415 }
10416
10417 static int
10418 test_AES_GCM_auth_decryption_test_case_192_7(void)
10419 {
10420         return test_authenticated_decryption(&gcm_test_case_192_7);
10421 }
10422
10423 static int
10424 test_AES_GCM_auth_decryption_test_case_256_1(void)
10425 {
10426         return test_authenticated_decryption(&gcm_test_case_256_1);
10427 }
10428
10429 static int
10430 test_AES_GCM_auth_decryption_test_case_256_2(void)
10431 {
10432         return test_authenticated_decryption(&gcm_test_case_256_2);
10433 }
10434
10435 static int
10436 test_AES_GCM_auth_decryption_test_case_256_3(void)
10437 {
10438         return test_authenticated_decryption(&gcm_test_case_256_3);
10439 }
10440
10441 static int
10442 test_AES_GCM_auth_decryption_test_case_256_4(void)
10443 {
10444         return test_authenticated_decryption(&gcm_test_case_256_4);
10445 }
10446
10447 static int
10448 test_AES_GCM_auth_decryption_test_case_256_5(void)
10449 {
10450         return test_authenticated_decryption(&gcm_test_case_256_5);
10451 }
10452
10453 static int
10454 test_AES_GCM_auth_decryption_test_case_256_6(void)
10455 {
10456         return test_authenticated_decryption(&gcm_test_case_256_6);
10457 }
10458
10459 static int
10460 test_AES_GCM_auth_decryption_test_case_256_7(void)
10461 {
10462         return test_authenticated_decryption(&gcm_test_case_256_7);
10463 }
10464
10465 static int
10466 test_AES_GCM_auth_decryption_test_case_aad_1(void)
10467 {
10468         return test_authenticated_decryption(&gcm_test_case_aad_1);
10469 }
10470
10471 static int
10472 test_AES_GCM_auth_decryption_test_case_aad_2(void)
10473 {
10474         return test_authenticated_decryption(&gcm_test_case_aad_2);
10475 }
10476
10477 static int
10478 test_AES_GCM_auth_decryption_fail_iv_corrupt(void)
10479 {
10480         struct aead_test_data tdata;
10481         int res;
10482
10483         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10484         tdata.iv.data[0] += 1;
10485         res = test_authenticated_decryption(&tdata);
10486         if (res == TEST_SKIPPED)
10487                 return res;
10488         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10489         return TEST_SUCCESS;
10490 }
10491
10492 static int
10493 test_AES_GCM_auth_decryption_fail_in_data_corrupt(void)
10494 {
10495         struct aead_test_data tdata;
10496         int res;
10497
10498         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10499         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10500         tdata.plaintext.data[0] += 1;
10501         res = test_authenticated_decryption(&tdata);
10502         if (res == TEST_SKIPPED)
10503                 return res;
10504         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10505         return TEST_SUCCESS;
10506 }
10507
10508 static int
10509 test_AES_GCM_auth_decryption_fail_out_data_corrupt(void)
10510 {
10511         struct aead_test_data tdata;
10512         int res;
10513
10514         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10515         tdata.ciphertext.data[0] += 1;
10516         res = test_authenticated_decryption(&tdata);
10517         if (res == TEST_SKIPPED)
10518                 return res;
10519         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10520         return TEST_SUCCESS;
10521 }
10522
10523 static int
10524 test_AES_GCM_auth_decryption_fail_aad_len_corrupt(void)
10525 {
10526         struct aead_test_data tdata;
10527         int res;
10528
10529         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10530         tdata.aad.len += 1;
10531         res = test_authenticated_decryption(&tdata);
10532         if (res == TEST_SKIPPED)
10533                 return res;
10534         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10535         return TEST_SUCCESS;
10536 }
10537
10538 static int
10539 test_AES_GCM_auth_decryption_fail_aad_corrupt(void)
10540 {
10541         struct aead_test_data tdata;
10542         uint8_t aad[gcm_test_case_7.aad.len];
10543         int res;
10544
10545         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10546         memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
10547         aad[0] += 1;
10548         tdata.aad.data = aad;
10549         res = test_authenticated_decryption(&tdata);
10550         if (res == TEST_SKIPPED)
10551                 return res;
10552         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10553         return TEST_SUCCESS;
10554 }
10555
10556 static int
10557 test_AES_GCM_auth_decryption_fail_tag_corrupt(void)
10558 {
10559         struct aead_test_data tdata;
10560         int res;
10561
10562         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10563         tdata.auth_tag.data[0] += 1;
10564         res = test_authenticated_decryption(&tdata);
10565         if (res == TEST_SKIPPED)
10566                 return res;
10567         TEST_ASSERT_EQUAL(res, TEST_FAILED, "authentication not failed");
10568         return TEST_SUCCESS;
10569 }
10570
10571 static int
10572 test_authenticated_encryption_oop(const struct aead_test_data *tdata)
10573 {
10574         struct crypto_testsuite_params *ts_params = &testsuite_params;
10575         struct crypto_unittest_params *ut_params = &unittest_params;
10576
10577         int retval;
10578         uint8_t *ciphertext, *auth_tag;
10579         uint16_t plaintext_pad_len;
10580         struct rte_cryptodev_info dev_info;
10581
10582         /* Verify the capabilities */
10583         struct rte_cryptodev_sym_capability_idx cap_idx;
10584         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10585         cap_idx.algo.aead = tdata->algo;
10586         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10587                         &cap_idx) == NULL)
10588                 return TEST_SKIPPED;
10589
10590         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10591         uint64_t feat_flags = dev_info.feature_flags;
10592
10593         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10594                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP)))
10595                 return TEST_SKIPPED;
10596
10597         /* not supported with CPU crypto */
10598         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10599                 return TEST_SKIPPED;
10600
10601         /* Create AEAD session */
10602         retval = create_aead_session(ts_params->valid_devs[0],
10603                         tdata->algo,
10604                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
10605                         tdata->key.data, tdata->key.len,
10606                         tdata->aad.len, tdata->auth_tag.len,
10607                         tdata->iv.len);
10608         if (retval < 0)
10609                 return retval;
10610
10611         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10612         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10613
10614         /* clear mbuf payload */
10615         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10616                         rte_pktmbuf_tailroom(ut_params->ibuf));
10617         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
10618                         rte_pktmbuf_tailroom(ut_params->obuf));
10619
10620         /* Create AEAD operation */
10621         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
10622         if (retval < 0)
10623                 return retval;
10624
10625         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10626
10627         ut_params->op->sym->m_src = ut_params->ibuf;
10628         ut_params->op->sym->m_dst = ut_params->obuf;
10629
10630         /* Process crypto operation */
10631         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10632                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10633                         ut_params->op, 0, 0, 0, 0);
10634         else
10635                 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
10636                         ut_params->op), "failed to process sym crypto op");
10637
10638         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10639                         "crypto op processing failed");
10640
10641         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
10642
10643         ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
10644                         ut_params->op->sym->cipher.data.offset);
10645         auth_tag = ciphertext + plaintext_pad_len;
10646
10647         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
10648         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
10649
10650         /* Validate obuf */
10651         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10652                         ciphertext,
10653                         tdata->ciphertext.data,
10654                         tdata->ciphertext.len,
10655                         "Ciphertext data not as expected");
10656
10657         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10658                         auth_tag,
10659                         tdata->auth_tag.data,
10660                         tdata->auth_tag.len,
10661                         "Generated auth tag not as expected");
10662
10663         return 0;
10664
10665 }
10666
10667 static int
10668 test_AES_GCM_authenticated_encryption_oop_test_case_1(void)
10669 {
10670         return test_authenticated_encryption_oop(&gcm_test_case_5);
10671 }
10672
10673 static int
10674 test_authenticated_decryption_oop(const struct aead_test_data *tdata)
10675 {
10676         struct crypto_testsuite_params *ts_params = &testsuite_params;
10677         struct crypto_unittest_params *ut_params = &unittest_params;
10678
10679         int retval;
10680         uint8_t *plaintext;
10681         struct rte_cryptodev_info dev_info;
10682
10683         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10684         uint64_t feat_flags = dev_info.feature_flags;
10685
10686         /* Verify the capabilities */
10687         struct rte_cryptodev_sym_capability_idx cap_idx;
10688         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10689         cap_idx.algo.aead = tdata->algo;
10690         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10691                         &cap_idx) == NULL)
10692                 return TEST_SKIPPED;
10693
10694         /* not supported with CPU crypto and raw data-path APIs*/
10695         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO ||
10696                         global_api_test_type == CRYPTODEV_RAW_API_TEST)
10697                 return TEST_SKIPPED;
10698
10699         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10700                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10701                 printf("Device does not support RAW data-path APIs.\n");
10702                 return TEST_SKIPPED;
10703         }
10704
10705         /* Create AEAD session */
10706         retval = create_aead_session(ts_params->valid_devs[0],
10707                         tdata->algo,
10708                         RTE_CRYPTO_AEAD_OP_DECRYPT,
10709                         tdata->key.data, tdata->key.len,
10710                         tdata->aad.len, tdata->auth_tag.len,
10711                         tdata->iv.len);
10712         if (retval < 0)
10713                 return retval;
10714
10715         /* alloc mbuf and set payload */
10716         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10717         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10718
10719         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10720                         rte_pktmbuf_tailroom(ut_params->ibuf));
10721         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
10722                         rte_pktmbuf_tailroom(ut_params->obuf));
10723
10724         /* Create AEAD operation */
10725         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
10726         if (retval < 0)
10727                 return retval;
10728
10729         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10730
10731         ut_params->op->sym->m_src = ut_params->ibuf;
10732         ut_params->op->sym->m_dst = ut_params->obuf;
10733
10734         /* Process crypto operation */
10735         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10736                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10737                                 ut_params->op, 0, 0, 0, 0);
10738         else
10739                 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
10740                         ut_params->op), "failed to process sym crypto op");
10741
10742         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10743                         "crypto op processing failed");
10744
10745         plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
10746                         ut_params->op->sym->cipher.data.offset);
10747
10748         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
10749
10750         /* Validate obuf */
10751         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10752                         plaintext,
10753                         tdata->plaintext.data,
10754                         tdata->plaintext.len,
10755                         "Plaintext data not as expected");
10756
10757         TEST_ASSERT_EQUAL(ut_params->op->status,
10758                         RTE_CRYPTO_OP_STATUS_SUCCESS,
10759                         "Authentication failed");
10760         return 0;
10761 }
10762
10763 static int
10764 test_AES_GCM_authenticated_decryption_oop_test_case_1(void)
10765 {
10766         return test_authenticated_decryption_oop(&gcm_test_case_5);
10767 }
10768
10769 static int
10770 test_authenticated_encryption_sessionless(
10771                 const struct aead_test_data *tdata)
10772 {
10773         struct crypto_testsuite_params *ts_params = &testsuite_params;
10774         struct crypto_unittest_params *ut_params = &unittest_params;
10775
10776         int retval;
10777         uint8_t *ciphertext, *auth_tag;
10778         uint16_t plaintext_pad_len;
10779         uint8_t key[tdata->key.len + 1];
10780         struct rte_cryptodev_info dev_info;
10781
10782         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10783         uint64_t feat_flags = dev_info.feature_flags;
10784
10785         if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
10786                 printf("Device doesn't support Sessionless ops.\n");
10787                 return TEST_SKIPPED;
10788         }
10789
10790         /* not supported with CPU crypto */
10791         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10792                 return TEST_SKIPPED;
10793
10794         /* Verify the capabilities */
10795         struct rte_cryptodev_sym_capability_idx cap_idx;
10796         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10797         cap_idx.algo.aead = tdata->algo;
10798         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10799                         &cap_idx) == NULL)
10800                 return TEST_SKIPPED;
10801
10802         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10803
10804         /* clear mbuf payload */
10805         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10806                         rte_pktmbuf_tailroom(ut_params->ibuf));
10807
10808         /* Create AEAD operation */
10809         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
10810         if (retval < 0)
10811                 return retval;
10812
10813         /* Create GCM xform */
10814         memcpy(key, tdata->key.data, tdata->key.len);
10815         retval = create_aead_xform(ut_params->op,
10816                         tdata->algo,
10817                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
10818                         key, tdata->key.len,
10819                         tdata->aad.len, tdata->auth_tag.len,
10820                         tdata->iv.len);
10821         if (retval < 0)
10822                 return retval;
10823
10824         ut_params->op->sym->m_src = ut_params->ibuf;
10825
10826         TEST_ASSERT_EQUAL(ut_params->op->sess_type,
10827                         RTE_CRYPTO_OP_SESSIONLESS,
10828                         "crypto op session type not sessionless");
10829
10830         /* Process crypto operation */
10831         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
10832                         ut_params->op), "failed to process sym crypto op");
10833
10834         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
10835
10836         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10837                         "crypto op status not success");
10838
10839         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
10840
10841         ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
10842                         ut_params->op->sym->cipher.data.offset);
10843         auth_tag = ciphertext + plaintext_pad_len;
10844
10845         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
10846         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
10847
10848         /* Validate obuf */
10849         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10850                         ciphertext,
10851                         tdata->ciphertext.data,
10852                         tdata->ciphertext.len,
10853                         "Ciphertext data not as expected");
10854
10855         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10856                         auth_tag,
10857                         tdata->auth_tag.data,
10858                         tdata->auth_tag.len,
10859                         "Generated auth tag not as expected");
10860
10861         return 0;
10862
10863 }
10864
10865 static int
10866 test_AES_GCM_authenticated_encryption_sessionless_test_case_1(void)
10867 {
10868         return test_authenticated_encryption_sessionless(
10869                         &gcm_test_case_5);
10870 }
10871
10872 static int
10873 test_authenticated_decryption_sessionless(
10874                 const struct aead_test_data *tdata)
10875 {
10876         struct crypto_testsuite_params *ts_params = &testsuite_params;
10877         struct crypto_unittest_params *ut_params = &unittest_params;
10878
10879         int retval;
10880         uint8_t *plaintext;
10881         uint8_t key[tdata->key.len + 1];
10882         struct rte_cryptodev_info dev_info;
10883
10884         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10885         uint64_t feat_flags = dev_info.feature_flags;
10886
10887         if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
10888                 printf("Device doesn't support Sessionless ops.\n");
10889                 return TEST_SKIPPED;
10890         }
10891
10892         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10893                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10894                 printf("Device doesn't support RAW data-path APIs.\n");
10895                 return TEST_SKIPPED;
10896         }
10897
10898         /* not supported with CPU crypto */
10899         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10900                 return TEST_SKIPPED;
10901
10902         /* Verify the capabilities */
10903         struct rte_cryptodev_sym_capability_idx cap_idx;
10904         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10905         cap_idx.algo.aead = tdata->algo;
10906         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10907                         &cap_idx) == NULL)
10908                 return TEST_SKIPPED;
10909
10910         /* alloc mbuf and set payload */
10911         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10912
10913         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10914                         rte_pktmbuf_tailroom(ut_params->ibuf));
10915
10916         /* Create AEAD operation */
10917         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
10918         if (retval < 0)
10919                 return retval;
10920
10921         /* Create AEAD xform */
10922         memcpy(key, tdata->key.data, tdata->key.len);
10923         retval = create_aead_xform(ut_params->op,
10924                         tdata->algo,
10925                         RTE_CRYPTO_AEAD_OP_DECRYPT,
10926                         key, tdata->key.len,
10927                         tdata->aad.len, tdata->auth_tag.len,
10928                         tdata->iv.len);
10929         if (retval < 0)
10930                 return retval;
10931
10932         ut_params->op->sym->m_src = ut_params->ibuf;
10933
10934         TEST_ASSERT_EQUAL(ut_params->op->sess_type,
10935                         RTE_CRYPTO_OP_SESSIONLESS,
10936                         "crypto op session type not sessionless");
10937
10938         /* Process crypto operation */
10939         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10940                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10941                                 ut_params->op, 0, 0, 0, 0);
10942         else
10943                 TEST_ASSERT_NOT_NULL(process_crypto_request(
10944                         ts_params->valid_devs[0], ut_params->op),
10945                                 "failed to process sym crypto op");
10946
10947         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
10948
10949         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10950                         "crypto op status not success");
10951
10952         plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
10953                         ut_params->op->sym->cipher.data.offset);
10954
10955         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
10956
10957         /* Validate obuf */
10958         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10959                         plaintext,
10960                         tdata->plaintext.data,
10961                         tdata->plaintext.len,
10962                         "Plaintext data not as expected");
10963
10964         TEST_ASSERT_EQUAL(ut_params->op->status,
10965                         RTE_CRYPTO_OP_STATUS_SUCCESS,
10966                         "Authentication failed");
10967         return 0;
10968 }
10969
10970 static int
10971 test_AES_GCM_authenticated_decryption_sessionless_test_case_1(void)
10972 {
10973         return test_authenticated_decryption_sessionless(
10974                         &gcm_test_case_5);
10975 }
10976
10977 static int
10978 test_AES_CCM_authenticated_encryption_test_case_128_1(void)
10979 {
10980         return test_authenticated_encryption(&ccm_test_case_128_1);
10981 }
10982
10983 static int
10984 test_AES_CCM_authenticated_encryption_test_case_128_2(void)
10985 {
10986         return test_authenticated_encryption(&ccm_test_case_128_2);
10987 }
10988
10989 static int
10990 test_AES_CCM_authenticated_encryption_test_case_128_3(void)
10991 {
10992         return test_authenticated_encryption(&ccm_test_case_128_3);
10993 }
10994
10995 static int
10996 test_AES_CCM_authenticated_decryption_test_case_128_1(void)
10997 {
10998         return test_authenticated_decryption(&ccm_test_case_128_1);
10999 }
11000
11001 static int
11002 test_AES_CCM_authenticated_decryption_test_case_128_2(void)
11003 {
11004         return test_authenticated_decryption(&ccm_test_case_128_2);
11005 }
11006
11007 static int
11008 test_AES_CCM_authenticated_decryption_test_case_128_3(void)
11009 {
11010         return test_authenticated_decryption(&ccm_test_case_128_3);
11011 }
11012
11013 static int
11014 test_AES_CCM_authenticated_encryption_test_case_192_1(void)
11015 {
11016         return test_authenticated_encryption(&ccm_test_case_192_1);
11017 }
11018
11019 static int
11020 test_AES_CCM_authenticated_encryption_test_case_192_2(void)
11021 {
11022         return test_authenticated_encryption(&ccm_test_case_192_2);
11023 }
11024
11025 static int
11026 test_AES_CCM_authenticated_encryption_test_case_192_3(void)
11027 {
11028         return test_authenticated_encryption(&ccm_test_case_192_3);
11029 }
11030
11031 static int
11032 test_AES_CCM_authenticated_decryption_test_case_192_1(void)
11033 {
11034         return test_authenticated_decryption(&ccm_test_case_192_1);
11035 }
11036
11037 static int
11038 test_AES_CCM_authenticated_decryption_test_case_192_2(void)
11039 {
11040         return test_authenticated_decryption(&ccm_test_case_192_2);
11041 }
11042
11043 static int
11044 test_AES_CCM_authenticated_decryption_test_case_192_3(void)
11045 {
11046         return test_authenticated_decryption(&ccm_test_case_192_3);
11047 }
11048
11049 static int
11050 test_AES_CCM_authenticated_encryption_test_case_256_1(void)
11051 {
11052         return test_authenticated_encryption(&ccm_test_case_256_1);
11053 }
11054
11055 static int
11056 test_AES_CCM_authenticated_encryption_test_case_256_2(void)
11057 {
11058         return test_authenticated_encryption(&ccm_test_case_256_2);
11059 }
11060
11061 static int
11062 test_AES_CCM_authenticated_encryption_test_case_256_3(void)
11063 {
11064         return test_authenticated_encryption(&ccm_test_case_256_3);
11065 }
11066
11067 static int
11068 test_AES_CCM_authenticated_decryption_test_case_256_1(void)
11069 {
11070         return test_authenticated_decryption(&ccm_test_case_256_1);
11071 }
11072
11073 static int
11074 test_AES_CCM_authenticated_decryption_test_case_256_2(void)
11075 {
11076         return test_authenticated_decryption(&ccm_test_case_256_2);
11077 }
11078
11079 static int
11080 test_AES_CCM_authenticated_decryption_test_case_256_3(void)
11081 {
11082         return test_authenticated_decryption(&ccm_test_case_256_3);
11083 }
11084
11085 static int
11086 test_stats(void)
11087 {
11088         struct crypto_testsuite_params *ts_params = &testsuite_params;
11089         struct rte_cryptodev_stats stats;
11090
11091         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11092                 return TEST_SKIPPED;
11093
11094         /* Verify the capabilities */
11095         struct rte_cryptodev_sym_capability_idx cap_idx;
11096         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11097         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
11098         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11099                         &cap_idx) == NULL)
11100                 return TEST_SKIPPED;
11101         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11102         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
11103         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11104                         &cap_idx) == NULL)
11105                 return TEST_SKIPPED;
11106
11107         if (rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
11108                         == -ENOTSUP)
11109                 return TEST_SKIPPED;
11110
11111         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
11112         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
11113                         &stats) == -ENODEV),
11114                 "rte_cryptodev_stats_get invalid dev failed");
11115         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
11116                 "rte_cryptodev_stats_get invalid Param failed");
11117
11118         /* Test expected values */
11119         test_AES_CBC_HMAC_SHA1_encrypt_digest();
11120         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
11121                         &stats),
11122                 "rte_cryptodev_stats_get failed");
11123         TEST_ASSERT((stats.enqueued_count == 1),
11124                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11125         TEST_ASSERT((stats.dequeued_count == 1),
11126                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11127         TEST_ASSERT((stats.enqueue_err_count == 0),
11128                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11129         TEST_ASSERT((stats.dequeue_err_count == 0),
11130                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11131
11132         /* invalid device but should ignore and not reset device stats*/
11133         rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
11134         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
11135                         &stats),
11136                 "rte_cryptodev_stats_get failed");
11137         TEST_ASSERT((stats.enqueued_count == 1),
11138                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11139
11140         /* check that a valid reset clears stats */
11141         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
11142         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
11143                         &stats),
11144                                           "rte_cryptodev_stats_get failed");
11145         TEST_ASSERT((stats.enqueued_count == 0),
11146                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11147         TEST_ASSERT((stats.dequeued_count == 0),
11148                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11149
11150         return TEST_SUCCESS;
11151 }
11152
11153 static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
11154                                    struct crypto_unittest_params *ut_params,
11155                                    enum rte_crypto_auth_operation op,
11156                                    const struct HMAC_MD5_vector *test_case)
11157 {
11158         uint8_t key[64];
11159
11160         memcpy(key, test_case->key.data, test_case->key.len);
11161
11162         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11163         ut_params->auth_xform.next = NULL;
11164         ut_params->auth_xform.auth.op = op;
11165
11166         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC;
11167
11168         ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN;
11169         ut_params->auth_xform.auth.key.length = test_case->key.len;
11170         ut_params->auth_xform.auth.key.data = key;
11171
11172         ut_params->sess = rte_cryptodev_sym_session_create(
11173                         ts_params->session_mpool);
11174
11175         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11176                         ut_params->sess, &ut_params->auth_xform,
11177                         ts_params->session_priv_mpool);
11178
11179         if (ut_params->sess == NULL)
11180                 return TEST_FAILED;
11181
11182         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11183
11184         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11185                         rte_pktmbuf_tailroom(ut_params->ibuf));
11186
11187         return 0;
11188 }
11189
11190 static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
11191                               const struct HMAC_MD5_vector *test_case,
11192                               uint8_t **plaintext)
11193 {
11194         uint16_t plaintext_pad_len;
11195
11196         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
11197
11198         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
11199                                 16);
11200
11201         *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11202                         plaintext_pad_len);
11203         memcpy(*plaintext, test_case->plaintext.data,
11204                         test_case->plaintext.len);
11205
11206         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
11207                         ut_params->ibuf, MD5_DIGEST_LEN);
11208         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
11209                         "no room to append digest");
11210         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
11211                         ut_params->ibuf, plaintext_pad_len);
11212
11213         if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
11214                 rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data,
11215                            test_case->auth_tag.len);
11216         }
11217
11218         sym_op->auth.data.offset = 0;
11219         sym_op->auth.data.length = test_case->plaintext.len;
11220
11221         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11222         ut_params->op->sym->m_src = ut_params->ibuf;
11223
11224         return 0;
11225 }
11226
11227 static int
11228 test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
11229 {
11230         uint16_t plaintext_pad_len;
11231         uint8_t *plaintext, *auth_tag;
11232
11233         struct crypto_testsuite_params *ts_params = &testsuite_params;
11234         struct crypto_unittest_params *ut_params = &unittest_params;
11235         struct rte_cryptodev_info dev_info;
11236
11237         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11238         uint64_t feat_flags = dev_info.feature_flags;
11239
11240         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11241                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11242                 printf("Device doesn't support RAW data-path APIs.\n");
11243                 return TEST_SKIPPED;
11244         }
11245
11246         /* Verify the capabilities */
11247         struct rte_cryptodev_sym_capability_idx cap_idx;
11248         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11249         cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
11250         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11251                         &cap_idx) == NULL)
11252                 return TEST_SKIPPED;
11253
11254         if (MD5_HMAC_create_session(ts_params, ut_params,
11255                         RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
11256                 return TEST_FAILED;
11257
11258         /* Generate Crypto op data structure */
11259         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11260                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11261         TEST_ASSERT_NOT_NULL(ut_params->op,
11262                         "Failed to allocate symmetric crypto operation struct");
11263
11264         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
11265                                 16);
11266
11267         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
11268                 return TEST_FAILED;
11269
11270         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11271                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11272                         ut_params->op);
11273         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11274                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11275                                 ut_params->op, 0, 1, 0, 0);
11276         else
11277                 TEST_ASSERT_NOT_NULL(
11278                         process_crypto_request(ts_params->valid_devs[0],
11279                                 ut_params->op),
11280                                 "failed to process sym crypto op");
11281
11282         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11283                         "crypto op processing failed");
11284
11285         if (ut_params->op->sym->m_dst) {
11286                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
11287                                 uint8_t *, plaintext_pad_len);
11288         } else {
11289                 auth_tag = plaintext + plaintext_pad_len;
11290         }
11291
11292         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11293                         auth_tag,
11294                         test_case->auth_tag.data,
11295                         test_case->auth_tag.len,
11296                         "HMAC_MD5 generated tag not as expected");
11297
11298         return TEST_SUCCESS;
11299 }
11300
11301 static int
11302 test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
11303 {
11304         uint8_t *plaintext;
11305
11306         struct crypto_testsuite_params *ts_params = &testsuite_params;
11307         struct crypto_unittest_params *ut_params = &unittest_params;
11308         struct rte_cryptodev_info dev_info;
11309
11310         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11311         uint64_t feat_flags = dev_info.feature_flags;
11312
11313         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11314                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11315                 printf("Device doesn't support RAW data-path APIs.\n");
11316                 return TEST_SKIPPED;
11317         }
11318
11319         /* Verify the capabilities */
11320         struct rte_cryptodev_sym_capability_idx cap_idx;
11321         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11322         cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
11323         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11324                         &cap_idx) == NULL)
11325                 return TEST_SKIPPED;
11326
11327         if (MD5_HMAC_create_session(ts_params, ut_params,
11328                         RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
11329                 return TEST_FAILED;
11330         }
11331
11332         /* Generate Crypto op data structure */
11333         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11334                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11335         TEST_ASSERT_NOT_NULL(ut_params->op,
11336                         "Failed to allocate symmetric crypto operation struct");
11337
11338         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
11339                 return TEST_FAILED;
11340
11341         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11342                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11343                         ut_params->op);
11344         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11345                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11346                                 ut_params->op, 0, 1, 0, 0);
11347         else
11348                 TEST_ASSERT_NOT_NULL(
11349                         process_crypto_request(ts_params->valid_devs[0],
11350                                 ut_params->op),
11351                                 "failed to process sym crypto op");
11352
11353         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11354                         "HMAC_MD5 crypto op processing failed");
11355
11356         return TEST_SUCCESS;
11357 }
11358
11359 static int
11360 test_MD5_HMAC_generate_case_1(void)
11361 {
11362         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1);
11363 }
11364
11365 static int
11366 test_MD5_HMAC_verify_case_1(void)
11367 {
11368         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1);
11369 }
11370
11371 static int
11372 test_MD5_HMAC_generate_case_2(void)
11373 {
11374         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2);
11375 }
11376
11377 static int
11378 test_MD5_HMAC_verify_case_2(void)
11379 {
11380         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2);
11381 }
11382
11383 static int
11384 test_multi_session(void)
11385 {
11386         struct crypto_testsuite_params *ts_params = &testsuite_params;
11387         struct crypto_unittest_params *ut_params = &unittest_params;
11388
11389         struct rte_cryptodev_info dev_info;
11390         struct rte_cryptodev_sym_session **sessions;
11391
11392         uint16_t i;
11393
11394         /* Verify the capabilities */
11395         struct rte_cryptodev_sym_capability_idx cap_idx;
11396         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11397         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
11398         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11399                         &cap_idx) == NULL)
11400                 return TEST_SKIPPED;
11401         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11402         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
11403         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11404                         &cap_idx) == NULL)
11405                 return TEST_SKIPPED;
11406
11407         test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
11408                         aes_cbc_key, hmac_sha512_key);
11409
11410
11411         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11412
11413         sessions = rte_malloc(NULL,
11414                         sizeof(struct rte_cryptodev_sym_session *) *
11415                         (MAX_NB_SESSIONS + 1), 0);
11416
11417         /* Create multiple crypto sessions*/
11418         for (i = 0; i < MAX_NB_SESSIONS; i++) {
11419
11420                 sessions[i] = rte_cryptodev_sym_session_create(
11421                                 ts_params->session_mpool);
11422
11423                 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11424                                 sessions[i], &ut_params->auth_xform,
11425                                 ts_params->session_priv_mpool);
11426                 TEST_ASSERT_NOT_NULL(sessions[i],
11427                                 "Session creation failed at session number %u",
11428                                 i);
11429
11430                 /* Attempt to send a request on each session */
11431                 TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform(
11432                         sessions[i],
11433                         ut_params,
11434                         ts_params,
11435                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
11436                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
11437                         aes_cbc_iv),
11438                         "Failed to perform decrypt on request number %u.", i);
11439                 /* free crypto operation structure */
11440                 if (ut_params->op)
11441                         rte_crypto_op_free(ut_params->op);
11442
11443                 /*
11444                  * free mbuf - both obuf and ibuf are usually the same,
11445                  * so check if they point at the same address is necessary,
11446                  * to avoid freeing the mbuf twice.
11447                  */
11448                 if (ut_params->obuf) {
11449                         rte_pktmbuf_free(ut_params->obuf);
11450                         if (ut_params->ibuf == ut_params->obuf)
11451                                 ut_params->ibuf = 0;
11452                         ut_params->obuf = 0;
11453                 }
11454                 if (ut_params->ibuf) {
11455                         rte_pktmbuf_free(ut_params->ibuf);
11456                         ut_params->ibuf = 0;
11457                 }
11458         }
11459
11460         sessions[i] = NULL;
11461         /* Next session create should fail */
11462         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11463                         sessions[i], &ut_params->auth_xform,
11464                         ts_params->session_priv_mpool);
11465         TEST_ASSERT_NULL(sessions[i],
11466                         "Session creation succeeded unexpectedly!");
11467
11468         for (i = 0; i < MAX_NB_SESSIONS; i++) {
11469                 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
11470                                 sessions[i]);
11471                 rte_cryptodev_sym_session_free(sessions[i]);
11472         }
11473
11474         rte_free(sessions);
11475
11476         return TEST_SUCCESS;
11477 }
11478
11479 struct multi_session_params {
11480         struct crypto_unittest_params ut_params;
11481         uint8_t *cipher_key;
11482         uint8_t *hmac_key;
11483         const uint8_t *cipher;
11484         const uint8_t *digest;
11485         uint8_t *iv;
11486 };
11487
11488 #define MB_SESSION_NUMBER 3
11489
11490 static int
11491 test_multi_session_random_usage(void)
11492 {
11493         struct crypto_testsuite_params *ts_params = &testsuite_params;
11494         struct rte_cryptodev_info dev_info;
11495         struct rte_cryptodev_sym_session **sessions;
11496         uint32_t i, j;
11497         struct multi_session_params ut_paramz[] = {
11498
11499                 {
11500                         .cipher_key = ms_aes_cbc_key0,
11501                         .hmac_key = ms_hmac_key0,
11502                         .cipher = ms_aes_cbc_cipher0,
11503                         .digest = ms_hmac_digest0,
11504                         .iv = ms_aes_cbc_iv0
11505                 },
11506                 {
11507                         .cipher_key = ms_aes_cbc_key1,
11508                         .hmac_key = ms_hmac_key1,
11509                         .cipher = ms_aes_cbc_cipher1,
11510                         .digest = ms_hmac_digest1,
11511                         .iv = ms_aes_cbc_iv1
11512                 },
11513                 {
11514                         .cipher_key = ms_aes_cbc_key2,
11515                         .hmac_key = ms_hmac_key2,
11516                         .cipher = ms_aes_cbc_cipher2,
11517                         .digest = ms_hmac_digest2,
11518                         .iv = ms_aes_cbc_iv2
11519                 },
11520
11521         };
11522
11523         /* Verify the capabilities */
11524         struct rte_cryptodev_sym_capability_idx cap_idx;
11525         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11526         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
11527         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11528                         &cap_idx) == NULL)
11529                 return TEST_SKIPPED;
11530         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11531         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
11532         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11533                         &cap_idx) == NULL)
11534                 return TEST_SKIPPED;
11535
11536         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11537
11538         sessions = rte_malloc(NULL,
11539                         (sizeof(struct rte_cryptodev_sym_session *)
11540                                         * MAX_NB_SESSIONS) + 1, 0);
11541
11542         for (i = 0; i < MB_SESSION_NUMBER; i++) {
11543                 sessions[i] = rte_cryptodev_sym_session_create(
11544                                 ts_params->session_mpool);
11545
11546                 rte_memcpy(&ut_paramz[i].ut_params, &unittest_params,
11547                                 sizeof(struct crypto_unittest_params));
11548
11549                 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
11550                                 &ut_paramz[i].ut_params,
11551                                 ut_paramz[i].cipher_key, ut_paramz[i].hmac_key);
11552
11553                 /* Create multiple crypto sessions*/
11554                 rte_cryptodev_sym_session_init(
11555                                 ts_params->valid_devs[0],
11556                                 sessions[i],
11557                                 &ut_paramz[i].ut_params.auth_xform,
11558                                 ts_params->session_priv_mpool);
11559
11560                 TEST_ASSERT_NOT_NULL(sessions[i],
11561                                 "Session creation failed at session number %u",
11562                                 i);
11563
11564         }
11565
11566         srand(time(NULL));
11567         for (i = 0; i < 40000; i++) {
11568
11569                 j = rand() % MB_SESSION_NUMBER;
11570
11571                 TEST_ASSERT_SUCCESS(
11572                         test_AES_CBC_HMAC_SHA512_decrypt_perform(
11573                                         sessions[j],
11574                                         &ut_paramz[j].ut_params,
11575                                         ts_params, ut_paramz[j].cipher,
11576                                         ut_paramz[j].digest,
11577                                         ut_paramz[j].iv),
11578                         "Failed to perform decrypt on request number %u.", i);
11579
11580                 if (ut_paramz[j].ut_params.op)
11581                         rte_crypto_op_free(ut_paramz[j].ut_params.op);
11582
11583                 /*
11584                  * free mbuf - both obuf and ibuf are usually the same,
11585                  * so check if they point at the same address is necessary,
11586                  * to avoid freeing the mbuf twice.
11587                  */
11588                 if (ut_paramz[j].ut_params.obuf) {
11589                         rte_pktmbuf_free(ut_paramz[j].ut_params.obuf);
11590                         if (ut_paramz[j].ut_params.ibuf
11591                                         == ut_paramz[j].ut_params.obuf)
11592                                 ut_paramz[j].ut_params.ibuf = 0;
11593                         ut_paramz[j].ut_params.obuf = 0;
11594                 }
11595                 if (ut_paramz[j].ut_params.ibuf) {
11596                         rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf);
11597                         ut_paramz[j].ut_params.ibuf = 0;
11598                 }
11599         }
11600
11601         for (i = 0; i < MB_SESSION_NUMBER; i++) {
11602                 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
11603                                 sessions[i]);
11604                 rte_cryptodev_sym_session_free(sessions[i]);
11605         }
11606
11607         rte_free(sessions);
11608
11609         return TEST_SUCCESS;
11610 }
11611
11612 uint8_t orig_data[] = {0xab, 0xab, 0xab, 0xab,
11613                         0xab, 0xab, 0xab, 0xab,
11614                         0xab, 0xab, 0xab, 0xab,
11615                         0xab, 0xab, 0xab, 0xab};
11616
11617 static int
11618 test_null_invalid_operation(void)
11619 {
11620         struct crypto_testsuite_params *ts_params = &testsuite_params;
11621         struct crypto_unittest_params *ut_params = &unittest_params;
11622         int ret;
11623
11624         /* This test is for NULL PMD only */
11625         if (gbl_driver_id != rte_cryptodev_driver_id_get(
11626                         RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
11627                 return TEST_SKIPPED;
11628
11629         /* Setup Cipher Parameters */
11630         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11631         ut_params->cipher_xform.next = NULL;
11632
11633         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
11634         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
11635
11636         ut_params->sess = rte_cryptodev_sym_session_create(
11637                         ts_params->session_mpool);
11638
11639         /* Create Crypto session*/
11640         ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11641                         ut_params->sess, &ut_params->cipher_xform,
11642                         ts_params->session_priv_mpool);
11643         TEST_ASSERT(ret < 0,
11644                         "Session creation succeeded unexpectedly");
11645
11646
11647         /* Setup HMAC Parameters */
11648         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11649         ut_params->auth_xform.next = NULL;
11650
11651         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
11652         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
11653
11654         ut_params->sess = rte_cryptodev_sym_session_create(
11655                         ts_params->session_mpool);
11656
11657         /* Create Crypto session*/
11658         ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11659                         ut_params->sess, &ut_params->auth_xform,
11660                         ts_params->session_priv_mpool);
11661         TEST_ASSERT(ret < 0,
11662                         "Session creation succeeded unexpectedly");
11663
11664         return TEST_SUCCESS;
11665 }
11666
11667
11668 #define NULL_BURST_LENGTH (32)
11669
11670 static int
11671 test_null_burst_operation(void)
11672 {
11673         struct crypto_testsuite_params *ts_params = &testsuite_params;
11674         struct crypto_unittest_params *ut_params = &unittest_params;
11675
11676         unsigned i, burst_len = NULL_BURST_LENGTH;
11677
11678         struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
11679         struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
11680
11681         /* This test is for NULL PMD only */
11682         if (gbl_driver_id != rte_cryptodev_driver_id_get(
11683                         RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
11684                 return TEST_SKIPPED;
11685
11686         /* Setup Cipher Parameters */
11687         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11688         ut_params->cipher_xform.next = &ut_params->auth_xform;
11689
11690         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
11691         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
11692
11693         /* Setup HMAC Parameters */
11694         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11695         ut_params->auth_xform.next = NULL;
11696
11697         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
11698         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
11699
11700         ut_params->sess = rte_cryptodev_sym_session_create(
11701                         ts_params->session_mpool);
11702
11703         /* Create Crypto session*/
11704         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11705                         ut_params->sess, &ut_params->cipher_xform,
11706                         ts_params->session_priv_mpool);
11707         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
11708
11709         TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
11710                         RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
11711                         burst_len, "failed to generate burst of crypto ops");
11712
11713         /* Generate an operation for each mbuf in burst */
11714         for (i = 0; i < burst_len; i++) {
11715                 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11716
11717                 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
11718
11719                 unsigned *data = (unsigned *)rte_pktmbuf_append(m,
11720                                 sizeof(unsigned));
11721                 *data = i;
11722
11723                 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
11724
11725                 burst[i]->sym->m_src = m;
11726         }
11727
11728         /* Process crypto operation */
11729         TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
11730                         0, burst, burst_len),
11731                         burst_len,
11732                         "Error enqueuing burst");
11733
11734         TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
11735                         0, burst_dequeued, burst_len),
11736                         burst_len,
11737                         "Error dequeuing burst");
11738
11739
11740         for (i = 0; i < burst_len; i++) {
11741                 TEST_ASSERT_EQUAL(
11742                         *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
11743                         *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
11744                                         uint32_t *),
11745                         "data not as expected");
11746
11747                 rte_pktmbuf_free(burst[i]->sym->m_src);
11748                 rte_crypto_op_free(burst[i]);
11749         }
11750
11751         return TEST_SUCCESS;
11752 }
11753
11754 static uint16_t
11755 test_enq_callback(uint16_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops,
11756                   uint16_t nb_ops, void *user_param)
11757 {
11758         RTE_SET_USED(dev_id);
11759         RTE_SET_USED(qp_id);
11760         RTE_SET_USED(ops);
11761         RTE_SET_USED(user_param);
11762
11763         printf("crypto enqueue callback called\n");
11764         return nb_ops;
11765 }
11766
11767 static uint16_t
11768 test_deq_callback(uint16_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops,
11769                   uint16_t nb_ops, void *user_param)
11770 {
11771         RTE_SET_USED(dev_id);
11772         RTE_SET_USED(qp_id);
11773         RTE_SET_USED(ops);
11774         RTE_SET_USED(user_param);
11775
11776         printf("crypto dequeue callback called\n");
11777         return nb_ops;
11778 }
11779
11780 /*
11781  * Thread using enqueue/dequeue callback with RCU.
11782  */
11783 static int
11784 test_enqdeq_callback_thread(void *arg)
11785 {
11786         RTE_SET_USED(arg);
11787         /* DP thread calls rte_cryptodev_enqueue_burst()/
11788          * rte_cryptodev_dequeue_burst() and invokes callback.
11789          */
11790         test_null_burst_operation();
11791         return 0;
11792 }
11793
11794 static int
11795 test_enq_callback_setup(void)
11796 {
11797         struct crypto_testsuite_params *ts_params = &testsuite_params;
11798         struct rte_cryptodev_info dev_info;
11799         struct rte_cryptodev_qp_conf qp_conf = {
11800                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
11801         };
11802
11803         struct rte_cryptodev_cb *cb;
11804         uint16_t qp_id = 0;
11805
11806         /* Stop the device in case it's started so it can be configured */
11807         rte_cryptodev_stop(ts_params->valid_devs[0]);
11808
11809         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11810
11811         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
11812                         &ts_params->conf),
11813                         "Failed to configure cryptodev %u",
11814                         ts_params->valid_devs[0]);
11815
11816         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
11817         qp_conf.mp_session = ts_params->session_mpool;
11818         qp_conf.mp_session_private = ts_params->session_priv_mpool;
11819
11820         TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
11821                         ts_params->valid_devs[0], qp_id, &qp_conf,
11822                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
11823                         "Failed test for "
11824                         "rte_cryptodev_queue_pair_setup: num_inflights "
11825                         "%u on qp %u on cryptodev %u",
11826                         qp_conf.nb_descriptors, qp_id,
11827                         ts_params->valid_devs[0]);
11828
11829         /* Test with invalid crypto device */
11830         cb = rte_cryptodev_add_enq_callback(RTE_CRYPTO_MAX_DEVS,
11831                         qp_id, test_enq_callback, NULL);
11832         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11833                         "cryptodev %u did not fail",
11834                         qp_id, RTE_CRYPTO_MAX_DEVS);
11835
11836         /* Test with invalid queue pair */
11837         cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
11838                         dev_info.max_nb_queue_pairs + 1,
11839                         test_enq_callback, NULL);
11840         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11841                         "cryptodev %u did not fail",
11842                         dev_info.max_nb_queue_pairs + 1,
11843                         ts_params->valid_devs[0]);
11844
11845         /* Test with NULL callback */
11846         cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
11847                         qp_id, NULL, NULL);
11848         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11849                         "cryptodev %u did not fail",
11850                         qp_id, ts_params->valid_devs[0]);
11851
11852         /* Test with valid configuration */
11853         cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
11854                         qp_id, test_enq_callback, NULL);
11855         TEST_ASSERT_NOT_NULL(cb, "Failed test to add callback on "
11856                         "qp %u on cryptodev %u",
11857                         qp_id, ts_params->valid_devs[0]);
11858
11859         rte_cryptodev_start(ts_params->valid_devs[0]);
11860
11861         /* Launch a thread */
11862         rte_eal_remote_launch(test_enqdeq_callback_thread, NULL,
11863                                 rte_get_next_lcore(-1, 1, 0));
11864
11865         /* Wait until reader exited. */
11866         rte_eal_mp_wait_lcore();
11867
11868         /* Test with invalid crypto device */
11869         TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
11870                         RTE_CRYPTO_MAX_DEVS, qp_id, cb),
11871                         "Expected call to fail as crypto device is invalid");
11872
11873         /* Test with invalid queue pair */
11874         TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
11875                         ts_params->valid_devs[0],
11876                         dev_info.max_nb_queue_pairs + 1, cb),
11877                         "Expected call to fail as queue pair is invalid");
11878
11879         /* Test with NULL callback */
11880         TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
11881                         ts_params->valid_devs[0], qp_id, NULL),
11882                         "Expected call to fail as callback is NULL");
11883
11884         /* Test with valid configuration */
11885         TEST_ASSERT_SUCCESS(rte_cryptodev_remove_enq_callback(
11886                         ts_params->valid_devs[0], qp_id, cb),
11887                         "Failed test to remove callback on "
11888                         "qp %u on cryptodev %u",
11889                         qp_id, ts_params->valid_devs[0]);
11890
11891         return TEST_SUCCESS;
11892 }
11893
11894 static int
11895 test_deq_callback_setup(void)
11896 {
11897         struct crypto_testsuite_params *ts_params = &testsuite_params;
11898         struct rte_cryptodev_info dev_info;
11899         struct rte_cryptodev_qp_conf qp_conf = {
11900                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
11901         };
11902
11903         struct rte_cryptodev_cb *cb;
11904         uint16_t qp_id = 0;
11905
11906         /* Stop the device in case it's started so it can be configured */
11907         rte_cryptodev_stop(ts_params->valid_devs[0]);
11908
11909         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11910
11911         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
11912                         &ts_params->conf),
11913                         "Failed to configure cryptodev %u",
11914                         ts_params->valid_devs[0]);
11915
11916         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
11917         qp_conf.mp_session = ts_params->session_mpool;
11918         qp_conf.mp_session_private = ts_params->session_priv_mpool;
11919
11920         TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
11921                         ts_params->valid_devs[0], qp_id, &qp_conf,
11922                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
11923                         "Failed test for "
11924                         "rte_cryptodev_queue_pair_setup: num_inflights "
11925                         "%u on qp %u on cryptodev %u",
11926                         qp_conf.nb_descriptors, qp_id,
11927                         ts_params->valid_devs[0]);
11928
11929         /* Test with invalid crypto device */
11930         cb = rte_cryptodev_add_deq_callback(RTE_CRYPTO_MAX_DEVS,
11931                         qp_id, test_deq_callback, NULL);
11932         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11933                         "cryptodev %u did not fail",
11934                         qp_id, RTE_CRYPTO_MAX_DEVS);
11935
11936         /* Test with invalid queue pair */
11937         cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
11938                         dev_info.max_nb_queue_pairs + 1,
11939                         test_deq_callback, NULL);
11940         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11941                         "cryptodev %u did not fail",
11942                         dev_info.max_nb_queue_pairs + 1,
11943                         ts_params->valid_devs[0]);
11944
11945         /* Test with NULL callback */
11946         cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
11947                         qp_id, NULL, NULL);
11948         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11949                         "cryptodev %u did not fail",
11950                         qp_id, ts_params->valid_devs[0]);
11951
11952         /* Test with valid configuration */
11953         cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
11954                         qp_id, test_deq_callback, NULL);
11955         TEST_ASSERT_NOT_NULL(cb, "Failed test to add callback on "
11956                         "qp %u on cryptodev %u",
11957                         qp_id, ts_params->valid_devs[0]);
11958
11959         rte_cryptodev_start(ts_params->valid_devs[0]);
11960
11961         /* Launch a thread */
11962         rte_eal_remote_launch(test_enqdeq_callback_thread, NULL,
11963                                 rte_get_next_lcore(-1, 1, 0));
11964
11965         /* Wait until reader exited. */
11966         rte_eal_mp_wait_lcore();
11967
11968         /* Test with invalid crypto device */
11969         TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
11970                         RTE_CRYPTO_MAX_DEVS, qp_id, cb),
11971                         "Expected call to fail as crypto device is invalid");
11972
11973         /* Test with invalid queue pair */
11974         TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
11975                         ts_params->valid_devs[0],
11976                         dev_info.max_nb_queue_pairs + 1, cb),
11977                         "Expected call to fail as queue pair is invalid");
11978
11979         /* Test with NULL callback */
11980         TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
11981                         ts_params->valid_devs[0], qp_id, NULL),
11982                         "Expected call to fail as callback is NULL");
11983
11984         /* Test with valid configuration */
11985         TEST_ASSERT_SUCCESS(rte_cryptodev_remove_deq_callback(
11986                         ts_params->valid_devs[0], qp_id, cb),
11987                         "Failed test to remove callback on "
11988                         "qp %u on cryptodev %u",
11989                         qp_id, ts_params->valid_devs[0]);
11990
11991         return TEST_SUCCESS;
11992 }
11993
11994 static void
11995 generate_gmac_large_plaintext(uint8_t *data)
11996 {
11997         uint16_t i;
11998
11999         for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32)
12000                 memcpy(&data[i], &data[0], 32);
12001 }
12002
12003 static int
12004 create_gmac_operation(enum rte_crypto_auth_operation op,
12005                 const struct gmac_test_data *tdata)
12006 {
12007         struct crypto_testsuite_params *ts_params = &testsuite_params;
12008         struct crypto_unittest_params *ut_params = &unittest_params;
12009         struct rte_crypto_sym_op *sym_op;
12010
12011         uint32_t plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
12012
12013         /* Generate Crypto op data structure */
12014         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12015                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12016         TEST_ASSERT_NOT_NULL(ut_params->op,
12017                         "Failed to allocate symmetric crypto operation struct");
12018
12019         sym_op = ut_params->op->sym;
12020
12021         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
12022                         ut_params->ibuf, tdata->gmac_tag.len);
12023         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
12024                         "no room to append digest");
12025
12026         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
12027                         ut_params->ibuf, plaintext_pad_len);
12028
12029         if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
12030                 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
12031                                 tdata->gmac_tag.len);
12032                 debug_hexdump(stdout, "digest:",
12033                                 sym_op->auth.digest.data,
12034                                 tdata->gmac_tag.len);
12035         }
12036
12037         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
12038                         uint8_t *, IV_OFFSET);
12039
12040         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
12041
12042         debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
12043
12044         sym_op->cipher.data.length = 0;
12045         sym_op->cipher.data.offset = 0;
12046
12047         sym_op->auth.data.offset = 0;
12048         sym_op->auth.data.length = tdata->plaintext.len;
12049
12050         return 0;
12051 }
12052
12053 static int
12054 create_gmac_operation_sgl(enum rte_crypto_auth_operation op,
12055                 const struct gmac_test_data *tdata,
12056                 void *digest_mem, uint64_t digest_phys)
12057 {
12058         struct crypto_testsuite_params *ts_params = &testsuite_params;
12059         struct crypto_unittest_params *ut_params = &unittest_params;
12060         struct rte_crypto_sym_op *sym_op;
12061
12062         /* Generate Crypto op data structure */
12063         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12064                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12065         TEST_ASSERT_NOT_NULL(ut_params->op,
12066                         "Failed to allocate symmetric crypto operation struct");
12067
12068         sym_op = ut_params->op->sym;
12069
12070         sym_op->auth.digest.data = digest_mem;
12071         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
12072                         "no room to append digest");
12073
12074         sym_op->auth.digest.phys_addr = digest_phys;
12075
12076         if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
12077                 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
12078                                 tdata->gmac_tag.len);
12079                 debug_hexdump(stdout, "digest:",
12080                                 sym_op->auth.digest.data,
12081                                 tdata->gmac_tag.len);
12082         }
12083
12084         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
12085                         uint8_t *, IV_OFFSET);
12086
12087         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
12088
12089         debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
12090
12091         sym_op->cipher.data.length = 0;
12092         sym_op->cipher.data.offset = 0;
12093
12094         sym_op->auth.data.offset = 0;
12095         sym_op->auth.data.length = tdata->plaintext.len;
12096
12097         return 0;
12098 }
12099
12100 static int create_gmac_session(uint8_t dev_id,
12101                 const struct gmac_test_data *tdata,
12102                 enum rte_crypto_auth_operation auth_op)
12103 {
12104         uint8_t auth_key[tdata->key.len];
12105
12106         struct crypto_testsuite_params *ts_params = &testsuite_params;
12107         struct crypto_unittest_params *ut_params = &unittest_params;
12108
12109         memcpy(auth_key, tdata->key.data, tdata->key.len);
12110
12111         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12112         ut_params->auth_xform.next = NULL;
12113
12114         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
12115         ut_params->auth_xform.auth.op = auth_op;
12116         ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
12117         ut_params->auth_xform.auth.key.length = tdata->key.len;
12118         ut_params->auth_xform.auth.key.data = auth_key;
12119         ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
12120         ut_params->auth_xform.auth.iv.length = tdata->iv.len;
12121
12122
12123         ut_params->sess = rte_cryptodev_sym_session_create(
12124                         ts_params->session_mpool);
12125
12126         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
12127                         &ut_params->auth_xform,
12128                         ts_params->session_priv_mpool);
12129
12130         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12131
12132         return 0;
12133 }
12134
12135 static int
12136 test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
12137 {
12138         struct crypto_testsuite_params *ts_params = &testsuite_params;
12139         struct crypto_unittest_params *ut_params = &unittest_params;
12140         struct rte_cryptodev_info dev_info;
12141
12142         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12143         uint64_t feat_flags = dev_info.feature_flags;
12144
12145         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12146                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12147                 printf("Device doesn't support RAW data-path APIs.\n");
12148                 return TEST_SKIPPED;
12149         }
12150
12151         int retval;
12152
12153         uint8_t *auth_tag, *plaintext;
12154         uint16_t plaintext_pad_len;
12155
12156         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
12157                               "No GMAC length in the source data");
12158
12159         /* Verify the capabilities */
12160         struct rte_cryptodev_sym_capability_idx cap_idx;
12161         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12162         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
12163         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12164                         &cap_idx) == NULL)
12165                 return TEST_SKIPPED;
12166
12167         retval = create_gmac_session(ts_params->valid_devs[0],
12168                         tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
12169
12170         if (retval < 0)
12171                 return retval;
12172
12173         if (tdata->plaintext.len > MBUF_SIZE)
12174                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
12175         else
12176                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12177         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12178                         "Failed to allocate input buffer in mempool");
12179
12180         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12181                         rte_pktmbuf_tailroom(ut_params->ibuf));
12182
12183         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
12184         /*
12185          * Runtime generate the large plain text instead of use hard code
12186          * plain text vector. It is done to avoid create huge source file
12187          * with the test vector.
12188          */
12189         if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
12190                 generate_gmac_large_plaintext(tdata->plaintext.data);
12191
12192         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12193                                 plaintext_pad_len);
12194         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12195
12196         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
12197         debug_hexdump(stdout, "plaintext:", plaintext,
12198                         tdata->plaintext.len);
12199
12200         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
12201                         tdata);
12202
12203         if (retval < 0)
12204                 return retval;
12205
12206         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12207
12208         ut_params->op->sym->m_src = ut_params->ibuf;
12209
12210         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12211                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12212                         ut_params->op);
12213         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12214                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12215                                 ut_params->op, 0, 1, 0, 0);
12216         else
12217                 TEST_ASSERT_NOT_NULL(
12218                         process_crypto_request(ts_params->valid_devs[0],
12219                         ut_params->op), "failed to process sym crypto op");
12220
12221         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12222                         "crypto op processing failed");
12223
12224         if (ut_params->op->sym->m_dst) {
12225                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
12226                                 uint8_t *, plaintext_pad_len);
12227         } else {
12228                 auth_tag = plaintext + plaintext_pad_len;
12229         }
12230
12231         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
12232
12233         TEST_ASSERT_BUFFERS_ARE_EQUAL(
12234                         auth_tag,
12235                         tdata->gmac_tag.data,
12236                         tdata->gmac_tag.len,
12237                         "GMAC Generated auth tag not as expected");
12238
12239         return 0;
12240 }
12241
12242 static int
12243 test_AES_GMAC_authentication_test_case_1(void)
12244 {
12245         return test_AES_GMAC_authentication(&gmac_test_case_1);
12246 }
12247
12248 static int
12249 test_AES_GMAC_authentication_test_case_2(void)
12250 {
12251         return test_AES_GMAC_authentication(&gmac_test_case_2);
12252 }
12253
12254 static int
12255 test_AES_GMAC_authentication_test_case_3(void)
12256 {
12257         return test_AES_GMAC_authentication(&gmac_test_case_3);
12258 }
12259
12260 static int
12261 test_AES_GMAC_authentication_test_case_4(void)
12262 {
12263         return test_AES_GMAC_authentication(&gmac_test_case_4);
12264 }
12265
12266 static int
12267 test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
12268 {
12269         struct crypto_testsuite_params *ts_params = &testsuite_params;
12270         struct crypto_unittest_params *ut_params = &unittest_params;
12271         int retval;
12272         uint32_t plaintext_pad_len;
12273         uint8_t *plaintext;
12274         struct rte_cryptodev_info dev_info;
12275
12276         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12277         uint64_t feat_flags = dev_info.feature_flags;
12278
12279         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12280                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12281                 printf("Device doesn't support RAW data-path APIs.\n");
12282                 return TEST_SKIPPED;
12283         }
12284
12285         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
12286                               "No GMAC length in the source data");
12287
12288         /* Verify the capabilities */
12289         struct rte_cryptodev_sym_capability_idx cap_idx;
12290         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12291         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
12292         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12293                         &cap_idx) == NULL)
12294                 return TEST_SKIPPED;
12295
12296         retval = create_gmac_session(ts_params->valid_devs[0],
12297                         tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
12298
12299         if (retval < 0)
12300                 return retval;
12301
12302         if (tdata->plaintext.len > MBUF_SIZE)
12303                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
12304         else
12305                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12306         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12307                         "Failed to allocate input buffer in mempool");
12308
12309         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12310                         rte_pktmbuf_tailroom(ut_params->ibuf));
12311
12312         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
12313
12314         /*
12315          * Runtime generate the large plain text instead of use hard code
12316          * plain text vector. It is done to avoid create huge source file
12317          * with the test vector.
12318          */
12319         if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
12320                 generate_gmac_large_plaintext(tdata->plaintext.data);
12321
12322         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12323                                 plaintext_pad_len);
12324         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12325
12326         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
12327         debug_hexdump(stdout, "plaintext:", plaintext,
12328                         tdata->plaintext.len);
12329
12330         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
12331                         tdata);
12332
12333         if (retval < 0)
12334                 return retval;
12335
12336         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12337
12338         ut_params->op->sym->m_src = ut_params->ibuf;
12339
12340         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12341                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12342                         ut_params->op);
12343         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12344                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12345                                 ut_params->op, 0, 1, 0, 0);
12346         else
12347                 TEST_ASSERT_NOT_NULL(
12348                         process_crypto_request(ts_params->valid_devs[0],
12349                         ut_params->op), "failed to process sym crypto op");
12350
12351         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12352                         "crypto op processing failed");
12353
12354         return 0;
12355
12356 }
12357
12358 static int
12359 test_AES_GMAC_authentication_verify_test_case_1(void)
12360 {
12361         return test_AES_GMAC_authentication_verify(&gmac_test_case_1);
12362 }
12363
12364 static int
12365 test_AES_GMAC_authentication_verify_test_case_2(void)
12366 {
12367         return test_AES_GMAC_authentication_verify(&gmac_test_case_2);
12368 }
12369
12370 static int
12371 test_AES_GMAC_authentication_verify_test_case_3(void)
12372 {
12373         return test_AES_GMAC_authentication_verify(&gmac_test_case_3);
12374 }
12375
12376 static int
12377 test_AES_GMAC_authentication_verify_test_case_4(void)
12378 {
12379         return test_AES_GMAC_authentication_verify(&gmac_test_case_4);
12380 }
12381
12382 static int
12383 test_AES_GMAC_authentication_SGL(const struct gmac_test_data *tdata,
12384                                 uint32_t fragsz)
12385 {
12386         struct crypto_testsuite_params *ts_params = &testsuite_params;
12387         struct crypto_unittest_params *ut_params = &unittest_params;
12388         struct rte_cryptodev_info dev_info;
12389         uint64_t feature_flags;
12390         unsigned int trn_data = 0;
12391         void *digest_mem = NULL;
12392         uint32_t segs = 1;
12393         unsigned int to_trn = 0;
12394         struct rte_mbuf *buf = NULL;
12395         uint8_t *auth_tag, *plaintext;
12396         int retval;
12397
12398         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
12399                               "No GMAC length in the source data");
12400
12401         /* Verify the capabilities */
12402         struct rte_cryptodev_sym_capability_idx cap_idx;
12403         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12404         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
12405         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12406                         &cap_idx) == NULL)
12407                 return TEST_SKIPPED;
12408
12409         /* Check for any input SGL support */
12410         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12411         feature_flags = dev_info.feature_flags;
12412
12413         if ((!(feature_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) ||
12414                         (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT)) ||
12415                         (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)))
12416                 return TEST_SKIPPED;
12417
12418         if (fragsz > tdata->plaintext.len)
12419                 fragsz = tdata->plaintext.len;
12420
12421         uint16_t plaintext_len = fragsz;
12422
12423         retval = create_gmac_session(ts_params->valid_devs[0],
12424                         tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
12425
12426         if (retval < 0)
12427                 return retval;
12428
12429         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12430         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12431                         "Failed to allocate input buffer in mempool");
12432
12433         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12434                         rte_pktmbuf_tailroom(ut_params->ibuf));
12435
12436         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12437                                 plaintext_len);
12438         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12439
12440         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
12441
12442         trn_data += plaintext_len;
12443
12444         buf = ut_params->ibuf;
12445
12446         /*
12447          * Loop until no more fragments
12448          */
12449
12450         while (trn_data < tdata->plaintext.len) {
12451                 ++segs;
12452                 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
12453                                 (tdata->plaintext.len - trn_data) : fragsz;
12454
12455                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12456                 buf = buf->next;
12457
12458                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
12459                                 rte_pktmbuf_tailroom(buf));
12460
12461                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
12462                                 to_trn);
12463
12464                 memcpy(plaintext, tdata->plaintext.data + trn_data,
12465                                 to_trn);
12466                 trn_data += to_trn;
12467                 if (trn_data  == tdata->plaintext.len)
12468                         digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
12469                                         tdata->gmac_tag.len);
12470         }
12471         ut_params->ibuf->nb_segs = segs;
12472
12473         /*
12474          * Place digest at the end of the last buffer
12475          */
12476         uint64_t digest_phys = rte_pktmbuf_iova(buf) + to_trn;
12477
12478         if (!digest_mem) {
12479                 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12480                                 + tdata->gmac_tag.len);
12481                 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
12482                                 tdata->plaintext.len);
12483         }
12484
12485         retval = create_gmac_operation_sgl(RTE_CRYPTO_AUTH_OP_GENERATE,
12486                         tdata, digest_mem, digest_phys);
12487
12488         if (retval < 0)
12489                 return retval;
12490
12491         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12492
12493         ut_params->op->sym->m_src = ut_params->ibuf;
12494
12495         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12496                 return TEST_SKIPPED;
12497
12498         TEST_ASSERT_NOT_NULL(
12499                 process_crypto_request(ts_params->valid_devs[0],
12500                 ut_params->op), "failed to process sym crypto op");
12501
12502         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12503                         "crypto op processing failed");
12504
12505         auth_tag = digest_mem;
12506         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
12507         TEST_ASSERT_BUFFERS_ARE_EQUAL(
12508                         auth_tag,
12509                         tdata->gmac_tag.data,
12510                         tdata->gmac_tag.len,
12511                         "GMAC Generated auth tag not as expected");
12512
12513         return 0;
12514 }
12515
12516 /* Segment size not multiple of block size (16B) */
12517 static int
12518 test_AES_GMAC_authentication_SGL_40B(void)
12519 {
12520         return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 40);
12521 }
12522
12523 static int
12524 test_AES_GMAC_authentication_SGL_80B(void)
12525 {
12526         return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 80);
12527 }
12528
12529 static int
12530 test_AES_GMAC_authentication_SGL_2048B(void)
12531 {
12532         return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2048);
12533 }
12534
12535 /* Segment size not multiple of block size (16B) */
12536 static int
12537 test_AES_GMAC_authentication_SGL_2047B(void)
12538 {
12539         return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2047);
12540 }
12541
12542 struct test_crypto_vector {
12543         enum rte_crypto_cipher_algorithm crypto_algo;
12544         unsigned int cipher_offset;
12545         unsigned int cipher_len;
12546
12547         struct {
12548                 uint8_t data[64];
12549                 unsigned int len;
12550         } cipher_key;
12551
12552         struct {
12553                 uint8_t data[64];
12554                 unsigned int len;
12555         } iv;
12556
12557         struct {
12558                 const uint8_t *data;
12559                 unsigned int len;
12560         } plaintext;
12561
12562         struct {
12563                 const uint8_t *data;
12564                 unsigned int len;
12565         } ciphertext;
12566
12567         enum rte_crypto_auth_algorithm auth_algo;
12568         unsigned int auth_offset;
12569
12570         struct {
12571                 uint8_t data[128];
12572                 unsigned int len;
12573         } auth_key;
12574
12575         struct {
12576                 const uint8_t *data;
12577                 unsigned int len;
12578         } aad;
12579
12580         struct {
12581                 uint8_t data[128];
12582                 unsigned int len;
12583         } digest;
12584 };
12585
12586 static const struct test_crypto_vector
12587 hmac_sha1_test_crypto_vector = {
12588         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
12589         .plaintext = {
12590                 .data = plaintext_hash,
12591                 .len = 512
12592         },
12593         .auth_key = {
12594                 .data = {
12595                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
12596                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
12597                         0xDE, 0xF4, 0xDE, 0xAD
12598                 },
12599                 .len = 20
12600         },
12601         .digest = {
12602                 .data = {
12603                         0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
12604                         0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
12605                         0x3F, 0x91, 0x64, 0x59
12606                 },
12607                 .len = 20
12608         }
12609 };
12610
12611 static const struct test_crypto_vector
12612 aes128_gmac_test_vector = {
12613         .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
12614         .plaintext = {
12615                 .data = plaintext_hash,
12616                 .len = 512
12617         },
12618         .iv = {
12619                 .data = {
12620                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
12621                         0x08, 0x09, 0x0A, 0x0B
12622                 },
12623                 .len = 12
12624         },
12625         .auth_key = {
12626                 .data = {
12627                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
12628                         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
12629                 },
12630                 .len = 16
12631         },
12632         .digest = {
12633                 .data = {
12634                         0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56,
12635                         0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A
12636                 },
12637                 .len = 16
12638         }
12639 };
12640
12641 static const struct test_crypto_vector
12642 aes128cbc_hmac_sha1_test_vector = {
12643         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
12644         .cipher_offset = 0,
12645         .cipher_len = 512,
12646         .cipher_key = {
12647                 .data = {
12648                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
12649                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
12650                 },
12651                 .len = 16
12652         },
12653         .iv = {
12654                 .data = {
12655                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
12656                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
12657                 },
12658                 .len = 16
12659         },
12660         .plaintext = {
12661                 .data = plaintext_hash,
12662                 .len = 512
12663         },
12664         .ciphertext = {
12665                 .data = ciphertext512_aes128cbc,
12666                 .len = 512
12667         },
12668         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
12669         .auth_offset = 0,
12670         .auth_key = {
12671                 .data = {
12672                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
12673                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
12674                         0xDE, 0xF4, 0xDE, 0xAD
12675                 },
12676                 .len = 20
12677         },
12678         .digest = {
12679                 .data = {
12680                         0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
12681                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
12682                         0x18, 0x8C, 0x1D, 0x32
12683                 },
12684                 .len = 20
12685         }
12686 };
12687
12688 static const struct test_crypto_vector
12689 aes128cbc_hmac_sha1_aad_test_vector = {
12690         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
12691         .cipher_offset = 8,
12692         .cipher_len = 496,
12693         .cipher_key = {
12694                 .data = {
12695                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
12696                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
12697                 },
12698                 .len = 16
12699         },
12700         .iv = {
12701                 .data = {
12702                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
12703                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
12704                 },
12705                 .len = 16
12706         },
12707         .plaintext = {
12708                 .data = plaintext_hash,
12709                 .len = 512
12710         },
12711         .ciphertext = {
12712                 .data = ciphertext512_aes128cbc_aad,
12713                 .len = 512
12714         },
12715         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
12716         .auth_offset = 0,
12717         .auth_key = {
12718                 .data = {
12719                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
12720                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
12721                         0xDE, 0xF4, 0xDE, 0xAD
12722                 },
12723                 .len = 20
12724         },
12725         .digest = {
12726                 .data = {
12727                         0x6D, 0xF3, 0x50, 0x79, 0x7A, 0x2A, 0xAC, 0x7F,
12728                         0xA6, 0xF0, 0xC6, 0x38, 0x1F, 0xA4, 0xDD, 0x9B,
12729                         0x62, 0x0F, 0xFB, 0x10
12730                 },
12731                 .len = 20
12732         }
12733 };
12734
12735 static void
12736 data_corruption(uint8_t *data)
12737 {
12738         data[0] += 1;
12739 }
12740
12741 static void
12742 tag_corruption(uint8_t *data, unsigned int tag_offset)
12743 {
12744         data[tag_offset] += 1;
12745 }
12746
12747 static int
12748 create_auth_session(struct crypto_unittest_params *ut_params,
12749                 uint8_t dev_id,
12750                 const struct test_crypto_vector *reference,
12751                 enum rte_crypto_auth_operation auth_op)
12752 {
12753         struct crypto_testsuite_params *ts_params = &testsuite_params;
12754         uint8_t auth_key[reference->auth_key.len + 1];
12755
12756         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
12757
12758         /* Setup Authentication Parameters */
12759         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12760         ut_params->auth_xform.auth.op = auth_op;
12761         ut_params->auth_xform.next = NULL;
12762         ut_params->auth_xform.auth.algo = reference->auth_algo;
12763         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
12764         ut_params->auth_xform.auth.key.data = auth_key;
12765         ut_params->auth_xform.auth.digest_length = reference->digest.len;
12766
12767         /* Create Crypto session*/
12768         ut_params->sess = rte_cryptodev_sym_session_create(
12769                         ts_params->session_mpool);
12770
12771         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
12772                                 &ut_params->auth_xform,
12773                                 ts_params->session_priv_mpool);
12774
12775         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12776
12777         return 0;
12778 }
12779
12780 static int
12781 create_auth_cipher_session(struct crypto_unittest_params *ut_params,
12782                 uint8_t dev_id,
12783                 const struct test_crypto_vector *reference,
12784                 enum rte_crypto_auth_operation auth_op,
12785                 enum rte_crypto_cipher_operation cipher_op)
12786 {
12787         struct crypto_testsuite_params *ts_params = &testsuite_params;
12788         uint8_t cipher_key[reference->cipher_key.len + 1];
12789         uint8_t auth_key[reference->auth_key.len + 1];
12790
12791         memcpy(cipher_key, reference->cipher_key.data,
12792                         reference->cipher_key.len);
12793         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
12794
12795         /* Setup Authentication Parameters */
12796         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12797         ut_params->auth_xform.auth.op = auth_op;
12798         ut_params->auth_xform.auth.algo = reference->auth_algo;
12799         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
12800         ut_params->auth_xform.auth.key.data = auth_key;
12801         ut_params->auth_xform.auth.digest_length = reference->digest.len;
12802
12803         if (reference->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) {
12804                 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
12805                 ut_params->auth_xform.auth.iv.length = reference->iv.len;
12806         } else {
12807                 ut_params->auth_xform.next = &ut_params->cipher_xform;
12808
12809                 /* Setup Cipher Parameters */
12810                 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12811                 ut_params->cipher_xform.next = NULL;
12812                 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
12813                 ut_params->cipher_xform.cipher.op = cipher_op;
12814                 ut_params->cipher_xform.cipher.key.data = cipher_key;
12815                 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
12816                 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
12817                 ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
12818         }
12819
12820         /* Create Crypto session*/
12821         ut_params->sess = rte_cryptodev_sym_session_create(
12822                         ts_params->session_mpool);
12823
12824         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
12825                                 &ut_params->auth_xform,
12826                                 ts_params->session_priv_mpool);
12827
12828         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12829
12830         return 0;
12831 }
12832
12833 static int
12834 create_auth_operation(struct crypto_testsuite_params *ts_params,
12835                 struct crypto_unittest_params *ut_params,
12836                 const struct test_crypto_vector *reference,
12837                 unsigned int auth_generate)
12838 {
12839         /* Generate Crypto op data structure */
12840         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12841                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12842         TEST_ASSERT_NOT_NULL(ut_params->op,
12843                         "Failed to allocate pktmbuf offload");
12844
12845         /* Set crypto operation data parameters */
12846         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12847
12848         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
12849
12850         /* set crypto operation source mbuf */
12851         sym_op->m_src = ut_params->ibuf;
12852
12853         /* digest */
12854         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
12855                         ut_params->ibuf, reference->digest.len);
12856
12857         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
12858                         "no room to append auth tag");
12859
12860         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
12861                         ut_params->ibuf, reference->plaintext.len);
12862
12863         if (auth_generate)
12864                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
12865         else
12866                 memcpy(sym_op->auth.digest.data,
12867                                 reference->digest.data,
12868                                 reference->digest.len);
12869
12870         debug_hexdump(stdout, "digest:",
12871                         sym_op->auth.digest.data,
12872                         reference->digest.len);
12873
12874         sym_op->auth.data.length = reference->plaintext.len;
12875         sym_op->auth.data.offset = 0;
12876
12877         return 0;
12878 }
12879
12880 static int
12881 create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
12882                 struct crypto_unittest_params *ut_params,
12883                 const struct test_crypto_vector *reference,
12884                 unsigned int auth_generate)
12885 {
12886         /* Generate Crypto op data structure */
12887         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12888                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12889         TEST_ASSERT_NOT_NULL(ut_params->op,
12890                         "Failed to allocate pktmbuf offload");
12891
12892         /* Set crypto operation data parameters */
12893         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12894
12895         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
12896
12897         /* set crypto operation source mbuf */
12898         sym_op->m_src = ut_params->ibuf;
12899
12900         /* digest */
12901         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
12902                         ut_params->ibuf, reference->digest.len);
12903
12904         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
12905                         "no room to append auth tag");
12906
12907         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
12908                         ut_params->ibuf, reference->ciphertext.len);
12909
12910         if (auth_generate)
12911                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
12912         else
12913                 memcpy(sym_op->auth.digest.data,
12914                                 reference->digest.data,
12915                                 reference->digest.len);
12916
12917         debug_hexdump(stdout, "digest:",
12918                         sym_op->auth.digest.data,
12919                         reference->digest.len);
12920
12921         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
12922                         reference->iv.data, reference->iv.len);
12923
12924         sym_op->cipher.data.length = 0;
12925         sym_op->cipher.data.offset = 0;
12926
12927         sym_op->auth.data.length = reference->plaintext.len;
12928         sym_op->auth.data.offset = 0;
12929
12930         return 0;
12931 }
12932
12933 static int
12934 create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
12935                 struct crypto_unittest_params *ut_params,
12936                 const struct test_crypto_vector *reference,
12937                 unsigned int auth_generate)
12938 {
12939         /* Generate Crypto op data structure */
12940         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12941                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12942         TEST_ASSERT_NOT_NULL(ut_params->op,
12943                         "Failed to allocate pktmbuf offload");
12944
12945         /* Set crypto operation data parameters */
12946         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12947
12948         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
12949
12950         /* set crypto operation source mbuf */
12951         sym_op->m_src = ut_params->ibuf;
12952
12953         /* digest */
12954         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
12955                         ut_params->ibuf, reference->digest.len);
12956
12957         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
12958                         "no room to append auth tag");
12959
12960         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
12961                         ut_params->ibuf, reference->ciphertext.len);
12962
12963         if (auth_generate)
12964                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
12965         else
12966                 memcpy(sym_op->auth.digest.data,
12967                                 reference->digest.data,
12968                                 reference->digest.len);
12969
12970         debug_hexdump(stdout, "digest:",
12971                         sym_op->auth.digest.data,
12972                         reference->digest.len);
12973
12974         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
12975                         reference->iv.data, reference->iv.len);
12976
12977         sym_op->cipher.data.length = reference->cipher_len;
12978         sym_op->cipher.data.offset = reference->cipher_offset;
12979
12980         sym_op->auth.data.length = reference->plaintext.len;
12981         sym_op->auth.data.offset = reference->auth_offset;
12982
12983         return 0;
12984 }
12985
12986 static int
12987 create_auth_verify_operation(struct crypto_testsuite_params *ts_params,
12988                 struct crypto_unittest_params *ut_params,
12989                 const struct test_crypto_vector *reference)
12990 {
12991         return create_auth_operation(ts_params, ut_params, reference, 0);
12992 }
12993
12994 static int
12995 create_auth_verify_GMAC_operation(
12996                 struct crypto_testsuite_params *ts_params,
12997                 struct crypto_unittest_params *ut_params,
12998                 const struct test_crypto_vector *reference)
12999 {
13000         return create_auth_GMAC_operation(ts_params, ut_params, reference, 0);
13001 }
13002
13003 static int
13004 create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params,
13005                 struct crypto_unittest_params *ut_params,
13006                 const struct test_crypto_vector *reference)
13007 {
13008         return create_cipher_auth_operation(ts_params, ut_params, reference, 0);
13009 }
13010
13011 static int
13012 test_authentication_verify_fail_when_data_corruption(
13013                 struct crypto_testsuite_params *ts_params,
13014                 struct crypto_unittest_params *ut_params,
13015                 const struct test_crypto_vector *reference,
13016                 unsigned int data_corrupted)
13017 {
13018         int retval;
13019
13020         uint8_t *plaintext;
13021         struct rte_cryptodev_info dev_info;
13022
13023         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13024         uint64_t feat_flags = dev_info.feature_flags;
13025
13026         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13027                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13028                 printf("Device doesn't support RAW data-path APIs.\n");
13029                 return TEST_SKIPPED;
13030         }
13031
13032         /* Verify the capabilities */
13033         struct rte_cryptodev_sym_capability_idx cap_idx;
13034         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13035         cap_idx.algo.auth = reference->auth_algo;
13036         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13037                         &cap_idx) == NULL)
13038                 return TEST_SKIPPED;
13039
13040
13041         /* Create session */
13042         retval = create_auth_session(ut_params,
13043                         ts_params->valid_devs[0],
13044                         reference,
13045                         RTE_CRYPTO_AUTH_OP_VERIFY);
13046         if (retval < 0)
13047                 return retval;
13048
13049         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13050         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13051                         "Failed to allocate input buffer in mempool");
13052
13053         /* clear mbuf payload */
13054         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13055                         rte_pktmbuf_tailroom(ut_params->ibuf));
13056
13057         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13058                         reference->plaintext.len);
13059         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
13060         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
13061
13062         debug_hexdump(stdout, "plaintext:", plaintext,
13063                 reference->plaintext.len);
13064
13065         /* Create operation */
13066         retval = create_auth_verify_operation(ts_params, ut_params, reference);
13067
13068         if (retval < 0)
13069                 return retval;
13070
13071         if (data_corrupted)
13072                 data_corruption(plaintext);
13073         else
13074                 tag_corruption(plaintext, reference->plaintext.len);
13075
13076         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
13077                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13078                         ut_params->op);
13079                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
13080                         RTE_CRYPTO_OP_STATUS_SUCCESS,
13081                         "authentication not failed");
13082         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13083                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13084                                 ut_params->op, 0, 1, 0, 0);
13085         else {
13086                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13087                         ut_params->op);
13088         }
13089         if (ut_params->op == NULL)
13090                 return 0;
13091         else if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS)
13092                 return 0;
13093
13094         return -1;
13095 }
13096
13097 static int
13098 test_authentication_verify_GMAC_fail_when_corruption(
13099                 struct crypto_testsuite_params *ts_params,
13100                 struct crypto_unittest_params *ut_params,
13101                 const struct test_crypto_vector *reference,
13102                 unsigned int data_corrupted)
13103 {
13104         int retval;
13105         uint8_t *plaintext;
13106         struct rte_cryptodev_info dev_info;
13107
13108         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13109         uint64_t feat_flags = dev_info.feature_flags;
13110
13111         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13112                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13113                 printf("Device doesn't support RAW data-path APIs.\n");
13114                 return TEST_SKIPPED;
13115         }
13116
13117         /* Verify the capabilities */
13118         struct rte_cryptodev_sym_capability_idx cap_idx;
13119         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13120         cap_idx.algo.auth = reference->auth_algo;
13121         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13122                         &cap_idx) == NULL)
13123                 return TEST_SKIPPED;
13124
13125         /* Create session */
13126         retval = create_auth_cipher_session(ut_params,
13127                         ts_params->valid_devs[0],
13128                         reference,
13129                         RTE_CRYPTO_AUTH_OP_VERIFY,
13130                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
13131         if (retval < 0)
13132                 return retval;
13133
13134         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13135         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13136                         "Failed to allocate input buffer in mempool");
13137
13138         /* clear mbuf payload */
13139         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13140                         rte_pktmbuf_tailroom(ut_params->ibuf));
13141
13142         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13143                         reference->plaintext.len);
13144         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
13145         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
13146
13147         debug_hexdump(stdout, "plaintext:", plaintext,
13148                 reference->plaintext.len);
13149
13150         /* Create operation */
13151         retval = create_auth_verify_GMAC_operation(ts_params,
13152                         ut_params,
13153                         reference);
13154
13155         if (retval < 0)
13156                 return retval;
13157
13158         if (data_corrupted)
13159                 data_corruption(plaintext);
13160         else
13161                 tag_corruption(plaintext, reference->aad.len);
13162
13163         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
13164                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13165                         ut_params->op);
13166                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
13167                         RTE_CRYPTO_OP_STATUS_SUCCESS,
13168                         "authentication not failed");
13169         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13170                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13171                                 ut_params->op, 0, 1, 0, 0);
13172         else {
13173                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13174                         ut_params->op);
13175                 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
13176         }
13177
13178         return 0;
13179 }
13180
13181 static int
13182 test_authenticated_decryption_fail_when_corruption(
13183                 struct crypto_testsuite_params *ts_params,
13184                 struct crypto_unittest_params *ut_params,
13185                 const struct test_crypto_vector *reference,
13186                 unsigned int data_corrupted)
13187 {
13188         int retval;
13189
13190         uint8_t *ciphertext;
13191         struct rte_cryptodev_info dev_info;
13192
13193         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13194         uint64_t feat_flags = dev_info.feature_flags;
13195
13196         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13197                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13198                 printf("Device doesn't support RAW data-path APIs.\n");
13199                 return TEST_SKIPPED;
13200         }
13201
13202         /* Verify the capabilities */
13203         struct rte_cryptodev_sym_capability_idx cap_idx;
13204         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13205         cap_idx.algo.auth = reference->auth_algo;
13206         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13207                         &cap_idx) == NULL)
13208                 return TEST_SKIPPED;
13209         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13210         cap_idx.algo.cipher = reference->crypto_algo;
13211         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13212                         &cap_idx) == NULL)
13213                 return TEST_SKIPPED;
13214
13215         /* Create session */
13216         retval = create_auth_cipher_session(ut_params,
13217                         ts_params->valid_devs[0],
13218                         reference,
13219                         RTE_CRYPTO_AUTH_OP_VERIFY,
13220                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
13221         if (retval < 0)
13222                 return retval;
13223
13224         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13225         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13226                         "Failed to allocate input buffer in mempool");
13227
13228         /* clear mbuf payload */
13229         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13230                         rte_pktmbuf_tailroom(ut_params->ibuf));
13231
13232         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13233                         reference->ciphertext.len);
13234         TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
13235         memcpy(ciphertext, reference->ciphertext.data,
13236                         reference->ciphertext.len);
13237
13238         /* Create operation */
13239         retval = create_cipher_auth_verify_operation(ts_params,
13240                         ut_params,
13241                         reference);
13242
13243         if (retval < 0)
13244                 return retval;
13245
13246         if (data_corrupted)
13247                 data_corruption(ciphertext);
13248         else
13249                 tag_corruption(ciphertext, reference->ciphertext.len);
13250
13251         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
13252                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13253                         ut_params->op);
13254                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
13255                         RTE_CRYPTO_OP_STATUS_SUCCESS,
13256                         "authentication not failed");
13257         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13258                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13259                                 ut_params->op, 1, 1, 0, 0);
13260         else {
13261                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13262                         ut_params->op);
13263                 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
13264         }
13265
13266         return 0;
13267 }
13268
13269 static int
13270 test_authenticated_encrypt_with_esn(
13271                 struct crypto_testsuite_params *ts_params,
13272                 struct crypto_unittest_params *ut_params,
13273                 const struct test_crypto_vector *reference)
13274 {
13275         int retval;
13276
13277         uint8_t *authciphertext, *plaintext, *auth_tag;
13278         uint16_t plaintext_pad_len;
13279         uint8_t cipher_key[reference->cipher_key.len + 1];
13280         uint8_t auth_key[reference->auth_key.len + 1];
13281         struct rte_cryptodev_info dev_info;
13282
13283         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13284         uint64_t feat_flags = dev_info.feature_flags;
13285
13286         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13287                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13288                 printf("Device doesn't support RAW data-path APIs.\n");
13289                 return TEST_SKIPPED;
13290         }
13291
13292         /* Verify the capabilities */
13293         struct rte_cryptodev_sym_capability_idx cap_idx;
13294         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13295         cap_idx.algo.auth = reference->auth_algo;
13296         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13297                         &cap_idx) == NULL)
13298                 return TEST_SKIPPED;
13299         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13300         cap_idx.algo.cipher = reference->crypto_algo;
13301         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13302                         &cap_idx) == NULL)
13303                 return TEST_SKIPPED;
13304
13305         /* Create session */
13306         memcpy(cipher_key, reference->cipher_key.data,
13307                         reference->cipher_key.len);
13308         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
13309
13310         /* Setup Cipher Parameters */
13311         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13312         ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
13313         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
13314         ut_params->cipher_xform.cipher.key.data = cipher_key;
13315         ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
13316         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
13317         ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
13318
13319         ut_params->cipher_xform.next = &ut_params->auth_xform;
13320
13321         /* Setup Authentication Parameters */
13322         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13323         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
13324         ut_params->auth_xform.auth.algo = reference->auth_algo;
13325         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
13326         ut_params->auth_xform.auth.key.data = auth_key;
13327         ut_params->auth_xform.auth.digest_length = reference->digest.len;
13328         ut_params->auth_xform.next = NULL;
13329
13330         /* Create Crypto session*/
13331         ut_params->sess = rte_cryptodev_sym_session_create(
13332                         ts_params->session_mpool);
13333
13334         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
13335                                 ut_params->sess,
13336                                 &ut_params->cipher_xform,
13337                                 ts_params->session_priv_mpool);
13338
13339         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
13340
13341         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13342         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13343                         "Failed to allocate input buffer in mempool");
13344
13345         /* clear mbuf payload */
13346         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13347                         rte_pktmbuf_tailroom(ut_params->ibuf));
13348
13349         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13350                         reference->plaintext.len);
13351         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
13352         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
13353
13354         /* Create operation */
13355         retval = create_cipher_auth_operation(ts_params,
13356                         ut_params,
13357                         reference, 0);
13358
13359         if (retval < 0)
13360                 return retval;
13361
13362         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13363                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13364                         ut_params->op);
13365         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13366                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13367                                 ut_params->op, 1, 1, 0, 0);
13368         else
13369                 ut_params->op = process_crypto_request(
13370                         ts_params->valid_devs[0], ut_params->op);
13371
13372         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
13373
13374         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
13375                         "crypto op processing failed");
13376
13377         plaintext_pad_len = RTE_ALIGN_CEIL(reference->plaintext.len, 16);
13378
13379         authciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
13380                         ut_params->op->sym->auth.data.offset);
13381         auth_tag = authciphertext + plaintext_pad_len;
13382         debug_hexdump(stdout, "ciphertext:", authciphertext,
13383                         reference->ciphertext.len);
13384         debug_hexdump(stdout, "auth tag:", auth_tag, reference->digest.len);
13385
13386         /* Validate obuf */
13387         TEST_ASSERT_BUFFERS_ARE_EQUAL(
13388                         authciphertext,
13389                         reference->ciphertext.data,
13390                         reference->ciphertext.len,
13391                         "Ciphertext data not as expected");
13392
13393         TEST_ASSERT_BUFFERS_ARE_EQUAL(
13394                         auth_tag,
13395                         reference->digest.data,
13396                         reference->digest.len,
13397                         "Generated digest not as expected");
13398
13399         return TEST_SUCCESS;
13400
13401 }
13402
13403 static int
13404 test_authenticated_decrypt_with_esn(
13405                 struct crypto_testsuite_params *ts_params,
13406                 struct crypto_unittest_params *ut_params,
13407                 const struct test_crypto_vector *reference)
13408 {
13409         int retval;
13410
13411         uint8_t *ciphertext;
13412         uint8_t cipher_key[reference->cipher_key.len + 1];
13413         uint8_t auth_key[reference->auth_key.len + 1];
13414         struct rte_cryptodev_info dev_info;
13415
13416         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13417         uint64_t feat_flags = dev_info.feature_flags;
13418
13419         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13420                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13421                 printf("Device doesn't support RAW data-path APIs.\n");
13422                 return TEST_SKIPPED;
13423         }
13424
13425         /* Verify the capabilities */
13426         struct rte_cryptodev_sym_capability_idx cap_idx;
13427         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13428         cap_idx.algo.auth = reference->auth_algo;
13429         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13430                         &cap_idx) == NULL)
13431                 return TEST_SKIPPED;
13432         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13433         cap_idx.algo.cipher = reference->crypto_algo;
13434         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13435                         &cap_idx) == NULL)
13436                 return TEST_SKIPPED;
13437
13438         /* Create session */
13439         memcpy(cipher_key, reference->cipher_key.data,
13440                         reference->cipher_key.len);
13441         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
13442
13443         /* Setup Authentication Parameters */
13444         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13445         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
13446         ut_params->auth_xform.auth.algo = reference->auth_algo;
13447         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
13448         ut_params->auth_xform.auth.key.data = auth_key;
13449         ut_params->auth_xform.auth.digest_length = reference->digest.len;
13450         ut_params->auth_xform.next = &ut_params->cipher_xform;
13451
13452         /* Setup Cipher Parameters */
13453         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13454         ut_params->cipher_xform.next = NULL;
13455         ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
13456         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
13457         ut_params->cipher_xform.cipher.key.data = cipher_key;
13458         ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
13459         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
13460         ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
13461
13462         /* Create Crypto session*/
13463         ut_params->sess = rte_cryptodev_sym_session_create(
13464                         ts_params->session_mpool);
13465
13466         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
13467                                 ut_params->sess,
13468                                 &ut_params->auth_xform,
13469                                 ts_params->session_priv_mpool);
13470
13471         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
13472
13473         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13474         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13475                         "Failed to allocate input buffer in mempool");
13476
13477         /* clear mbuf payload */
13478         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13479                         rte_pktmbuf_tailroom(ut_params->ibuf));
13480
13481         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13482                         reference->ciphertext.len);
13483         TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
13484         memcpy(ciphertext, reference->ciphertext.data,
13485                         reference->ciphertext.len);
13486
13487         /* Create operation */
13488         retval = create_cipher_auth_verify_operation(ts_params,
13489                         ut_params,
13490                         reference);
13491
13492         if (retval < 0)
13493                 return retval;
13494
13495         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13496                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13497                         ut_params->op);
13498         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13499                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13500                                 ut_params->op, 1, 1, 0, 0);
13501         else
13502                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13503                         ut_params->op);
13504
13505         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
13506         TEST_ASSERT_EQUAL(ut_params->op->status,
13507                         RTE_CRYPTO_OP_STATUS_SUCCESS,
13508                         "crypto op processing passed");
13509
13510         ut_params->obuf = ut_params->op->sym->m_src;
13511         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
13512
13513         return 0;
13514 }
13515
13516 static int
13517 create_aead_operation_SGL(enum rte_crypto_aead_operation op,
13518                 const struct aead_test_data *tdata,
13519                 void *digest_mem, uint64_t digest_phys)
13520 {
13521         struct crypto_testsuite_params *ts_params = &testsuite_params;
13522         struct crypto_unittest_params *ut_params = &unittest_params;
13523
13524         const unsigned int auth_tag_len = tdata->auth_tag.len;
13525         const unsigned int iv_len = tdata->iv.len;
13526         unsigned int aad_len = tdata->aad.len;
13527         unsigned int aad_len_pad = 0;
13528
13529         /* Generate Crypto op data structure */
13530         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
13531                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
13532         TEST_ASSERT_NOT_NULL(ut_params->op,
13533                 "Failed to allocate symmetric crypto operation struct");
13534
13535         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
13536
13537         sym_op->aead.digest.data = digest_mem;
13538
13539         TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
13540                         "no room to append digest");
13541
13542         sym_op->aead.digest.phys_addr = digest_phys;
13543
13544         if (op == RTE_CRYPTO_AEAD_OP_DECRYPT) {
13545                 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
13546                                 auth_tag_len);
13547                 debug_hexdump(stdout, "digest:",
13548                                 sym_op->aead.digest.data,
13549                                 auth_tag_len);
13550         }
13551
13552         /* Append aad data */
13553         if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
13554                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
13555                                 uint8_t *, IV_OFFSET);
13556
13557                 /* Copy IV 1 byte after the IV pointer, according to the API */
13558                 rte_memcpy(iv_ptr + 1, tdata->iv.data, iv_len);
13559
13560                 aad_len = RTE_ALIGN_CEIL(aad_len + 18, 16);
13561
13562                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
13563                                 ut_params->ibuf, aad_len);
13564                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
13565                                 "no room to prepend aad");
13566                 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
13567                                 ut_params->ibuf);
13568
13569                 memset(sym_op->aead.aad.data, 0, aad_len);
13570                 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
13571                 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
13572
13573                 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
13574                 debug_hexdump(stdout, "aad:",
13575                                 sym_op->aead.aad.data, aad_len);
13576         } else {
13577                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
13578                                 uint8_t *, IV_OFFSET);
13579
13580                 rte_memcpy(iv_ptr, tdata->iv.data, iv_len);
13581
13582                 aad_len_pad = RTE_ALIGN_CEIL(aad_len, 16);
13583
13584                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
13585                                 ut_params->ibuf, aad_len_pad);
13586                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
13587                                 "no room to prepend aad");
13588                 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
13589                                 ut_params->ibuf);
13590
13591                 memset(sym_op->aead.aad.data, 0, aad_len);
13592                 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
13593
13594                 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
13595                 debug_hexdump(stdout, "aad:",
13596                                 sym_op->aead.aad.data, aad_len);
13597         }
13598
13599         sym_op->aead.data.length = tdata->plaintext.len;
13600         sym_op->aead.data.offset = aad_len_pad;
13601
13602         return 0;
13603 }
13604
13605 #define SGL_MAX_NO      16
13606
13607 static int
13608 test_authenticated_encryption_SGL(const struct aead_test_data *tdata,
13609                 const int oop, uint32_t fragsz, uint32_t fragsz_oop)
13610 {
13611         struct crypto_testsuite_params *ts_params = &testsuite_params;
13612         struct crypto_unittest_params *ut_params = &unittest_params;
13613         struct rte_mbuf *buf, *buf_oop = NULL, *buf_last_oop = NULL;
13614         int retval;
13615         int to_trn = 0;
13616         int to_trn_tbl[SGL_MAX_NO];
13617         int segs = 1;
13618         unsigned int trn_data = 0;
13619         uint8_t *plaintext, *ciphertext, *auth_tag;
13620         struct rte_cryptodev_info dev_info;
13621
13622         /* Verify the capabilities */
13623         struct rte_cryptodev_sym_capability_idx cap_idx;
13624         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
13625         cap_idx.algo.aead = tdata->algo;
13626         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13627                         &cap_idx) == NULL)
13628                 return TEST_SKIPPED;
13629
13630         /* OOP not supported with CPU crypto */
13631         if (oop && gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13632                 return TEST_SKIPPED;
13633
13634         /* Detailed check for the particular SGL support flag */
13635         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13636         if (!oop) {
13637                 unsigned int sgl_in = fragsz < tdata->plaintext.len;
13638                 if (sgl_in && (!(dev_info.feature_flags &
13639                                 RTE_CRYPTODEV_FF_IN_PLACE_SGL)))
13640                         return TEST_SKIPPED;
13641
13642                 uint64_t feat_flags = dev_info.feature_flags;
13643
13644                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13645                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13646                         printf("Device doesn't support RAW data-path APIs.\n");
13647                         return TEST_SKIPPED;
13648                 }
13649         } else {
13650                 unsigned int sgl_in = fragsz < tdata->plaintext.len;
13651                 unsigned int sgl_out = (fragsz_oop ? fragsz_oop : fragsz) <
13652                                 tdata->plaintext.len;
13653                 /* Raw data path API does not support OOP */
13654                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13655                         return TEST_SKIPPED;
13656                 if (sgl_in && !sgl_out) {
13657                         if (!(dev_info.feature_flags &
13658                                         RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT))
13659                                 return TEST_SKIPPED;
13660                 } else if (!sgl_in && sgl_out) {
13661                         if (!(dev_info.feature_flags &
13662                                         RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT))
13663                                 return TEST_SKIPPED;
13664                 } else if (sgl_in && sgl_out) {
13665                         if (!(dev_info.feature_flags &
13666                                         RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT))
13667                                 return TEST_SKIPPED;
13668                 }
13669         }
13670
13671         if (fragsz > tdata->plaintext.len)
13672                 fragsz = tdata->plaintext.len;
13673
13674         uint16_t plaintext_len = fragsz;
13675         uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
13676
13677         if (fragsz_oop > tdata->plaintext.len)
13678                 frag_size_oop = tdata->plaintext.len;
13679
13680         int ecx = 0;
13681         void *digest_mem = NULL;
13682
13683         uint32_t prepend_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
13684
13685         if (tdata->plaintext.len % fragsz != 0) {
13686                 if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO)
13687                         return 1;
13688         }       else {
13689                 if (tdata->plaintext.len / fragsz > SGL_MAX_NO)
13690                         return 1;
13691         }
13692
13693         /*
13694          * For out-op-place we need to alloc another mbuf
13695          */
13696         if (oop) {
13697                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13698                 rte_pktmbuf_append(ut_params->obuf,
13699                                 frag_size_oop + prepend_len);
13700                 buf_oop = ut_params->obuf;
13701         }
13702
13703         /* Create AEAD session */
13704         retval = create_aead_session(ts_params->valid_devs[0],
13705                         tdata->algo,
13706                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
13707                         tdata->key.data, tdata->key.len,
13708                         tdata->aad.len, tdata->auth_tag.len,
13709                         tdata->iv.len);
13710         if (retval < 0)
13711                 return retval;
13712
13713         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13714
13715         /* clear mbuf payload */
13716         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13717                         rte_pktmbuf_tailroom(ut_params->ibuf));
13718
13719         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13720                         plaintext_len);
13721
13722         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
13723
13724         trn_data += plaintext_len;
13725
13726         buf = ut_params->ibuf;
13727
13728         /*
13729          * Loop until no more fragments
13730          */
13731
13732         while (trn_data < tdata->plaintext.len) {
13733                 ++segs;
13734                 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
13735                                 (tdata->plaintext.len - trn_data) : fragsz;
13736
13737                 to_trn_tbl[ecx++] = to_trn;
13738
13739                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13740                 buf = buf->next;
13741
13742                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
13743                                 rte_pktmbuf_tailroom(buf));
13744
13745                 /* OOP */
13746                 if (oop && !fragsz_oop) {
13747                         buf_last_oop = buf_oop->next =
13748                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
13749                         buf_oop = buf_oop->next;
13750                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
13751                                         0, rte_pktmbuf_tailroom(buf_oop));
13752                         rte_pktmbuf_append(buf_oop, to_trn);
13753                 }
13754
13755                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
13756                                 to_trn);
13757
13758                 memcpy(plaintext, tdata->plaintext.data + trn_data,
13759                                 to_trn);
13760                 trn_data += to_trn;
13761                 if (trn_data  == tdata->plaintext.len) {
13762                         if (oop) {
13763                                 if (!fragsz_oop)
13764                                         digest_mem = rte_pktmbuf_append(buf_oop,
13765                                                 tdata->auth_tag.len);
13766                         } else
13767                                 digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
13768                                         tdata->auth_tag.len);
13769                 }
13770         }
13771
13772         uint64_t digest_phys = 0;
13773
13774         ut_params->ibuf->nb_segs = segs;
13775
13776         segs = 1;
13777         if (fragsz_oop && oop) {
13778                 to_trn = 0;
13779                 ecx = 0;
13780
13781                 if (frag_size_oop == tdata->plaintext.len) {
13782                         digest_mem = rte_pktmbuf_append(ut_params->obuf,
13783                                 tdata->auth_tag.len);
13784
13785                         digest_phys = rte_pktmbuf_iova_offset(
13786                                         ut_params->obuf,
13787                                         tdata->plaintext.len + prepend_len);
13788                 }
13789
13790                 trn_data = frag_size_oop;
13791                 while (trn_data < tdata->plaintext.len) {
13792                         ++segs;
13793                         to_trn =
13794                                 (tdata->plaintext.len - trn_data <
13795                                                 frag_size_oop) ?
13796                                 (tdata->plaintext.len - trn_data) :
13797                                                 frag_size_oop;
13798
13799                         to_trn_tbl[ecx++] = to_trn;
13800
13801                         buf_last_oop = buf_oop->next =
13802                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
13803                         buf_oop = buf_oop->next;
13804                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
13805                                         0, rte_pktmbuf_tailroom(buf_oop));
13806                         rte_pktmbuf_append(buf_oop, to_trn);
13807
13808                         trn_data += to_trn;
13809
13810                         if (trn_data  == tdata->plaintext.len) {
13811                                 digest_mem = rte_pktmbuf_append(buf_oop,
13812                                         tdata->auth_tag.len);
13813                         }
13814                 }
13815
13816                 ut_params->obuf->nb_segs = segs;
13817         }
13818
13819         /*
13820          * Place digest at the end of the last buffer
13821          */
13822         if (!digest_phys)
13823                 digest_phys = rte_pktmbuf_iova(buf) + to_trn;
13824         if (oop && buf_last_oop)
13825                 digest_phys = rte_pktmbuf_iova(buf_last_oop) + to_trn;
13826
13827         if (!digest_mem && !oop) {
13828                 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13829                                 + tdata->auth_tag.len);
13830                 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
13831                                 tdata->plaintext.len);
13832         }
13833
13834         /* Create AEAD operation */
13835         retval = create_aead_operation_SGL(RTE_CRYPTO_AEAD_OP_ENCRYPT,
13836                         tdata, digest_mem, digest_phys);
13837
13838         if (retval < 0)
13839                 return retval;
13840
13841         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
13842
13843         ut_params->op->sym->m_src = ut_params->ibuf;
13844         if (oop)
13845                 ut_params->op->sym->m_dst = ut_params->obuf;
13846
13847         /* Process crypto operation */
13848         if (oop == IN_PLACE &&
13849                         gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13850                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
13851         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13852                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13853                                 ut_params->op, 0, 0, 0, 0);
13854         else
13855                 TEST_ASSERT_NOT_NULL(
13856                         process_crypto_request(ts_params->valid_devs[0],
13857                         ut_params->op), "failed to process sym crypto op");
13858
13859         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
13860                         "crypto op processing failed");
13861
13862
13863         ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
13864                         uint8_t *, prepend_len);
13865         if (oop) {
13866                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
13867                                 uint8_t *, prepend_len);
13868         }
13869
13870         if (fragsz_oop)
13871                 fragsz = fragsz_oop;
13872
13873         TEST_ASSERT_BUFFERS_ARE_EQUAL(
13874                         ciphertext,
13875                         tdata->ciphertext.data,
13876                         fragsz,
13877                         "Ciphertext data not as expected");
13878
13879         buf = ut_params->op->sym->m_src->next;
13880         if (oop)
13881                 buf = ut_params->op->sym->m_dst->next;
13882
13883         unsigned int off = fragsz;
13884
13885         ecx = 0;
13886         while (buf) {
13887                 ciphertext = rte_pktmbuf_mtod(buf,
13888                                 uint8_t *);
13889
13890                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
13891                                 ciphertext,
13892                                 tdata->ciphertext.data + off,
13893                                 to_trn_tbl[ecx],
13894                                 "Ciphertext data not as expected");
13895
13896                 off += to_trn_tbl[ecx++];
13897                 buf = buf->next;
13898         }
13899
13900         auth_tag = digest_mem;
13901         TEST_ASSERT_BUFFERS_ARE_EQUAL(
13902                         auth_tag,
13903                         tdata->auth_tag.data,
13904                         tdata->auth_tag.len,
13905                         "Generated auth tag not as expected");
13906
13907         return 0;
13908 }
13909
13910 static int
13911 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void)
13912 {
13913         return test_authenticated_encryption_SGL(
13914                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 400, 400);
13915 }
13916
13917 static int
13918 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B(void)
13919 {
13920         return test_authenticated_encryption_SGL(
13921                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 1500, 2000);
13922 }
13923
13924 static int
13925 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void)
13926 {
13927         return test_authenticated_encryption_SGL(
13928                         &gcm_test_case_8, OUT_OF_PLACE, 400,
13929                         gcm_test_case_8.plaintext.len);
13930 }
13931
13932 static int
13933 test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void)
13934 {
13935         /* This test is not for OPENSSL PMD */
13936         if (gbl_driver_id == rte_cryptodev_driver_id_get(
13937                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)))
13938                 return TEST_SKIPPED;
13939
13940         return test_authenticated_encryption_SGL(
13941                         &gcm_test_case_SGL_1, IN_PLACE, 1500, 0);
13942 }
13943
13944 static int
13945 test_authentication_verify_fail_when_data_corrupted(
13946                 struct crypto_testsuite_params *ts_params,
13947                 struct crypto_unittest_params *ut_params,
13948                 const struct test_crypto_vector *reference)
13949 {
13950         return test_authentication_verify_fail_when_data_corruption(
13951                         ts_params, ut_params, reference, 1);
13952 }
13953
13954 static int
13955 test_authentication_verify_fail_when_tag_corrupted(
13956                 struct crypto_testsuite_params *ts_params,
13957                 struct crypto_unittest_params *ut_params,
13958                 const struct test_crypto_vector *reference)
13959 {
13960         return test_authentication_verify_fail_when_data_corruption(
13961                         ts_params, ut_params, reference, 0);
13962 }
13963
13964 static int
13965 test_authentication_verify_GMAC_fail_when_data_corrupted(
13966                 struct crypto_testsuite_params *ts_params,
13967                 struct crypto_unittest_params *ut_params,
13968                 const struct test_crypto_vector *reference)
13969 {
13970         return test_authentication_verify_GMAC_fail_when_corruption(
13971                         ts_params, ut_params, reference, 1);
13972 }
13973
13974 static int
13975 test_authentication_verify_GMAC_fail_when_tag_corrupted(
13976                 struct crypto_testsuite_params *ts_params,
13977                 struct crypto_unittest_params *ut_params,
13978                 const struct test_crypto_vector *reference)
13979 {
13980         return test_authentication_verify_GMAC_fail_when_corruption(
13981                         ts_params, ut_params, reference, 0);
13982 }
13983
13984 static int
13985 test_authenticated_decryption_fail_when_data_corrupted(
13986                 struct crypto_testsuite_params *ts_params,
13987                 struct crypto_unittest_params *ut_params,
13988                 const struct test_crypto_vector *reference)
13989 {
13990         return test_authenticated_decryption_fail_when_corruption(
13991                         ts_params, ut_params, reference, 1);
13992 }
13993
13994 static int
13995 test_authenticated_decryption_fail_when_tag_corrupted(
13996                 struct crypto_testsuite_params *ts_params,
13997                 struct crypto_unittest_params *ut_params,
13998                 const struct test_crypto_vector *reference)
13999 {
14000         return test_authenticated_decryption_fail_when_corruption(
14001                         ts_params, ut_params, reference, 0);
14002 }
14003
14004 static int
14005 authentication_verify_HMAC_SHA1_fail_data_corrupt(void)
14006 {
14007         return test_authentication_verify_fail_when_data_corrupted(
14008                         &testsuite_params, &unittest_params,
14009                         &hmac_sha1_test_crypto_vector);
14010 }
14011
14012 static int
14013 authentication_verify_HMAC_SHA1_fail_tag_corrupt(void)
14014 {
14015         return test_authentication_verify_fail_when_tag_corrupted(
14016                         &testsuite_params, &unittest_params,
14017                         &hmac_sha1_test_crypto_vector);
14018 }
14019
14020 static int
14021 authentication_verify_AES128_GMAC_fail_data_corrupt(void)
14022 {
14023         return test_authentication_verify_GMAC_fail_when_data_corrupted(
14024                         &testsuite_params, &unittest_params,
14025                         &aes128_gmac_test_vector);
14026 }
14027
14028 static int
14029 authentication_verify_AES128_GMAC_fail_tag_corrupt(void)
14030 {
14031         return test_authentication_verify_GMAC_fail_when_tag_corrupted(
14032                         &testsuite_params, &unittest_params,
14033                         &aes128_gmac_test_vector);
14034 }
14035
14036 static int
14037 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void)
14038 {
14039         return test_authenticated_decryption_fail_when_data_corrupted(
14040                         &testsuite_params,
14041                         &unittest_params,
14042                         &aes128cbc_hmac_sha1_test_vector);
14043 }
14044
14045 static int
14046 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void)
14047 {
14048         return test_authenticated_decryption_fail_when_tag_corrupted(
14049                         &testsuite_params,
14050                         &unittest_params,
14051                         &aes128cbc_hmac_sha1_test_vector);
14052 }
14053
14054 static int
14055 auth_encrypt_AES128CBC_HMAC_SHA1_esn_check(void)
14056 {
14057         return test_authenticated_encrypt_with_esn(
14058                         &testsuite_params,
14059                         &unittest_params,
14060                         &aes128cbc_hmac_sha1_aad_test_vector);
14061 }
14062
14063 static int
14064 auth_decrypt_AES128CBC_HMAC_SHA1_esn_check(void)
14065 {
14066         return test_authenticated_decrypt_with_esn(
14067                         &testsuite_params,
14068                         &unittest_params,
14069                         &aes128cbc_hmac_sha1_aad_test_vector);
14070 }
14071
14072 static int
14073 test_chacha20_poly1305_encrypt_test_case_rfc8439(void)
14074 {
14075         return test_authenticated_encryption(&chacha20_poly1305_case_rfc8439);
14076 }
14077
14078 static int
14079 test_chacha20_poly1305_decrypt_test_case_rfc8439(void)
14080 {
14081         return test_authenticated_decryption(&chacha20_poly1305_case_rfc8439);
14082 }
14083
14084 #ifdef RTE_CRYPTO_SCHEDULER
14085
14086 /* global AESNI worker IDs for the scheduler test */
14087 uint8_t aesni_ids[2];
14088
14089 static int
14090 scheduler_testsuite_setup(void)
14091 {
14092         uint32_t i = 0;
14093         int32_t nb_devs, ret;
14094         char vdev_args[VDEV_ARGS_SIZE] = {""};
14095         char temp_str[VDEV_ARGS_SIZE] = {"mode=multi-core,"
14096                 "ordering=enable,name=cryptodev_test_scheduler,corelist="};
14097         uint16_t worker_core_count = 0;
14098         uint16_t socket_id = 0;
14099
14100         if (gbl_driver_id == rte_cryptodev_driver_id_get(
14101                         RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD))) {
14102
14103                 /* Identify the Worker Cores
14104                  * Use 2 worker cores for the device args
14105                  */
14106                 RTE_LCORE_FOREACH_WORKER(i) {
14107                         if (worker_core_count > 1)
14108                                 break;
14109                         snprintf(vdev_args, sizeof(vdev_args),
14110                                         "%s%d", temp_str, i);
14111                         strcpy(temp_str, vdev_args);
14112                         strlcat(temp_str, ";", sizeof(temp_str));
14113                         worker_core_count++;
14114                         socket_id = rte_lcore_to_socket_id(i);
14115                 }
14116                 if (worker_core_count != 2) {
14117                         RTE_LOG(ERR, USER1,
14118                                 "Cryptodev scheduler test require at least "
14119                                 "two worker cores to run. "
14120                                 "Please use the correct coremask.\n");
14121                         return TEST_FAILED;
14122                 }
14123                 strcpy(temp_str, vdev_args);
14124                 snprintf(vdev_args, sizeof(vdev_args), "%s,socket_id=%d",
14125                                 temp_str, socket_id);
14126                 RTE_LOG(DEBUG, USER1, "vdev_args: %s\n", vdev_args);
14127                 nb_devs = rte_cryptodev_device_count_by_driver(
14128                                 rte_cryptodev_driver_id_get(
14129                                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)));
14130                 if (nb_devs < 1) {
14131                         ret = rte_vdev_init(
14132                                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),
14133                                         vdev_args);
14134                         TEST_ASSERT(ret == 0,
14135                                 "Failed to create instance %u of pmd : %s",
14136                                 i, RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
14137                 }
14138         }
14139         return testsuite_setup();
14140 }
14141
14142 static int
14143 test_scheduler_attach_worker_op(void)
14144 {
14145         struct crypto_testsuite_params *ts_params = &testsuite_params;
14146         uint8_t sched_id = ts_params->valid_devs[0];
14147         uint32_t i, nb_devs_attached = 0;
14148         int ret;
14149         char vdev_name[32];
14150         unsigned int count = rte_cryptodev_count();
14151
14152         /* create 2 AESNI_MB vdevs on top of existing devices */
14153         for (i = count; i < count + 2; i++) {
14154                 snprintf(vdev_name, sizeof(vdev_name), "%s_%u",
14155                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD),
14156                                 i);
14157                 ret = rte_vdev_init(vdev_name, NULL);
14158
14159                 TEST_ASSERT(ret == 0,
14160                         "Failed to create instance %u of"
14161                         " pmd : %s",
14162                         i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
14163
14164                 if (ret < 0) {
14165                         RTE_LOG(ERR, USER1,
14166                                 "Failed to create 2 AESNI MB PMDs.\n");
14167                         return TEST_SKIPPED;
14168                 }
14169         }
14170
14171         /* attach 2 AESNI_MB cdevs */
14172         for (i = count; i < count + 2; i++) {
14173                 struct rte_cryptodev_info info;
14174                 unsigned int session_size;
14175
14176                 rte_cryptodev_info_get(i, &info);
14177                 if (info.driver_id != rte_cryptodev_driver_id_get(
14178                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)))
14179                         continue;
14180
14181                 session_size = rte_cryptodev_sym_get_private_session_size(i);
14182                 /*
14183                  * Create the session mempool again, since now there are new devices
14184                  * to use the mempool.
14185                  */
14186                 if (ts_params->session_mpool) {
14187                         rte_mempool_free(ts_params->session_mpool);
14188                         ts_params->session_mpool = NULL;
14189                 }
14190                 if (ts_params->session_priv_mpool) {
14191                         rte_mempool_free(ts_params->session_priv_mpool);
14192                         ts_params->session_priv_mpool = NULL;
14193                 }
14194
14195                 if (info.sym.max_nb_sessions != 0 &&
14196                                 info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
14197                         RTE_LOG(ERR, USER1,
14198                                         "Device does not support "
14199                                         "at least %u sessions\n",
14200                                         MAX_NB_SESSIONS);
14201                         return TEST_FAILED;
14202                 }
14203                 /*
14204                  * Create mempool with maximum number of sessions,
14205                  * to include the session headers
14206                  */
14207                 if (ts_params->session_mpool == NULL) {
14208                         ts_params->session_mpool =
14209                                 rte_cryptodev_sym_session_pool_create(
14210                                                 "test_sess_mp",
14211                                                 MAX_NB_SESSIONS, 0, 0, 0,
14212                                                 SOCKET_ID_ANY);
14213                         TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
14214                                         "session mempool allocation failed");
14215                 }
14216
14217                 /*
14218                  * Create mempool with maximum number of sessions,
14219                  * to include device specific session private data
14220                  */
14221                 if (ts_params->session_priv_mpool == NULL) {
14222                         ts_params->session_priv_mpool = rte_mempool_create(
14223                                         "test_sess_mp_priv",
14224                                         MAX_NB_SESSIONS,
14225                                         session_size,
14226                                         0, 0, NULL, NULL, NULL,
14227                                         NULL, SOCKET_ID_ANY,
14228                                         0);
14229
14230                         TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
14231                                         "session mempool allocation failed");
14232                 }
14233
14234                 ts_params->qp_conf.mp_session = ts_params->session_mpool;
14235                 ts_params->qp_conf.mp_session_private =
14236                                 ts_params->session_priv_mpool;
14237
14238                 ret = rte_cryptodev_scheduler_worker_attach(sched_id,
14239                                 (uint8_t)i);
14240
14241                 TEST_ASSERT(ret == 0,
14242                         "Failed to attach device %u of pmd : %s", i,
14243                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
14244
14245                 aesni_ids[nb_devs_attached] = (uint8_t)i;
14246
14247                 nb_devs_attached++;
14248         }
14249
14250         return 0;
14251 }
14252
14253 static int
14254 test_scheduler_detach_worker_op(void)
14255 {
14256         struct crypto_testsuite_params *ts_params = &testsuite_params;
14257         uint8_t sched_id = ts_params->valid_devs[0];
14258         uint32_t i;
14259         int ret;
14260
14261         for (i = 0; i < 2; i++) {
14262                 ret = rte_cryptodev_scheduler_worker_detach(sched_id,
14263                                 aesni_ids[i]);
14264                 TEST_ASSERT(ret == 0,
14265                         "Failed to detach device %u", aesni_ids[i]);
14266         }
14267
14268         return 0;
14269 }
14270
14271 static int
14272 test_scheduler_mode_op(enum rte_cryptodev_scheduler_mode scheduler_mode)
14273 {
14274         struct crypto_testsuite_params *ts_params = &testsuite_params;
14275         uint8_t sched_id = ts_params->valid_devs[0];
14276         /* set mode */
14277         return rte_cryptodev_scheduler_mode_set(sched_id,
14278                 scheduler_mode);
14279 }
14280
14281 static int
14282 test_scheduler_mode_roundrobin_op(void)
14283 {
14284         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) ==
14285                         0, "Failed to set roundrobin mode");
14286         return 0;
14287
14288 }
14289
14290 static int
14291 test_scheduler_mode_multicore_op(void)
14292 {
14293         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) ==
14294                         0, "Failed to set multicore mode");
14295
14296         return 0;
14297 }
14298
14299 static int
14300 test_scheduler_mode_failover_op(void)
14301 {
14302         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) ==
14303                         0, "Failed to set failover mode");
14304
14305         return 0;
14306 }
14307
14308 static int
14309 test_scheduler_mode_pkt_size_distr_op(void)
14310 {
14311         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) ==
14312                         0, "Failed to set pktsize mode");
14313
14314         return 0;
14315 }
14316
14317 static int
14318 scheduler_multicore_testsuite_setup(void)
14319 {
14320         if (test_scheduler_attach_worker_op() < 0)
14321                 return TEST_SKIPPED;
14322         if (test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) < 0)
14323                 return TEST_SKIPPED;
14324         return 0;
14325 }
14326
14327 static int
14328 scheduler_roundrobin_testsuite_setup(void)
14329 {
14330         if (test_scheduler_attach_worker_op() < 0)
14331                 return TEST_SKIPPED;
14332         if (test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) < 0)
14333                 return TEST_SKIPPED;
14334         return 0;
14335 }
14336
14337 static int
14338 scheduler_failover_testsuite_setup(void)
14339 {
14340         if (test_scheduler_attach_worker_op() < 0)
14341                 return TEST_SKIPPED;
14342         if (test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) < 0)
14343                 return TEST_SKIPPED;
14344         return 0;
14345 }
14346
14347 static int
14348 scheduler_pkt_size_distr_testsuite_setup(void)
14349 {
14350         if (test_scheduler_attach_worker_op() < 0)
14351                 return TEST_SKIPPED;
14352         if (test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) < 0)
14353                 return TEST_SKIPPED;
14354         return 0;
14355 }
14356
14357 static void
14358 scheduler_mode_testsuite_teardown(void)
14359 {
14360         test_scheduler_detach_worker_op();
14361 }
14362
14363 #endif /* RTE_CRYPTO_SCHEDULER */
14364
14365 static struct unit_test_suite end_testsuite = {
14366         .suite_name = NULL,
14367         .setup = NULL,
14368         .teardown = NULL,
14369         .unit_test_suites = NULL
14370 };
14371
14372 #ifdef RTE_LIB_SECURITY
14373 static struct unit_test_suite ipsec_proto_testsuite  = {
14374         .suite_name = "IPsec Proto Unit Test Suite",
14375         .setup = ipsec_proto_testsuite_setup,
14376         .unit_test_cases = {
14377                 TEST_CASE_NAMED_WITH_DATA(
14378                         "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 128)",
14379                         ut_setup_security, ut_teardown,
14380                         test_ipsec_proto_known_vec, &pkt_aes_128_gcm),
14381                 TEST_CASE_NAMED_WITH_DATA(
14382                         "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 192)",
14383                         ut_setup_security, ut_teardown,
14384                         test_ipsec_proto_known_vec, &pkt_aes_192_gcm),
14385                 TEST_CASE_NAMED_WITH_DATA(
14386                         "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 256)",
14387                         ut_setup_security, ut_teardown,
14388                         test_ipsec_proto_known_vec, &pkt_aes_256_gcm),
14389                 TEST_CASE_NAMED_WITH_DATA(
14390                         "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 128)",
14391                         ut_setup_security, ut_teardown,
14392                         test_ipsec_proto_known_vec_inb, &pkt_aes_128_gcm),
14393                 TEST_CASE_NAMED_WITH_DATA(
14394                         "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 192)",
14395                         ut_setup_security, ut_teardown,
14396                         test_ipsec_proto_known_vec_inb, &pkt_aes_192_gcm),
14397                 TEST_CASE_NAMED_WITH_DATA(
14398                         "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 256)",
14399                         ut_setup_security, ut_teardown,
14400                         test_ipsec_proto_known_vec_inb, &pkt_aes_256_gcm),
14401                 TEST_CASE_NAMED_ST(
14402                         "Combined test alg list",
14403                         ut_setup_security, ut_teardown,
14404                         test_ipsec_proto_display_list),
14405                 TEST_CASE_NAMED_ST(
14406                         "IV generation",
14407                         ut_setup_security, ut_teardown,
14408                         test_ipsec_proto_iv_gen),
14409                 TEST_CASE_NAMED_ST(
14410                         "UDP encapsulation",
14411                         ut_setup_security, ut_teardown,
14412                         test_ipsec_proto_udp_encap),
14413                 TEST_CASE_NAMED_ST(
14414                         "UDP encapsulation ports verification test",
14415                         ut_setup_security, ut_teardown,
14416                         test_ipsec_proto_udp_ports_verify),
14417                 TEST_CASE_NAMED_ST(
14418                         "SA expiry packets soft",
14419                         ut_setup_security, ut_teardown,
14420                         test_ipsec_proto_sa_exp_pkts_soft),
14421                 TEST_CASE_NAMED_ST(
14422                         "SA expiry packets hard",
14423                         ut_setup_security, ut_teardown,
14424                         test_ipsec_proto_sa_exp_pkts_hard),
14425                 TEST_CASE_NAMED_ST(
14426                         "Negative test: ICV corruption",
14427                         ut_setup_security, ut_teardown,
14428                         test_ipsec_proto_err_icv_corrupt),
14429                 TEST_CASE_NAMED_ST(
14430                         "Tunnel dst addr verification",
14431                         ut_setup_security, ut_teardown,
14432                         test_ipsec_proto_tunnel_dst_addr_verify),
14433                 TEST_CASE_NAMED_ST(
14434                         "Tunnel src and dst addr verification",
14435                         ut_setup_security, ut_teardown,
14436                         test_ipsec_proto_tunnel_src_dst_addr_verify),
14437                 TEST_CASE_NAMED_ST(
14438                         "Inner IP checksum",
14439                         ut_setup_security, ut_teardown,
14440                         test_ipsec_proto_inner_ip_csum),
14441                 TEST_CASE_NAMED_ST(
14442                         "Inner L4 checksum",
14443                         ut_setup_security, ut_teardown,
14444                         test_ipsec_proto_inner_l4_csum),
14445                 TEST_CASES_END() /**< NULL terminate unit test array */
14446         }
14447 };
14448
14449 static struct unit_test_suite pdcp_proto_testsuite  = {
14450         .suite_name = "PDCP Proto Unit Test Suite",
14451         .setup = pdcp_proto_testsuite_setup,
14452         .unit_test_cases = {
14453                 TEST_CASE_ST(ut_setup_security, ut_teardown,
14454                         test_PDCP_PROTO_all),
14455                 TEST_CASES_END() /**< NULL terminate unit test array */
14456         }
14457 };
14458
14459 static struct unit_test_suite docsis_proto_testsuite  = {
14460         .suite_name = "Docsis Proto Unit Test Suite",
14461         .setup = docsis_proto_testsuite_setup,
14462         .unit_test_cases = {
14463                 TEST_CASE_ST(ut_setup_security, ut_teardown,
14464                         test_DOCSIS_PROTO_all),
14465                 TEST_CASES_END() /**< NULL terminate unit test array */
14466         }
14467 };
14468 #endif
14469
14470 static struct unit_test_suite cryptodev_gen_testsuite  = {
14471         .suite_name = "Crypto General Unit Test Suite",
14472         .setup = crypto_gen_testsuite_setup,
14473         .unit_test_cases = {
14474                 TEST_CASE_ST(ut_setup, ut_teardown,
14475                                 test_device_configure_invalid_dev_id),
14476                 TEST_CASE_ST(ut_setup, ut_teardown,
14477                                 test_queue_pair_descriptor_setup),
14478                 TEST_CASE_ST(ut_setup, ut_teardown,
14479                                 test_device_configure_invalid_queue_pair_ids),
14480                 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
14481                 TEST_CASE_ST(ut_setup, ut_teardown, test_enq_callback_setup),
14482                 TEST_CASE_ST(ut_setup, ut_teardown, test_deq_callback_setup),
14483                 TEST_CASES_END() /**< NULL terminate unit test array */
14484         }
14485 };
14486
14487 static struct unit_test_suite cryptodev_negative_hmac_sha1_testsuite = {
14488         .suite_name = "Negative HMAC SHA1 Unit Test Suite",
14489         .setup = negative_hmac_sha1_testsuite_setup,
14490         .unit_test_cases = {
14491                 /** Negative tests */
14492                 TEST_CASE_ST(ut_setup, ut_teardown,
14493                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
14494                 TEST_CASE_ST(ut_setup, ut_teardown,
14495                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
14496                 TEST_CASE_ST(ut_setup, ut_teardown,
14497                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
14498                 TEST_CASE_ST(ut_setup, ut_teardown,
14499                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
14500
14501                 TEST_CASES_END() /**< NULL terminate unit test array */
14502         }
14503 };
14504
14505 static struct unit_test_suite cryptodev_multi_session_testsuite = {
14506         .suite_name = "Multi Session Unit Test Suite",
14507         .setup = multi_session_testsuite_setup,
14508         .unit_test_cases = {
14509                 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
14510                 TEST_CASE_ST(ut_setup, ut_teardown,
14511                                 test_multi_session_random_usage),
14512
14513                 TEST_CASES_END() /**< NULL terminate unit test array */
14514         }
14515 };
14516
14517 static struct unit_test_suite cryptodev_null_testsuite  = {
14518         .suite_name = "NULL Test Suite",
14519         .setup = null_testsuite_setup,
14520         .unit_test_cases = {
14521                 TEST_CASE_ST(ut_setup, ut_teardown,
14522                         test_null_invalid_operation),
14523                 TEST_CASE_ST(ut_setup, ut_teardown, test_null_burst_operation),
14524                 TEST_CASES_END()
14525         }
14526 };
14527
14528 static struct unit_test_suite cryptodev_aes_ccm_auth_testsuite  = {
14529         .suite_name = "AES CCM Authenticated Test Suite",
14530         .setup = aes_ccm_auth_testsuite_setup,
14531         .unit_test_cases = {
14532                 /** AES CCM Authenticated Encryption 128 bits key*/
14533                 TEST_CASE_ST(ut_setup, ut_teardown,
14534                         test_AES_CCM_authenticated_encryption_test_case_128_1),
14535                 TEST_CASE_ST(ut_setup, ut_teardown,
14536                         test_AES_CCM_authenticated_encryption_test_case_128_2),
14537                 TEST_CASE_ST(ut_setup, ut_teardown,
14538                         test_AES_CCM_authenticated_encryption_test_case_128_3),
14539
14540                 /** AES CCM Authenticated Decryption 128 bits key*/
14541                 TEST_CASE_ST(ut_setup, ut_teardown,
14542                         test_AES_CCM_authenticated_decryption_test_case_128_1),
14543                 TEST_CASE_ST(ut_setup, ut_teardown,
14544                         test_AES_CCM_authenticated_decryption_test_case_128_2),
14545                 TEST_CASE_ST(ut_setup, ut_teardown,
14546                         test_AES_CCM_authenticated_decryption_test_case_128_3),
14547
14548                 /** AES CCM Authenticated Encryption 192 bits key */
14549                 TEST_CASE_ST(ut_setup, ut_teardown,
14550                         test_AES_CCM_authenticated_encryption_test_case_192_1),
14551                 TEST_CASE_ST(ut_setup, ut_teardown,
14552                         test_AES_CCM_authenticated_encryption_test_case_192_2),
14553                 TEST_CASE_ST(ut_setup, ut_teardown,
14554                         test_AES_CCM_authenticated_encryption_test_case_192_3),
14555
14556                 /** AES CCM Authenticated Decryption 192 bits key*/
14557                 TEST_CASE_ST(ut_setup, ut_teardown,
14558                         test_AES_CCM_authenticated_decryption_test_case_192_1),
14559                 TEST_CASE_ST(ut_setup, ut_teardown,
14560                         test_AES_CCM_authenticated_decryption_test_case_192_2),
14561                 TEST_CASE_ST(ut_setup, ut_teardown,
14562                         test_AES_CCM_authenticated_decryption_test_case_192_3),
14563
14564                 /** AES CCM Authenticated Encryption 256 bits key */
14565                 TEST_CASE_ST(ut_setup, ut_teardown,
14566                         test_AES_CCM_authenticated_encryption_test_case_256_1),
14567                 TEST_CASE_ST(ut_setup, ut_teardown,
14568                         test_AES_CCM_authenticated_encryption_test_case_256_2),
14569                 TEST_CASE_ST(ut_setup, ut_teardown,
14570                         test_AES_CCM_authenticated_encryption_test_case_256_3),
14571
14572                 /** AES CCM Authenticated Decryption 256 bits key*/
14573                 TEST_CASE_ST(ut_setup, ut_teardown,
14574                         test_AES_CCM_authenticated_decryption_test_case_256_1),
14575                 TEST_CASE_ST(ut_setup, ut_teardown,
14576                         test_AES_CCM_authenticated_decryption_test_case_256_2),
14577                 TEST_CASE_ST(ut_setup, ut_teardown,
14578                         test_AES_CCM_authenticated_decryption_test_case_256_3),
14579                 TEST_CASES_END()
14580         }
14581 };
14582
14583 static struct unit_test_suite cryptodev_aes_gcm_auth_testsuite  = {
14584         .suite_name = "AES GCM Authenticated Test Suite",
14585         .setup = aes_gcm_auth_testsuite_setup,
14586         .unit_test_cases = {
14587                 /** AES GCM Authenticated Encryption */
14588                 TEST_CASE_ST(ut_setup, ut_teardown,
14589                         test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
14590                 TEST_CASE_ST(ut_setup, ut_teardown,
14591                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
14592                 TEST_CASE_ST(ut_setup, ut_teardown,
14593                         test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
14594                 TEST_CASE_ST(ut_setup, ut_teardown,
14595                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
14596                 TEST_CASE_ST(ut_setup, ut_teardown,
14597                         test_AES_GCM_authenticated_encryption_test_case_1),
14598                 TEST_CASE_ST(ut_setup, ut_teardown,
14599                         test_AES_GCM_authenticated_encryption_test_case_2),
14600                 TEST_CASE_ST(ut_setup, ut_teardown,
14601                         test_AES_GCM_authenticated_encryption_test_case_3),
14602                 TEST_CASE_ST(ut_setup, ut_teardown,
14603                         test_AES_GCM_authenticated_encryption_test_case_4),
14604                 TEST_CASE_ST(ut_setup, ut_teardown,
14605                         test_AES_GCM_authenticated_encryption_test_case_5),
14606                 TEST_CASE_ST(ut_setup, ut_teardown,
14607                         test_AES_GCM_authenticated_encryption_test_case_6),
14608                 TEST_CASE_ST(ut_setup, ut_teardown,
14609                         test_AES_GCM_authenticated_encryption_test_case_7),
14610                 TEST_CASE_ST(ut_setup, ut_teardown,
14611                         test_AES_GCM_authenticated_encryption_test_case_8),
14612                 TEST_CASE_ST(ut_setup, ut_teardown,
14613                         test_AES_GCM_J0_authenticated_encryption_test_case_1),
14614
14615                 /** AES GCM Authenticated Decryption */
14616                 TEST_CASE_ST(ut_setup, ut_teardown,
14617                         test_AES_GCM_authenticated_decryption_test_case_1),
14618                 TEST_CASE_ST(ut_setup, ut_teardown,
14619                         test_AES_GCM_authenticated_decryption_test_case_2),
14620                 TEST_CASE_ST(ut_setup, ut_teardown,
14621                         test_AES_GCM_authenticated_decryption_test_case_3),
14622                 TEST_CASE_ST(ut_setup, ut_teardown,
14623                         test_AES_GCM_authenticated_decryption_test_case_4),
14624                 TEST_CASE_ST(ut_setup, ut_teardown,
14625                         test_AES_GCM_authenticated_decryption_test_case_5),
14626                 TEST_CASE_ST(ut_setup, ut_teardown,
14627                         test_AES_GCM_authenticated_decryption_test_case_6),
14628                 TEST_CASE_ST(ut_setup, ut_teardown,
14629                         test_AES_GCM_authenticated_decryption_test_case_7),
14630                 TEST_CASE_ST(ut_setup, ut_teardown,
14631                         test_AES_GCM_authenticated_decryption_test_case_8),
14632                 TEST_CASE_ST(ut_setup, ut_teardown,
14633                         test_AES_GCM_J0_authenticated_decryption_test_case_1),
14634
14635                 /** AES GCM Authenticated Encryption 192 bits key */
14636                 TEST_CASE_ST(ut_setup, ut_teardown,
14637                         test_AES_GCM_auth_encryption_test_case_192_1),
14638                 TEST_CASE_ST(ut_setup, ut_teardown,
14639                         test_AES_GCM_auth_encryption_test_case_192_2),
14640                 TEST_CASE_ST(ut_setup, ut_teardown,
14641                         test_AES_GCM_auth_encryption_test_case_192_3),
14642                 TEST_CASE_ST(ut_setup, ut_teardown,
14643                         test_AES_GCM_auth_encryption_test_case_192_4),
14644                 TEST_CASE_ST(ut_setup, ut_teardown,
14645                         test_AES_GCM_auth_encryption_test_case_192_5),
14646                 TEST_CASE_ST(ut_setup, ut_teardown,
14647                         test_AES_GCM_auth_encryption_test_case_192_6),
14648                 TEST_CASE_ST(ut_setup, ut_teardown,
14649                         test_AES_GCM_auth_encryption_test_case_192_7),
14650
14651                 /** AES GCM Authenticated Decryption 192 bits key */
14652                 TEST_CASE_ST(ut_setup, ut_teardown,
14653                         test_AES_GCM_auth_decryption_test_case_192_1),
14654                 TEST_CASE_ST(ut_setup, ut_teardown,
14655                         test_AES_GCM_auth_decryption_test_case_192_2),
14656                 TEST_CASE_ST(ut_setup, ut_teardown,
14657                         test_AES_GCM_auth_decryption_test_case_192_3),
14658                 TEST_CASE_ST(ut_setup, ut_teardown,
14659                         test_AES_GCM_auth_decryption_test_case_192_4),
14660                 TEST_CASE_ST(ut_setup, ut_teardown,
14661                         test_AES_GCM_auth_decryption_test_case_192_5),
14662                 TEST_CASE_ST(ut_setup, ut_teardown,
14663                         test_AES_GCM_auth_decryption_test_case_192_6),
14664                 TEST_CASE_ST(ut_setup, ut_teardown,
14665                         test_AES_GCM_auth_decryption_test_case_192_7),
14666
14667                 /** AES GCM Authenticated Encryption 256 bits key */
14668                 TEST_CASE_ST(ut_setup, ut_teardown,
14669                         test_AES_GCM_auth_encryption_test_case_256_1),
14670                 TEST_CASE_ST(ut_setup, ut_teardown,
14671                         test_AES_GCM_auth_encryption_test_case_256_2),
14672                 TEST_CASE_ST(ut_setup, ut_teardown,
14673                         test_AES_GCM_auth_encryption_test_case_256_3),
14674                 TEST_CASE_ST(ut_setup, ut_teardown,
14675                         test_AES_GCM_auth_encryption_test_case_256_4),
14676                 TEST_CASE_ST(ut_setup, ut_teardown,
14677                         test_AES_GCM_auth_encryption_test_case_256_5),
14678                 TEST_CASE_ST(ut_setup, ut_teardown,
14679                         test_AES_GCM_auth_encryption_test_case_256_6),
14680                 TEST_CASE_ST(ut_setup, ut_teardown,
14681                         test_AES_GCM_auth_encryption_test_case_256_7),
14682
14683                 /** AES GCM Authenticated Decryption 256 bits key */
14684                 TEST_CASE_ST(ut_setup, ut_teardown,
14685                         test_AES_GCM_auth_decryption_test_case_256_1),
14686                 TEST_CASE_ST(ut_setup, ut_teardown,
14687                         test_AES_GCM_auth_decryption_test_case_256_2),
14688                 TEST_CASE_ST(ut_setup, ut_teardown,
14689                         test_AES_GCM_auth_decryption_test_case_256_3),
14690                 TEST_CASE_ST(ut_setup, ut_teardown,
14691                         test_AES_GCM_auth_decryption_test_case_256_4),
14692                 TEST_CASE_ST(ut_setup, ut_teardown,
14693                         test_AES_GCM_auth_decryption_test_case_256_5),
14694                 TEST_CASE_ST(ut_setup, ut_teardown,
14695                         test_AES_GCM_auth_decryption_test_case_256_6),
14696                 TEST_CASE_ST(ut_setup, ut_teardown,
14697                         test_AES_GCM_auth_decryption_test_case_256_7),
14698
14699                 /** AES GCM Authenticated Encryption big aad size */
14700                 TEST_CASE_ST(ut_setup, ut_teardown,
14701                         test_AES_GCM_auth_encryption_test_case_aad_1),
14702                 TEST_CASE_ST(ut_setup, ut_teardown,
14703                         test_AES_GCM_auth_encryption_test_case_aad_2),
14704
14705                 /** AES GCM Authenticated Decryption big aad size */
14706                 TEST_CASE_ST(ut_setup, ut_teardown,
14707                         test_AES_GCM_auth_decryption_test_case_aad_1),
14708                 TEST_CASE_ST(ut_setup, ut_teardown,
14709                         test_AES_GCM_auth_decryption_test_case_aad_2),
14710
14711                 /** Out of place tests */
14712                 TEST_CASE_ST(ut_setup, ut_teardown,
14713                         test_AES_GCM_authenticated_encryption_oop_test_case_1),
14714                 TEST_CASE_ST(ut_setup, ut_teardown,
14715                         test_AES_GCM_authenticated_decryption_oop_test_case_1),
14716
14717                 /** Session-less tests */
14718                 TEST_CASE_ST(ut_setup, ut_teardown,
14719                         test_AES_GCM_authenticated_encryption_sessionless_test_case_1),
14720                 TEST_CASE_ST(ut_setup, ut_teardown,
14721                         test_AES_GCM_authenticated_decryption_sessionless_test_case_1),
14722
14723                 TEST_CASES_END()
14724         }
14725 };
14726
14727 static struct unit_test_suite cryptodev_aes_gmac_auth_testsuite  = {
14728         .suite_name = "AES GMAC Authentication Test Suite",
14729         .setup = aes_gmac_auth_testsuite_setup,
14730         .unit_test_cases = {
14731                 TEST_CASE_ST(ut_setup, ut_teardown,
14732                         test_AES_GMAC_authentication_test_case_1),
14733                 TEST_CASE_ST(ut_setup, ut_teardown,
14734                         test_AES_GMAC_authentication_verify_test_case_1),
14735                 TEST_CASE_ST(ut_setup, ut_teardown,
14736                         test_AES_GMAC_authentication_test_case_2),
14737                 TEST_CASE_ST(ut_setup, ut_teardown,
14738                         test_AES_GMAC_authentication_verify_test_case_2),
14739                 TEST_CASE_ST(ut_setup, ut_teardown,
14740                         test_AES_GMAC_authentication_test_case_3),
14741                 TEST_CASE_ST(ut_setup, ut_teardown,
14742                         test_AES_GMAC_authentication_verify_test_case_3),
14743                 TEST_CASE_ST(ut_setup, ut_teardown,
14744                         test_AES_GMAC_authentication_test_case_4),
14745                 TEST_CASE_ST(ut_setup, ut_teardown,
14746                         test_AES_GMAC_authentication_verify_test_case_4),
14747                 TEST_CASE_ST(ut_setup, ut_teardown,
14748                         test_AES_GMAC_authentication_SGL_40B),
14749                 TEST_CASE_ST(ut_setup, ut_teardown,
14750                         test_AES_GMAC_authentication_SGL_80B),
14751                 TEST_CASE_ST(ut_setup, ut_teardown,
14752                         test_AES_GMAC_authentication_SGL_2048B),
14753                 TEST_CASE_ST(ut_setup, ut_teardown,
14754                         test_AES_GMAC_authentication_SGL_2047B),
14755
14756                 TEST_CASES_END()
14757         }
14758 };
14759
14760 static struct unit_test_suite cryptodev_chacha20_poly1305_testsuite  = {
14761         .suite_name = "Chacha20-Poly1305 Test Suite",
14762         .setup = chacha20_poly1305_testsuite_setup,
14763         .unit_test_cases = {
14764                 TEST_CASE_ST(ut_setup, ut_teardown,
14765                         test_chacha20_poly1305_encrypt_test_case_rfc8439),
14766                 TEST_CASE_ST(ut_setup, ut_teardown,
14767                         test_chacha20_poly1305_decrypt_test_case_rfc8439),
14768                 TEST_CASES_END()
14769         }
14770 };
14771
14772 static struct unit_test_suite cryptodev_snow3g_testsuite  = {
14773         .suite_name = "SNOW 3G Test Suite",
14774         .setup = snow3g_testsuite_setup,
14775         .unit_test_cases = {
14776                 /** SNOW 3G encrypt only (UEA2) */
14777                 TEST_CASE_ST(ut_setup, ut_teardown,
14778                         test_snow3g_encryption_test_case_1),
14779                 TEST_CASE_ST(ut_setup, ut_teardown,
14780                         test_snow3g_encryption_test_case_2),
14781                 TEST_CASE_ST(ut_setup, ut_teardown,
14782                         test_snow3g_encryption_test_case_3),
14783                 TEST_CASE_ST(ut_setup, ut_teardown,
14784                         test_snow3g_encryption_test_case_4),
14785                 TEST_CASE_ST(ut_setup, ut_teardown,
14786                         test_snow3g_encryption_test_case_5),
14787
14788                 TEST_CASE_ST(ut_setup, ut_teardown,
14789                         test_snow3g_encryption_test_case_1_oop),
14790                 TEST_CASE_ST(ut_setup, ut_teardown,
14791                         test_snow3g_encryption_test_case_1_oop_sgl),
14792                 TEST_CASE_ST(ut_setup, ut_teardown,
14793                         test_snow3g_encryption_test_case_1_offset_oop),
14794                 TEST_CASE_ST(ut_setup, ut_teardown,
14795                         test_snow3g_decryption_test_case_1_oop),
14796
14797                 /** SNOW 3G generate auth, then encrypt (UEA2) */
14798                 TEST_CASE_ST(ut_setup, ut_teardown,
14799                         test_snow3g_auth_cipher_test_case_1),
14800                 TEST_CASE_ST(ut_setup, ut_teardown,
14801                         test_snow3g_auth_cipher_test_case_2),
14802                 TEST_CASE_ST(ut_setup, ut_teardown,
14803                         test_snow3g_auth_cipher_test_case_2_oop),
14804                 TEST_CASE_ST(ut_setup, ut_teardown,
14805                         test_snow3g_auth_cipher_part_digest_enc),
14806                 TEST_CASE_ST(ut_setup, ut_teardown,
14807                         test_snow3g_auth_cipher_part_digest_enc_oop),
14808                 TEST_CASE_ST(ut_setup, ut_teardown,
14809                         test_snow3g_auth_cipher_test_case_3_sgl),
14810                 TEST_CASE_ST(ut_setup, ut_teardown,
14811                         test_snow3g_auth_cipher_test_case_3_oop_sgl),
14812                 TEST_CASE_ST(ut_setup, ut_teardown,
14813                         test_snow3g_auth_cipher_part_digest_enc_sgl),
14814                 TEST_CASE_ST(ut_setup, ut_teardown,
14815                         test_snow3g_auth_cipher_part_digest_enc_oop_sgl),
14816
14817                 /** SNOW 3G decrypt (UEA2), then verify auth */
14818                 TEST_CASE_ST(ut_setup, ut_teardown,
14819                         test_snow3g_auth_cipher_verify_test_case_1),
14820                 TEST_CASE_ST(ut_setup, ut_teardown,
14821                         test_snow3g_auth_cipher_verify_test_case_2),
14822                 TEST_CASE_ST(ut_setup, ut_teardown,
14823                         test_snow3g_auth_cipher_verify_test_case_2_oop),
14824                 TEST_CASE_ST(ut_setup, ut_teardown,
14825                         test_snow3g_auth_cipher_verify_part_digest_enc),
14826                 TEST_CASE_ST(ut_setup, ut_teardown,
14827                         test_snow3g_auth_cipher_verify_part_digest_enc_oop),
14828                 TEST_CASE_ST(ut_setup, ut_teardown,
14829                         test_snow3g_auth_cipher_verify_test_case_3_sgl),
14830                 TEST_CASE_ST(ut_setup, ut_teardown,
14831                         test_snow3g_auth_cipher_verify_test_case_3_oop_sgl),
14832                 TEST_CASE_ST(ut_setup, ut_teardown,
14833                         test_snow3g_auth_cipher_verify_part_digest_enc_sgl),
14834                 TEST_CASE_ST(ut_setup, ut_teardown,
14835                         test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl),
14836
14837                 /** SNOW 3G decrypt only (UEA2) */
14838                 TEST_CASE_ST(ut_setup, ut_teardown,
14839                         test_snow3g_decryption_test_case_1),
14840                 TEST_CASE_ST(ut_setup, ut_teardown,
14841                         test_snow3g_decryption_test_case_2),
14842                 TEST_CASE_ST(ut_setup, ut_teardown,
14843                         test_snow3g_decryption_test_case_3),
14844                 TEST_CASE_ST(ut_setup, ut_teardown,
14845                         test_snow3g_decryption_test_case_4),
14846                 TEST_CASE_ST(ut_setup, ut_teardown,
14847                         test_snow3g_decryption_test_case_5),
14848                 TEST_CASE_ST(ut_setup, ut_teardown,
14849                         test_snow3g_decryption_with_digest_test_case_1),
14850                 TEST_CASE_ST(ut_setup, ut_teardown,
14851                         test_snow3g_hash_generate_test_case_1),
14852                 TEST_CASE_ST(ut_setup, ut_teardown,
14853                         test_snow3g_hash_generate_test_case_2),
14854                 TEST_CASE_ST(ut_setup, ut_teardown,
14855                         test_snow3g_hash_generate_test_case_3),
14856
14857                 /* Tests with buffers which length is not byte-aligned */
14858                 TEST_CASE_ST(ut_setup, ut_teardown,
14859                         test_snow3g_hash_generate_test_case_4),
14860                 TEST_CASE_ST(ut_setup, ut_teardown,
14861                         test_snow3g_hash_generate_test_case_5),
14862                 TEST_CASE_ST(ut_setup, ut_teardown,
14863                         test_snow3g_hash_generate_test_case_6),
14864                 TEST_CASE_ST(ut_setup, ut_teardown,
14865                         test_snow3g_hash_verify_test_case_1),
14866                 TEST_CASE_ST(ut_setup, ut_teardown,
14867                         test_snow3g_hash_verify_test_case_2),
14868                 TEST_CASE_ST(ut_setup, ut_teardown,
14869                         test_snow3g_hash_verify_test_case_3),
14870
14871                 /* Tests with buffers which length is not byte-aligned */
14872                 TEST_CASE_ST(ut_setup, ut_teardown,
14873                         test_snow3g_hash_verify_test_case_4),
14874                 TEST_CASE_ST(ut_setup, ut_teardown,
14875                         test_snow3g_hash_verify_test_case_5),
14876                 TEST_CASE_ST(ut_setup, ut_teardown,
14877                         test_snow3g_hash_verify_test_case_6),
14878                 TEST_CASE_ST(ut_setup, ut_teardown,
14879                         test_snow3g_cipher_auth_test_case_1),
14880                 TEST_CASE_ST(ut_setup, ut_teardown,
14881                         test_snow3g_auth_cipher_with_digest_test_case_1),
14882                 TEST_CASES_END()
14883         }
14884 };
14885
14886 static struct unit_test_suite cryptodev_zuc_testsuite  = {
14887         .suite_name = "ZUC Test Suite",
14888         .setup = zuc_testsuite_setup,
14889         .unit_test_cases = {
14890                 /** ZUC encrypt only (EEA3) */
14891                 TEST_CASE_ST(ut_setup, ut_teardown,
14892                         test_zuc_encryption_test_case_1),
14893                 TEST_CASE_ST(ut_setup, ut_teardown,
14894                         test_zuc_encryption_test_case_2),
14895                 TEST_CASE_ST(ut_setup, ut_teardown,
14896                         test_zuc_encryption_test_case_3),
14897                 TEST_CASE_ST(ut_setup, ut_teardown,
14898                         test_zuc_encryption_test_case_4),
14899                 TEST_CASE_ST(ut_setup, ut_teardown,
14900                         test_zuc_encryption_test_case_5),
14901                 TEST_CASE_ST(ut_setup, ut_teardown,
14902                         test_zuc_encryption_test_case_6_sgl),
14903                 TEST_CASE_ST(ut_setup, ut_teardown,
14904                         test_zuc_encryption_test_case_7),
14905
14906                 /** ZUC authenticate (EIA3) */
14907                 TEST_CASE_ST(ut_setup, ut_teardown,
14908                         test_zuc_hash_generate_test_case_1),
14909                 TEST_CASE_ST(ut_setup, ut_teardown,
14910                         test_zuc_hash_generate_test_case_2),
14911                 TEST_CASE_ST(ut_setup, ut_teardown,
14912                         test_zuc_hash_generate_test_case_3),
14913                 TEST_CASE_ST(ut_setup, ut_teardown,
14914                         test_zuc_hash_generate_test_case_4),
14915                 TEST_CASE_ST(ut_setup, ut_teardown,
14916                         test_zuc_hash_generate_test_case_5),
14917                 TEST_CASE_ST(ut_setup, ut_teardown,
14918                         test_zuc_hash_generate_test_case_6),
14919                 TEST_CASE_ST(ut_setup, ut_teardown,
14920                         test_zuc_hash_generate_test_case_7),
14921                 TEST_CASE_ST(ut_setup, ut_teardown,
14922                         test_zuc_hash_generate_test_case_8),
14923                 TEST_CASE_ST(ut_setup, ut_teardown,
14924                         test_zuc_hash_generate_test_case_9),
14925                 TEST_CASE_ST(ut_setup, ut_teardown,
14926                         test_zuc_hash_generate_test_case_10),
14927
14928
14929                 /** ZUC alg-chain (EEA3/EIA3) */
14930                 TEST_CASE_ST(ut_setup, ut_teardown,
14931                         test_zuc_cipher_auth_test_case_1),
14932                 TEST_CASE_ST(ut_setup, ut_teardown,
14933                         test_zuc_cipher_auth_test_case_2),
14934
14935                 /** ZUC generate auth, then encrypt (EEA3) */
14936                 TEST_CASE_ST(ut_setup, ut_teardown,
14937                         test_zuc_auth_cipher_test_case_1),
14938                 TEST_CASE_ST(ut_setup, ut_teardown,
14939                         test_zuc_auth_cipher_test_case_1_oop),
14940                 TEST_CASE_ST(ut_setup, ut_teardown,
14941                         test_zuc_auth_cipher_test_case_1_sgl),
14942                 TEST_CASE_ST(ut_setup, ut_teardown,
14943                         test_zuc_auth_cipher_test_case_1_oop_sgl),
14944
14945                 /** ZUC decrypt (EEA3), then verify auth */
14946                 TEST_CASE_ST(ut_setup, ut_teardown,
14947                         test_zuc_auth_cipher_verify_test_case_1),
14948                 TEST_CASE_ST(ut_setup, ut_teardown,
14949                         test_zuc_auth_cipher_verify_test_case_1_oop),
14950                 TEST_CASE_ST(ut_setup, ut_teardown,
14951                         test_zuc_auth_cipher_verify_test_case_1_sgl),
14952                 TEST_CASE_ST(ut_setup, ut_teardown,
14953                         test_zuc_auth_cipher_verify_test_case_1_oop_sgl),
14954                 TEST_CASES_END()
14955         }
14956 };
14957
14958 static struct unit_test_suite cryptodev_hmac_md5_auth_testsuite  = {
14959         .suite_name = "HMAC_MD5 Authentication Test Suite",
14960         .setup = hmac_md5_auth_testsuite_setup,
14961         .unit_test_cases = {
14962                 TEST_CASE_ST(ut_setup, ut_teardown,
14963                         test_MD5_HMAC_generate_case_1),
14964                 TEST_CASE_ST(ut_setup, ut_teardown,
14965                         test_MD5_HMAC_verify_case_1),
14966                 TEST_CASE_ST(ut_setup, ut_teardown,
14967                         test_MD5_HMAC_generate_case_2),
14968                 TEST_CASE_ST(ut_setup, ut_teardown,
14969                         test_MD5_HMAC_verify_case_2),
14970                 TEST_CASES_END()
14971         }
14972 };
14973
14974 static struct unit_test_suite cryptodev_kasumi_testsuite  = {
14975         .suite_name = "Kasumi Test Suite",
14976         .setup = kasumi_testsuite_setup,
14977         .unit_test_cases = {
14978                 /** KASUMI hash only (UIA1) */
14979                 TEST_CASE_ST(ut_setup, ut_teardown,
14980                         test_kasumi_hash_generate_test_case_1),
14981                 TEST_CASE_ST(ut_setup, ut_teardown,
14982                         test_kasumi_hash_generate_test_case_2),
14983                 TEST_CASE_ST(ut_setup, ut_teardown,
14984                         test_kasumi_hash_generate_test_case_3),
14985                 TEST_CASE_ST(ut_setup, ut_teardown,
14986                         test_kasumi_hash_generate_test_case_4),
14987                 TEST_CASE_ST(ut_setup, ut_teardown,
14988                         test_kasumi_hash_generate_test_case_5),
14989                 TEST_CASE_ST(ut_setup, ut_teardown,
14990                         test_kasumi_hash_generate_test_case_6),
14991
14992                 TEST_CASE_ST(ut_setup, ut_teardown,
14993                         test_kasumi_hash_verify_test_case_1),
14994                 TEST_CASE_ST(ut_setup, ut_teardown,
14995                         test_kasumi_hash_verify_test_case_2),
14996                 TEST_CASE_ST(ut_setup, ut_teardown,
14997                         test_kasumi_hash_verify_test_case_3),
14998                 TEST_CASE_ST(ut_setup, ut_teardown,
14999                         test_kasumi_hash_verify_test_case_4),
15000                 TEST_CASE_ST(ut_setup, ut_teardown,
15001                         test_kasumi_hash_verify_test_case_5),
15002
15003                 /** KASUMI encrypt only (UEA1) */
15004                 TEST_CASE_ST(ut_setup, ut_teardown,
15005                         test_kasumi_encryption_test_case_1),
15006                 TEST_CASE_ST(ut_setup, ut_teardown,
15007                         test_kasumi_encryption_test_case_1_sgl),
15008                 TEST_CASE_ST(ut_setup, ut_teardown,
15009                         test_kasumi_encryption_test_case_1_oop),
15010                 TEST_CASE_ST(ut_setup, ut_teardown,
15011                         test_kasumi_encryption_test_case_1_oop_sgl),
15012                 TEST_CASE_ST(ut_setup, ut_teardown,
15013                         test_kasumi_encryption_test_case_2),
15014                 TEST_CASE_ST(ut_setup, ut_teardown,
15015                         test_kasumi_encryption_test_case_3),
15016                 TEST_CASE_ST(ut_setup, ut_teardown,
15017                         test_kasumi_encryption_test_case_4),
15018                 TEST_CASE_ST(ut_setup, ut_teardown,
15019                         test_kasumi_encryption_test_case_5),
15020
15021                 /** KASUMI decrypt only (UEA1) */
15022                 TEST_CASE_ST(ut_setup, ut_teardown,
15023                         test_kasumi_decryption_test_case_1),
15024                 TEST_CASE_ST(ut_setup, ut_teardown,
15025                         test_kasumi_decryption_test_case_2),
15026                 TEST_CASE_ST(ut_setup, ut_teardown,
15027                         test_kasumi_decryption_test_case_3),
15028                 TEST_CASE_ST(ut_setup, ut_teardown,
15029                         test_kasumi_decryption_test_case_4),
15030                 TEST_CASE_ST(ut_setup, ut_teardown,
15031                         test_kasumi_decryption_test_case_5),
15032                 TEST_CASE_ST(ut_setup, ut_teardown,
15033                         test_kasumi_decryption_test_case_1_oop),
15034                 TEST_CASE_ST(ut_setup, ut_teardown,
15035                         test_kasumi_cipher_auth_test_case_1),
15036
15037                 /** KASUMI generate auth, then encrypt (F8) */
15038                 TEST_CASE_ST(ut_setup, ut_teardown,
15039                         test_kasumi_auth_cipher_test_case_1),
15040                 TEST_CASE_ST(ut_setup, ut_teardown,
15041                         test_kasumi_auth_cipher_test_case_2),
15042                 TEST_CASE_ST(ut_setup, ut_teardown,
15043                         test_kasumi_auth_cipher_test_case_2_oop),
15044                 TEST_CASE_ST(ut_setup, ut_teardown,
15045                         test_kasumi_auth_cipher_test_case_2_sgl),
15046                 TEST_CASE_ST(ut_setup, ut_teardown,
15047                         test_kasumi_auth_cipher_test_case_2_oop_sgl),
15048
15049                 /** KASUMI decrypt (F8), then verify auth */
15050                 TEST_CASE_ST(ut_setup, ut_teardown,
15051                         test_kasumi_auth_cipher_verify_test_case_1),
15052                 TEST_CASE_ST(ut_setup, ut_teardown,
15053                         test_kasumi_auth_cipher_verify_test_case_2),
15054                 TEST_CASE_ST(ut_setup, ut_teardown,
15055                         test_kasumi_auth_cipher_verify_test_case_2_oop),
15056                 TEST_CASE_ST(ut_setup, ut_teardown,
15057                         test_kasumi_auth_cipher_verify_test_case_2_sgl),
15058                 TEST_CASE_ST(ut_setup, ut_teardown,
15059                         test_kasumi_auth_cipher_verify_test_case_2_oop_sgl),
15060
15061                 TEST_CASES_END()
15062         }
15063 };
15064
15065 static struct unit_test_suite cryptodev_esn_testsuite  = {
15066         .suite_name = "ESN Test Suite",
15067         .setup = esn_testsuite_setup,
15068         .unit_test_cases = {
15069                 TEST_CASE_ST(ut_setup, ut_teardown,
15070                         auth_encrypt_AES128CBC_HMAC_SHA1_esn_check),
15071                 TEST_CASE_ST(ut_setup, ut_teardown,
15072                         auth_decrypt_AES128CBC_HMAC_SHA1_esn_check),
15073                 TEST_CASES_END()
15074         }
15075 };
15076
15077 static struct unit_test_suite cryptodev_negative_aes_gcm_testsuite  = {
15078         .suite_name = "Negative AES GCM Test Suite",
15079         .setup = negative_aes_gcm_testsuite_setup,
15080         .unit_test_cases = {
15081                 TEST_CASE_ST(ut_setup, ut_teardown,
15082                         test_AES_GCM_auth_encryption_fail_iv_corrupt),
15083                 TEST_CASE_ST(ut_setup, ut_teardown,
15084                         test_AES_GCM_auth_encryption_fail_in_data_corrupt),
15085                 TEST_CASE_ST(ut_setup, ut_teardown,
15086                         test_AES_GCM_auth_encryption_fail_out_data_corrupt),
15087                 TEST_CASE_ST(ut_setup, ut_teardown,
15088                         test_AES_GCM_auth_encryption_fail_aad_len_corrupt),
15089                 TEST_CASE_ST(ut_setup, ut_teardown,
15090                         test_AES_GCM_auth_encryption_fail_aad_corrupt),
15091                 TEST_CASE_ST(ut_setup, ut_teardown,
15092                         test_AES_GCM_auth_encryption_fail_tag_corrupt),
15093                 TEST_CASE_ST(ut_setup, ut_teardown,
15094                         test_AES_GCM_auth_decryption_fail_iv_corrupt),
15095                 TEST_CASE_ST(ut_setup, ut_teardown,
15096                         test_AES_GCM_auth_decryption_fail_in_data_corrupt),
15097                 TEST_CASE_ST(ut_setup, ut_teardown,
15098                         test_AES_GCM_auth_decryption_fail_out_data_corrupt),
15099                 TEST_CASE_ST(ut_setup, ut_teardown,
15100                         test_AES_GCM_auth_decryption_fail_aad_len_corrupt),
15101                 TEST_CASE_ST(ut_setup, ut_teardown,
15102                         test_AES_GCM_auth_decryption_fail_aad_corrupt),
15103                 TEST_CASE_ST(ut_setup, ut_teardown,
15104                         test_AES_GCM_auth_decryption_fail_tag_corrupt),
15105
15106                 TEST_CASES_END()
15107         }
15108 };
15109
15110 static struct unit_test_suite cryptodev_negative_aes_gmac_testsuite  = {
15111         .suite_name = "Negative AES GMAC Test Suite",
15112         .setup = negative_aes_gmac_testsuite_setup,
15113         .unit_test_cases = {
15114                 TEST_CASE_ST(ut_setup, ut_teardown,
15115                         authentication_verify_AES128_GMAC_fail_data_corrupt),
15116                 TEST_CASE_ST(ut_setup, ut_teardown,
15117                         authentication_verify_AES128_GMAC_fail_tag_corrupt),
15118
15119                 TEST_CASES_END()
15120         }
15121 };
15122
15123 static struct unit_test_suite cryptodev_mixed_cipher_hash_testsuite  = {
15124         .suite_name = "Mixed CIPHER + HASH algorithms Test Suite",
15125         .setup = mixed_cipher_hash_testsuite_setup,
15126         .unit_test_cases = {
15127                 /** AUTH AES CMAC + CIPHER AES CTR */
15128                 TEST_CASE_ST(ut_setup, ut_teardown,
15129                         test_aes_cmac_aes_ctr_digest_enc_test_case_1),
15130                 TEST_CASE_ST(ut_setup, ut_teardown,
15131                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
15132                 TEST_CASE_ST(ut_setup, ut_teardown,
15133                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
15134                 TEST_CASE_ST(ut_setup, ut_teardown,
15135                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
15136                 TEST_CASE_ST(ut_setup, ut_teardown,
15137                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1),
15138                 TEST_CASE_ST(ut_setup, ut_teardown,
15139                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
15140                 TEST_CASE_ST(ut_setup, ut_teardown,
15141                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
15142                 TEST_CASE_ST(ut_setup, ut_teardown,
15143                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
15144
15145                 /** AUTH ZUC + CIPHER SNOW3G */
15146                 TEST_CASE_ST(ut_setup, ut_teardown,
15147                         test_auth_zuc_cipher_snow_test_case_1),
15148                 TEST_CASE_ST(ut_setup, ut_teardown,
15149                         test_verify_auth_zuc_cipher_snow_test_case_1),
15150                 /** AUTH AES CMAC + CIPHER SNOW3G */
15151                 TEST_CASE_ST(ut_setup, ut_teardown,
15152                         test_auth_aes_cmac_cipher_snow_test_case_1),
15153                 TEST_CASE_ST(ut_setup, ut_teardown,
15154                         test_verify_auth_aes_cmac_cipher_snow_test_case_1),
15155                 /** AUTH ZUC + CIPHER AES CTR */
15156                 TEST_CASE_ST(ut_setup, ut_teardown,
15157                         test_auth_zuc_cipher_aes_ctr_test_case_1),
15158                 TEST_CASE_ST(ut_setup, ut_teardown,
15159                         test_verify_auth_zuc_cipher_aes_ctr_test_case_1),
15160                 /** AUTH SNOW3G + CIPHER AES CTR */
15161                 TEST_CASE_ST(ut_setup, ut_teardown,
15162                         test_auth_snow_cipher_aes_ctr_test_case_1),
15163                 TEST_CASE_ST(ut_setup, ut_teardown,
15164                         test_verify_auth_snow_cipher_aes_ctr_test_case_1),
15165                 /** AUTH SNOW3G + CIPHER ZUC */
15166                 TEST_CASE_ST(ut_setup, ut_teardown,
15167                         test_auth_snow_cipher_zuc_test_case_1),
15168                 TEST_CASE_ST(ut_setup, ut_teardown,
15169                         test_verify_auth_snow_cipher_zuc_test_case_1),
15170                 /** AUTH AES CMAC + CIPHER ZUC */
15171                 TEST_CASE_ST(ut_setup, ut_teardown,
15172                         test_auth_aes_cmac_cipher_zuc_test_case_1),
15173                 TEST_CASE_ST(ut_setup, ut_teardown,
15174                         test_verify_auth_aes_cmac_cipher_zuc_test_case_1),
15175
15176                 /** AUTH NULL + CIPHER SNOW3G */
15177                 TEST_CASE_ST(ut_setup, ut_teardown,
15178                         test_auth_null_cipher_snow_test_case_1),
15179                 TEST_CASE_ST(ut_setup, ut_teardown,
15180                         test_verify_auth_null_cipher_snow_test_case_1),
15181                 /** AUTH NULL + CIPHER ZUC */
15182                 TEST_CASE_ST(ut_setup, ut_teardown,
15183                         test_auth_null_cipher_zuc_test_case_1),
15184                 TEST_CASE_ST(ut_setup, ut_teardown,
15185                         test_verify_auth_null_cipher_zuc_test_case_1),
15186                 /** AUTH SNOW3G + CIPHER NULL */
15187                 TEST_CASE_ST(ut_setup, ut_teardown,
15188                         test_auth_snow_cipher_null_test_case_1),
15189                 TEST_CASE_ST(ut_setup, ut_teardown,
15190                         test_verify_auth_snow_cipher_null_test_case_1),
15191                 /** AUTH ZUC + CIPHER NULL */
15192                 TEST_CASE_ST(ut_setup, ut_teardown,
15193                         test_auth_zuc_cipher_null_test_case_1),
15194                 TEST_CASE_ST(ut_setup, ut_teardown,
15195                         test_verify_auth_zuc_cipher_null_test_case_1),
15196                 /** AUTH NULL + CIPHER AES CTR */
15197                 TEST_CASE_ST(ut_setup, ut_teardown,
15198                         test_auth_null_cipher_aes_ctr_test_case_1),
15199                 TEST_CASE_ST(ut_setup, ut_teardown,
15200                         test_verify_auth_null_cipher_aes_ctr_test_case_1),
15201                 /** AUTH AES CMAC + CIPHER NULL */
15202                 TEST_CASE_ST(ut_setup, ut_teardown,
15203                         test_auth_aes_cmac_cipher_null_test_case_1),
15204                 TEST_CASE_ST(ut_setup, ut_teardown,
15205                         test_verify_auth_aes_cmac_cipher_null_test_case_1),
15206                 TEST_CASES_END()
15207         }
15208 };
15209
15210 static int
15211 run_cryptodev_testsuite(const char *pmd_name)
15212 {
15213         uint8_t ret, j, i = 0, blk_start_idx = 0;
15214         const enum blockcipher_test_type blk_suites[] = {
15215                 BLKCIPHER_AES_CHAIN_TYPE,
15216                 BLKCIPHER_AES_CIPHERONLY_TYPE,
15217                 BLKCIPHER_AES_DOCSIS_TYPE,
15218                 BLKCIPHER_3DES_CHAIN_TYPE,
15219                 BLKCIPHER_3DES_CIPHERONLY_TYPE,
15220                 BLKCIPHER_DES_CIPHERONLY_TYPE,
15221                 BLKCIPHER_DES_DOCSIS_TYPE,
15222                 BLKCIPHER_AUTHONLY_TYPE};
15223         struct unit_test_suite *static_suites[] = {
15224                 &cryptodev_multi_session_testsuite,
15225                 &cryptodev_null_testsuite,
15226                 &cryptodev_aes_ccm_auth_testsuite,
15227                 &cryptodev_aes_gcm_auth_testsuite,
15228                 &cryptodev_aes_gmac_auth_testsuite,
15229                 &cryptodev_snow3g_testsuite,
15230                 &cryptodev_chacha20_poly1305_testsuite,
15231                 &cryptodev_zuc_testsuite,
15232                 &cryptodev_hmac_md5_auth_testsuite,
15233                 &cryptodev_kasumi_testsuite,
15234                 &cryptodev_esn_testsuite,
15235                 &cryptodev_negative_aes_gcm_testsuite,
15236                 &cryptodev_negative_aes_gmac_testsuite,
15237                 &cryptodev_mixed_cipher_hash_testsuite,
15238                 &cryptodev_negative_hmac_sha1_testsuite,
15239                 &cryptodev_gen_testsuite,
15240 #ifdef RTE_LIB_SECURITY
15241                 &ipsec_proto_testsuite,
15242                 &pdcp_proto_testsuite,
15243                 &docsis_proto_testsuite,
15244 #endif
15245                 &end_testsuite
15246         };
15247         static struct unit_test_suite ts = {
15248                 .suite_name = "Cryptodev Unit Test Suite",
15249                 .setup = testsuite_setup,
15250                 .teardown = testsuite_teardown,
15251                 .unit_test_cases = {TEST_CASES_END()}
15252         };
15253
15254         gbl_driver_id = rte_cryptodev_driver_id_get(pmd_name);
15255
15256         if (gbl_driver_id == -1) {
15257                 RTE_LOG(ERR, USER1, "%s PMD must be loaded.\n", pmd_name);
15258                 return TEST_SKIPPED;
15259         }
15260
15261         ts.unit_test_suites = malloc(sizeof(struct unit_test_suite *) *
15262                         (RTE_DIM(blk_suites) + RTE_DIM(static_suites)));
15263
15264         ADD_BLOCKCIPHER_TESTSUITE(i, ts, blk_suites, RTE_DIM(blk_suites));
15265         ADD_STATIC_TESTSUITE(i, ts, static_suites, RTE_DIM(static_suites));
15266         ret = unit_test_suite_runner(&ts);
15267
15268         FREE_BLOCKCIPHER_TESTSUITE(blk_start_idx, ts, RTE_DIM(blk_suites));
15269         free(ts.unit_test_suites);
15270         return ret;
15271 }
15272
15273 static int
15274 require_feature_flag(const char *pmd_name, uint64_t flag, const char *flag_name)
15275 {
15276         struct rte_cryptodev_info dev_info;
15277         uint8_t i, nb_devs;
15278         int driver_id;
15279
15280         driver_id = rte_cryptodev_driver_id_get(pmd_name);
15281         if (driver_id == -1) {
15282                 RTE_LOG(WARNING, USER1, "%s PMD must be loaded.\n", pmd_name);
15283                 return TEST_SKIPPED;
15284         }
15285
15286         nb_devs = rte_cryptodev_count();
15287         if (nb_devs < 1) {
15288                 RTE_LOG(WARNING, USER1, "No crypto devices found?\n");
15289                 return TEST_SKIPPED;
15290         }
15291
15292         for (i = 0; i < nb_devs; i++) {
15293                 rte_cryptodev_info_get(i, &dev_info);
15294                 if (dev_info.driver_id == driver_id) {
15295                         if (!(dev_info.feature_flags & flag)) {
15296                                 RTE_LOG(INFO, USER1, "%s not supported\n",
15297                                                 flag_name);
15298                                 return TEST_SKIPPED;
15299                         }
15300                         return 0; /* found */
15301                 }
15302         }
15303
15304         RTE_LOG(INFO, USER1, "%s not supported\n", flag_name);
15305         return TEST_SKIPPED;
15306 }
15307
15308 static int
15309 test_cryptodev_qat(void)
15310 {
15311         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
15312 }
15313
15314 static int
15315 test_cryptodev_virtio(void)
15316 {
15317         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD));
15318 }
15319
15320 static int
15321 test_cryptodev_aesni_mb(void)
15322 {
15323         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
15324 }
15325
15326 static int
15327 test_cryptodev_cpu_aesni_mb(void)
15328 {
15329         int32_t rc;
15330         enum rte_security_session_action_type at = gbl_action_type;
15331         gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
15332         rc = run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
15333         gbl_action_type = at;
15334         return rc;
15335 }
15336
15337 static int
15338 test_cryptodev_openssl(void)
15339 {
15340         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
15341 }
15342
15343 static int
15344 test_cryptodev_aesni_gcm(void)
15345 {
15346         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
15347 }
15348
15349 static int
15350 test_cryptodev_cpu_aesni_gcm(void)
15351 {
15352         int32_t rc;
15353         enum rte_security_session_action_type at = gbl_action_type;
15354         gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
15355         rc  = run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
15356         gbl_action_type = at;
15357         return rc;
15358 }
15359
15360 static int
15361 test_cryptodev_mlx5(void)
15362 {
15363         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_MLX5_PMD));
15364 }
15365
15366 static int
15367 test_cryptodev_null(void)
15368 {
15369         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_NULL_PMD));
15370 }
15371
15372 static int
15373 test_cryptodev_sw_snow3g(void)
15374 {
15375         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
15376 }
15377
15378 static int
15379 test_cryptodev_sw_kasumi(void)
15380 {
15381         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
15382 }
15383
15384 static int
15385 test_cryptodev_sw_zuc(void)
15386 {
15387         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
15388 }
15389
15390 static int
15391 test_cryptodev_armv8(void)
15392 {
15393         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
15394 }
15395
15396 static int
15397 test_cryptodev_mrvl(void)
15398 {
15399         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
15400 }
15401
15402 #ifdef RTE_CRYPTO_SCHEDULER
15403
15404 static int
15405 test_cryptodev_scheduler(void)
15406 {
15407         uint8_t ret, sched_i, j, i = 0, blk_start_idx = 0;
15408         const enum blockcipher_test_type blk_suites[] = {
15409                 BLKCIPHER_AES_CHAIN_TYPE,
15410                 BLKCIPHER_AES_CIPHERONLY_TYPE,
15411                 BLKCIPHER_AUTHONLY_TYPE
15412         };
15413         static struct unit_test_suite scheduler_multicore = {
15414                 .suite_name = "Scheduler Multicore Unit Test Suite",
15415                 .setup = scheduler_multicore_testsuite_setup,
15416                 .teardown = scheduler_mode_testsuite_teardown,
15417                 .unit_test_cases = {TEST_CASES_END()}
15418         };
15419         static struct unit_test_suite scheduler_round_robin = {
15420                 .suite_name = "Scheduler Round Robin Unit Test Suite",
15421                 .setup = scheduler_roundrobin_testsuite_setup,
15422                 .teardown = scheduler_mode_testsuite_teardown,
15423                 .unit_test_cases = {TEST_CASES_END()}
15424         };
15425         static struct unit_test_suite scheduler_failover = {
15426                 .suite_name = "Scheduler Failover Unit Test Suite",
15427                 .setup = scheduler_failover_testsuite_setup,
15428                 .teardown = scheduler_mode_testsuite_teardown,
15429                 .unit_test_cases = {TEST_CASES_END()}
15430         };
15431         static struct unit_test_suite scheduler_pkt_size_distr = {
15432                 .suite_name = "Scheduler Pkt Size Distr Unit Test Suite",
15433                 .setup = scheduler_pkt_size_distr_testsuite_setup,
15434                 .teardown = scheduler_mode_testsuite_teardown,
15435                 .unit_test_cases = {TEST_CASES_END()}
15436         };
15437         struct unit_test_suite *sched_mode_suites[] = {
15438                 &scheduler_multicore,
15439                 &scheduler_round_robin,
15440                 &scheduler_failover,
15441                 &scheduler_pkt_size_distr
15442         };
15443         static struct unit_test_suite scheduler_config = {
15444                 .suite_name = "Crypto Device Scheduler Config Unit Test Suite",
15445                 .unit_test_cases = {
15446                         TEST_CASE(test_scheduler_attach_worker_op),
15447                         TEST_CASE(test_scheduler_mode_multicore_op),
15448                         TEST_CASE(test_scheduler_mode_roundrobin_op),
15449                         TEST_CASE(test_scheduler_mode_failover_op),
15450                         TEST_CASE(test_scheduler_mode_pkt_size_distr_op),
15451                         TEST_CASE(test_scheduler_detach_worker_op),
15452
15453                         TEST_CASES_END() /**< NULL terminate array */
15454                 }
15455         };
15456         struct unit_test_suite *static_suites[] = {
15457                 &scheduler_config,
15458                 &end_testsuite
15459         };
15460         static struct unit_test_suite ts = {
15461                 .suite_name = "Scheduler Unit Test Suite",
15462                 .setup = scheduler_testsuite_setup,
15463                 .teardown = testsuite_teardown,
15464                 .unit_test_cases = {TEST_CASES_END()}
15465         };
15466
15467         gbl_driver_id = rte_cryptodev_driver_id_get(
15468                         RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
15469
15470         if (gbl_driver_id == -1) {
15471                 RTE_LOG(ERR, USER1, "SCHEDULER PMD must be loaded.\n");
15472                 return TEST_SKIPPED;
15473         }
15474
15475         if (rte_cryptodev_driver_id_get(
15476                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) == -1) {
15477                 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded.\n");
15478                 return TEST_SKIPPED;
15479         }
15480
15481         for (sched_i = 0; sched_i < RTE_DIM(sched_mode_suites); sched_i++) {
15482                 uint8_t blk_i = 0;
15483                 sched_mode_suites[sched_i]->unit_test_suites = malloc(sizeof
15484                                 (struct unit_test_suite *) *
15485                                 (RTE_DIM(blk_suites) + 1));
15486                 ADD_BLOCKCIPHER_TESTSUITE(blk_i, (*sched_mode_suites[sched_i]),
15487                                 blk_suites, RTE_DIM(blk_suites));
15488                 sched_mode_suites[sched_i]->unit_test_suites[blk_i] = &end_testsuite;
15489         }
15490
15491         ts.unit_test_suites = malloc(sizeof(struct unit_test_suite *) *
15492                         (RTE_DIM(static_suites) + RTE_DIM(sched_mode_suites)));
15493         ADD_STATIC_TESTSUITE(i, ts, sched_mode_suites,
15494                         RTE_DIM(sched_mode_suites));
15495         ADD_STATIC_TESTSUITE(i, ts, static_suites, RTE_DIM(static_suites));
15496         ret = unit_test_suite_runner(&ts);
15497
15498         for (sched_i = 0; sched_i < RTE_DIM(sched_mode_suites); sched_i++) {
15499                 FREE_BLOCKCIPHER_TESTSUITE(blk_start_idx,
15500                                 (*sched_mode_suites[sched_i]),
15501                                 RTE_DIM(blk_suites));
15502                 free(sched_mode_suites[sched_i]->unit_test_suites);
15503         }
15504         free(ts.unit_test_suites);
15505         return ret;
15506 }
15507
15508 REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler);
15509
15510 #endif
15511
15512 static int
15513 test_cryptodev_dpaa2_sec(void)
15514 {
15515         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
15516 }
15517
15518 static int
15519 test_cryptodev_dpaa_sec(void)
15520 {
15521         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD));
15522 }
15523
15524 static int
15525 test_cryptodev_ccp(void)
15526 {
15527         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CCP_PMD));
15528 }
15529
15530 static int
15531 test_cryptodev_octeontx(void)
15532 {
15533         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD));
15534 }
15535
15536 static int
15537 test_cryptodev_octeontx2(void)
15538 {
15539         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OCTEONTX2_PMD));
15540 }
15541
15542 static int
15543 test_cryptodev_caam_jr(void)
15544 {
15545         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD));
15546 }
15547
15548 static int
15549 test_cryptodev_nitrox(void)
15550 {
15551         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_NITROX_PMD));
15552 }
15553
15554 static int
15555 test_cryptodev_bcmfs(void)
15556 {
15557         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_BCMFS_PMD));
15558 }
15559
15560 static int
15561 test_cryptodev_qat_raw_api(void)
15562 {
15563         static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD);
15564         int ret;
15565
15566         ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
15567                         "RAW API");
15568         if (ret)
15569                 return ret;
15570
15571         global_api_test_type = CRYPTODEV_RAW_API_TEST;
15572         ret = run_cryptodev_testsuite(pmd_name);
15573         global_api_test_type = CRYPTODEV_API_TEST;
15574
15575         return ret;
15576 }
15577
15578 static int
15579 test_cryptodev_cn9k(void)
15580 {
15581         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CN9K_PMD));
15582 }
15583
15584 static int
15585 test_cryptodev_cn10k(void)
15586 {
15587         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CN10K_PMD));
15588 }
15589
15590 static int
15591 test_cryptodev_dpaa2_sec_raw_api(void)
15592 {
15593         static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD);
15594         int ret;
15595
15596         ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
15597                         "RAW API");
15598         if (ret)
15599                 return ret;
15600
15601         global_api_test_type = CRYPTODEV_RAW_API_TEST;
15602         ret = run_cryptodev_testsuite(pmd_name);
15603         global_api_test_type = CRYPTODEV_API_TEST;
15604
15605         return ret;
15606 }
15607
15608 static int
15609 test_cryptodev_dpaa_sec_raw_api(void)
15610 {
15611         static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD);
15612         int ret;
15613
15614         ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
15615                         "RAW API");
15616         if (ret)
15617                 return ret;
15618
15619         global_api_test_type = CRYPTODEV_RAW_API_TEST;
15620         ret = run_cryptodev_testsuite(pmd_name);
15621         global_api_test_type = CRYPTODEV_API_TEST;
15622
15623         return ret;
15624 }
15625
15626 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_raw_api_autotest,
15627                 test_cryptodev_dpaa2_sec_raw_api);
15628 REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_raw_api_autotest,
15629                 test_cryptodev_dpaa_sec_raw_api);
15630 REGISTER_TEST_COMMAND(cryptodev_qat_raw_api_autotest,
15631                 test_cryptodev_qat_raw_api);
15632 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
15633 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
15634 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_mb_autotest,
15635         test_cryptodev_cpu_aesni_mb);
15636 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl);
15637 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm);
15638 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_gcm_autotest,
15639         test_cryptodev_cpu_aesni_gcm);
15640 REGISTER_TEST_COMMAND(cryptodev_mlx5_autotest, test_cryptodev_mlx5);
15641 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null);
15642 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
15643 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);
15644 REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc);
15645 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_autotest, test_cryptodev_armv8);
15646 REGISTER_TEST_COMMAND(cryptodev_sw_mvsam_autotest, test_cryptodev_mrvl);
15647 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_autotest, test_cryptodev_dpaa2_sec);
15648 REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_autotest, test_cryptodev_dpaa_sec);
15649 REGISTER_TEST_COMMAND(cryptodev_ccp_autotest, test_cryptodev_ccp);
15650 REGISTER_TEST_COMMAND(cryptodev_virtio_autotest, test_cryptodev_virtio);
15651 REGISTER_TEST_COMMAND(cryptodev_octeontx_autotest, test_cryptodev_octeontx);
15652 REGISTER_TEST_COMMAND(cryptodev_octeontx2_autotest, test_cryptodev_octeontx2);
15653 REGISTER_TEST_COMMAND(cryptodev_caam_jr_autotest, test_cryptodev_caam_jr);
15654 REGISTER_TEST_COMMAND(cryptodev_nitrox_autotest, test_cryptodev_nitrox);
15655 REGISTER_TEST_COMMAND(cryptodev_bcmfs_autotest, test_cryptodev_bcmfs);
15656 REGISTER_TEST_COMMAND(cryptodev_cn9k_autotest, test_cryptodev_cn9k);
15657 REGISTER_TEST_COMMAND(cryptodev_cn10k_autotest, test_cryptodev_cn10k);