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 static struct crypto_testsuite_params testsuite_params = { NULL };
 183 struct crypto_testsuite_params *p_testsuite_params = &testsuite_params;
 184 static struct crypto_unittest_params unittest_params;
 185
 186 void
 187 process_sym_raw_dp_op(uint8_t dev_id, uint16_t qp_id,
 188                 struct rte_crypto_op *op, uint8_t is_cipher, uint8_t is_auth,
 189                 uint8_t len_in_bits, uint8_t cipher_iv_len)
 190 {
 191         struct rte_crypto_sym_op *sop = op->sym;
 192         struct rte_crypto_op *ret_op = NULL;
 193         struct rte_crypto_vec data_vec[UINT8_MAX], dest_data_vec[UINT8_MAX];
 194         struct rte_crypto_va_iova_ptr cipher_iv, digest, aad_auth_iv;
 195         union rte_crypto_sym_ofs ofs;
 196         struct rte_crypto_sym_vec vec;
 197         struct rte_crypto_sgl sgl, dest_sgl;
 198         uint32_t max_len;
 199         union rte_cryptodev_session_ctx sess;
 200         uint64_t auth_end_iova;
 201         uint32_t count = 0;
 202         struct rte_crypto_raw_dp_ctx *ctx;
 203         uint32_t cipher_offset = 0, cipher_len = 0, auth_offset = 0,
 204                         auth_len = 0;
 205         int32_t n;
 206         uint32_t n_success;
 207         int ctx_service_size;
 208         int32_t status = 0;
 209         int enqueue_status, dequeue_status;
 210         struct crypto_unittest_params *ut_params = &unittest_params;
 211         int is_sgl = sop->m_src->nb_segs > 1;
 212
 213         ctx_service_size = rte_cryptodev_get_raw_dp_ctx_size(dev_id);
 214         if (ctx_service_size < 0) {
 215                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 216                 return;
 217         }
 218
 219         ctx = malloc(ctx_service_size);
 220         if (!ctx) {
 221                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 222                 return;
 223         }
 224
 225         /* Both are enums, setting crypto_sess will suit any session type */
 226         sess.crypto_sess = op->sym->session;
 227
 228         if (rte_cryptodev_configure_raw_dp_ctx(dev_id, qp_id, ctx,
 229                         op->sess_type, sess, 0) < 0) {
 230                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 231                 goto exit;
 232         }
 233
 234         cipher_iv.iova = 0;
 235         cipher_iv.va = NULL;
 236         aad_auth_iv.iova = 0;
 237         aad_auth_iv.va = NULL;
 238         digest.iova = 0;
 239         digest.va = NULL;
 240         sgl.vec = data_vec;
 241         vec.num = 1;
 242         vec.src_sgl = &sgl;
 243         vec.iv = &cipher_iv;
 244         vec.digest = &digest;
 245         vec.aad = &aad_auth_iv;
 246         vec.status = &status;
 247
 248         ofs.raw = 0;
 249
 250         if (is_cipher && is_auth) {
 251                 cipher_offset = sop->cipher.data.offset;
 252                 cipher_len = sop->cipher.data.length;
 253                 auth_offset = sop->auth.data.offset;
 254                 auth_len = sop->auth.data.length;
 255                 max_len = RTE_MAX(cipher_offset + cipher_len,
 256                                 auth_offset + auth_len);
 257                 if (len_in_bits) {
 258                         max_len = max_len >> 3;
 259                         cipher_offset = cipher_offset >> 3;
 260                         auth_offset = auth_offset >> 3;
 261                         cipher_len = cipher_len >> 3;
 262                         auth_len = auth_len >> 3;
 263                 }
 264                 ofs.ofs.cipher.head = cipher_offset;
 265                 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
 266                 ofs.ofs.auth.head = auth_offset;
 267                 ofs.ofs.auth.tail = max_len - auth_offset - auth_len;
 268                 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 269                 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
 270                 aad_auth_iv.va = rte_crypto_op_ctod_offset(
 271                                 op, void *, IV_OFFSET + cipher_iv_len);
 272                 aad_auth_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET +
 273                                 cipher_iv_len);
 274                 digest.va = (void *)sop->auth.digest.data;
 275                 digest.iova = sop->auth.digest.phys_addr;
 276
 277                 if (is_sgl) {
 278                         uint32_t remaining_off = auth_offset + auth_len;
 279                         struct rte_mbuf *sgl_buf = sop->m_src;
 280
 281                         while (remaining_off >= rte_pktmbuf_data_len(sgl_buf)
 282                                         && sgl_buf->next != NULL) {
 283                                 remaining_off -= rte_pktmbuf_data_len(sgl_buf);
 284                                 sgl_buf = sgl_buf->next;
 285                         }
 286
 287                         auth_end_iova = (uint64_t)rte_pktmbuf_iova_offset(
 288                                 sgl_buf, remaining_off);
 289                 } else {
 290                         auth_end_iova = rte_pktmbuf_iova(op->sym->m_src) +
 291                                                          auth_offset + auth_len;
 292                 }
 293                 /* Then check if digest-encrypted conditions are met */
 294                 if ((auth_offset + auth_len < cipher_offset + cipher_len) &&
 295                                 (digest.iova == auth_end_iova) && is_sgl)
 296                         max_len = RTE_MAX(max_len, auth_offset + auth_len +
 297                                 ut_params->auth_xform.auth.digest_length);
 298
 299         } else if (is_cipher) {
 300                 cipher_offset = sop->cipher.data.offset;
 301                 cipher_len = sop->cipher.data.length;
 302                 max_len = cipher_len + cipher_offset;
 303                 if (len_in_bits) {
 304                         max_len = max_len >> 3;
 305                         cipher_offset = cipher_offset >> 3;
 306                         cipher_len = cipher_len >> 3;
 307                 }
 308                 ofs.ofs.cipher.head = cipher_offset;
 309                 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
 310                 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 311                 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
 312
 313         } else if (is_auth) {
 314                 auth_offset = sop->auth.data.offset;
 315                 auth_len = sop->auth.data.length;
 316                 max_len = auth_len + auth_offset;
 317                 if (len_in_bits) {
 318                         max_len = max_len >> 3;
 319                         auth_offset = auth_offset >> 3;
 320                         auth_len = auth_len >> 3;
 321                 }
 322                 ofs.ofs.auth.head = auth_offset;
 323                 ofs.ofs.auth.tail = max_len - auth_offset - auth_len;
 324                 aad_auth_iv.va = rte_crypto_op_ctod_offset(
 325                                 op, void *, IV_OFFSET + cipher_iv_len);
 326                 aad_auth_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET +
 327                                 cipher_iv_len);
 328                 digest.va = (void *)sop->auth.digest.data;
 329                 digest.iova = sop->auth.digest.phys_addr;
 330
 331         } else { /* aead */
 332                 cipher_offset = sop->aead.data.offset;
 333                 cipher_len = sop->aead.data.length;
 334                 max_len = cipher_len + cipher_offset;
 335                 if (len_in_bits) {
 336                         max_len = max_len >> 3;
 337                         cipher_offset = cipher_offset >> 3;
 338                         cipher_len = cipher_len >> 3;
 339                 }
 340                 ofs.ofs.cipher.head = cipher_offset;
 341                 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
 342                 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 343                 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
 344                 aad_auth_iv.va = (void *)sop->aead.aad.data;
 345                 aad_auth_iv.iova = sop->aead.aad.phys_addr;
 346                 digest.va = (void *)sop->aead.digest.data;
 347                 digest.iova = sop->aead.digest.phys_addr;
 348         }
 349
 350         n = rte_crypto_mbuf_to_vec(sop->m_src, 0, max_len,
 351                         data_vec, RTE_DIM(data_vec));
 352         if (n < 0 || n > sop->m_src->nb_segs) {
 353                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 354                 goto exit;
 355         }
 356
 357         sgl.num = n;
 358         /* Out of place */
 359         if (sop->m_dst != NULL) {
 360                 dest_sgl.vec = dest_data_vec;
 361                 vec.dest_sgl = &dest_sgl;
 362                 n = rte_crypto_mbuf_to_vec(sop->m_dst, 0, max_len,
 363                                 dest_data_vec, RTE_DIM(dest_data_vec));
 364                 if (n < 0 || n > sop->m_dst->nb_segs) {
 365                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 366                         goto exit;
 367                 }
 368                 dest_sgl.num = n;
 369         } else
 370                 vec.dest_sgl = NULL;
 371
 372         if (rte_cryptodev_raw_enqueue_burst(ctx, &vec, ofs, (void **)&op,
 373                         &enqueue_status) < 1) {
 374                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 375                 goto exit;
 376         }
 377
 378         if (enqueue_status == 0) {
 379                 status = rte_cryptodev_raw_enqueue_done(ctx, 1);
 380                 if (status < 0) {
 381                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 382                         goto exit;
 383                 }
 384         } else if (enqueue_status < 0) {
 385                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 386                 goto exit;
 387         }
 388
 389         n = n_success = 0;
 390         while (count++ < MAX_RAW_DEQUEUE_COUNT && n == 0) {
 391                 n = rte_cryptodev_raw_dequeue_burst(ctx,
 392                         NULL, 1, post_process_raw_dp_op,
 393                                 (void **)&ret_op, 0, &n_success,
 394                                 &dequeue_status);
 395                 if (dequeue_status < 0) {
 396                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 397                         goto exit;
 398                 }
 399                 if (n == 0)
 400                         rte_pause();
 401         }
 402
 403         if (n == 1 && dequeue_status == 0) {
 404                 if (rte_cryptodev_raw_dequeue_done(ctx, 1) < 0) {
 405                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 406                         goto exit;
 407                 }
 408         }
 409
 410         op->status = (count == MAX_RAW_DEQUEUE_COUNT + 1 || ret_op != op ||
 411                         ret_op->status == RTE_CRYPTO_OP_STATUS_ERROR ||
 412                         n_success < 1) ? RTE_CRYPTO_OP_STATUS_ERROR :
 413                                         RTE_CRYPTO_OP_STATUS_SUCCESS;
 414
 415 exit:
 416         free(ctx);
 417 }
 418
 419 static void
 420 process_cpu_aead_op(uint8_t dev_id, struct rte_crypto_op *op)
 421 {
 422         int32_t n, st;
 423         struct rte_crypto_sym_op *sop;
 424         union rte_crypto_sym_ofs ofs;
 425         struct rte_crypto_sgl sgl;
 426         struct rte_crypto_sym_vec symvec;
 427         struct rte_crypto_va_iova_ptr iv_ptr, aad_ptr, digest_ptr;
 428         struct rte_crypto_vec vec[UINT8_MAX];
 429
 430         sop = op->sym;
 431
 432         n = rte_crypto_mbuf_to_vec(sop->m_src, sop->aead.data.offset,
 433                 sop->aead.data.length, vec, RTE_DIM(vec));
 434
 435         if (n < 0 || n != sop->m_src->nb_segs) {
 436                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 437                 return;
 438         }
 439
 440         sgl.vec = vec;
 441         sgl.num = n;
 442         symvec.src_sgl = &sgl;
 443         symvec.iv = &iv_ptr;
 444         symvec.digest = &digest_ptr;
 445         symvec.aad = &aad_ptr;
 446         symvec.status = &st;
 447         symvec.num = 1;
 448
 449         /* for CPU crypto the IOVA address is not required */
 450         iv_ptr.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 451         digest_ptr.va = (void *)sop->aead.digest.data;
 452         aad_ptr.va = (void *)sop->aead.aad.data;
 453
 454         ofs.raw = 0;
 455
 456         n = rte_cryptodev_sym_cpu_crypto_process(dev_id, sop->session, ofs,
 457                 &symvec);
 458
 459         if (n != 1)
 460                 op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
 461         else
 462                 op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
 463 }
 464
 465 static void
 466 process_cpu_crypt_auth_op(uint8_t dev_id, struct rte_crypto_op *op)
 467 {
 468         int32_t n, st;
 469         struct rte_crypto_sym_op *sop;
 470         union rte_crypto_sym_ofs ofs;
 471         struct rte_crypto_sgl sgl;
 472         struct rte_crypto_sym_vec symvec;
 473         struct rte_crypto_va_iova_ptr iv_ptr, digest_ptr;
 474         struct rte_crypto_vec vec[UINT8_MAX];
 475
 476         sop = op->sym;
 477
 478         n = rte_crypto_mbuf_to_vec(sop->m_src, sop->auth.data.offset,
 479                 sop->auth.data.length, vec, RTE_DIM(vec));
 480
 481         if (n < 0 || n != sop->m_src->nb_segs) {
 482                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 483                 return;
 484         }
 485
 486         sgl.vec = vec;
 487         sgl.num = n;
 488         symvec.src_sgl = &sgl;
 489         symvec.iv = &iv_ptr;
 490         symvec.digest = &digest_ptr;
 491         symvec.status = &st;
 492         symvec.num = 1;
 493
 494         iv_ptr.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 495         digest_ptr.va = (void *)sop->auth.digest.data;
 496
 497         ofs.raw = 0;
 498         ofs.ofs.cipher.head = sop->cipher.data.offset - sop->auth.data.offset;
 499         ofs.ofs.cipher.tail = (sop->auth.data.offset + sop->auth.data.length) -
 500                 (sop->cipher.data.offset + sop->cipher.data.length);
 501
 502         n = rte_cryptodev_sym_cpu_crypto_process(dev_id, sop->session, ofs,
 503                 &symvec);
 504
 505         if (n != 1)
 506                 op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
 507         else
 508                 op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
 509 }
 510
 511 static struct rte_crypto_op *
 512 process_crypto_request(uint8_t dev_id, struct rte_crypto_op *op)
 513 {
 514
 515         RTE_VERIFY(gbl_action_type != RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO);
 516
 517         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
 518                 RTE_LOG(ERR, USER1, "Error sending packet for encryption\n");
 519                 return NULL;
 520         }
 521
 522         op = NULL;
 523
 524         while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0)
 525                 rte_pause();
 526
 527         if (op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
 528                 RTE_LOG(DEBUG, USER1, "Operation status %d\n", op->status);
 529                 return NULL;
 530         }
 531
 532         return op;
 533 }
 534
 535 static int
 536 testsuite_setup(void)
 537 {
 538         struct crypto_testsuite_params *ts_params = &testsuite_params;
 539         struct rte_cryptodev_info info;
 540         uint32_t i = 0, nb_devs, dev_id;
 541         uint16_t qp_id;
 542
 543         memset(ts_params, 0, sizeof(*ts_params));
 544
 545         ts_params->mbuf_pool = rte_mempool_lookup("CRYPTO_MBUFPOOL");
 546         if (ts_params->mbuf_pool == NULL) {
 547                 /* Not already created so create */
 548                 ts_params->mbuf_pool = rte_pktmbuf_pool_create(
 549                                 "CRYPTO_MBUFPOOL",
 550                                 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
 551                                 rte_socket_id());
 552                 if (ts_params->mbuf_pool == NULL) {
 553                         RTE_LOG(ERR, USER1, "Can't create CRYPTO_MBUFPOOL\n");
 554                         return TEST_FAILED;
 555                 }
 556         }
 557
 558         ts_params->large_mbuf_pool = rte_mempool_lookup(
 559                         "CRYPTO_LARGE_MBUFPOOL");
 560         if (ts_params->large_mbuf_pool == NULL) {
 561                 /* Not already created so create */
 562                 ts_params->large_mbuf_pool = rte_pktmbuf_pool_create(
 563                                 "CRYPTO_LARGE_MBUFPOOL",
 564                                 1, 0, 0, UINT16_MAX,
 565                                 rte_socket_id());
 566                 if (ts_params->large_mbuf_pool == NULL) {
 567                         RTE_LOG(ERR, USER1,
 568                                 "Can't create CRYPTO_LARGE_MBUFPOOL\n");
 569                         return TEST_FAILED;
 570                 }
 571         }
 572
 573         ts_params->op_mpool = rte_crypto_op_pool_create(
 574                         "MBUF_CRYPTO_SYM_OP_POOL",
 575                         RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 576                         NUM_MBUFS, MBUF_CACHE_SIZE,
 577                         DEFAULT_NUM_XFORMS *
 578                         sizeof(struct rte_crypto_sym_xform) +
 579                         MAXIMUM_IV_LENGTH,
 580                         rte_socket_id());
 581         if (ts_params->op_mpool == NULL) {
 582                 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
 583                 return TEST_FAILED;
 584         }
 585
 586         nb_devs = rte_cryptodev_count();
 587         if (nb_devs < 1) {
 588                 RTE_LOG(WARNING, USER1, "No crypto devices found?\n");
 589                 return TEST_SKIPPED;
 590         }
 591
 592         if (rte_cryptodev_device_count_by_driver(gbl_driver_id) < 1) {
 593                 RTE_LOG(WARNING, USER1, "No %s devices found?\n",
 594                                 rte_cryptodev_driver_name_get(gbl_driver_id));
 595                 return TEST_SKIPPED;
 596         }
 597
 598         /* Create list of valid crypto devs */
 599         for (i = 0; i < nb_devs; i++) {
 600                 rte_cryptodev_info_get(i, &info);
 601                 if (info.driver_id == gbl_driver_id)
 602                         ts_params->valid_devs[ts_params->valid_dev_count++] = i;
 603         }
 604
 605         if (ts_params->valid_dev_count < 1)
 606                 return TEST_FAILED;
 607
 608         /* Set up all the qps on the first of the valid devices found */
 609
 610         dev_id = ts_params->valid_devs[0];
 611
 612         rte_cryptodev_info_get(dev_id, &info);
 613
 614         ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
 615         ts_params->conf.socket_id = SOCKET_ID_ANY;
 616         ts_params->conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY;
 617
 618         unsigned int session_size =
 619                 rte_cryptodev_sym_get_private_session_size(dev_id);
 620
 621 #ifdef RTE_LIB_SECURITY
 622         unsigned int security_session_size = rte_security_session_get_size(
 623                         rte_cryptodev_get_sec_ctx(dev_id));
 624
 625         if (session_size < security_session_size)
 626                 session_size = security_session_size;
 627 #endif
 628         /*
 629          * Create mempool with maximum number of sessions.
 630          */
 631         if (info.sym.max_nb_sessions != 0 &&
 632                         info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
 633                 RTE_LOG(ERR, USER1, "Device does not support "
 634                                 "at least %u sessions\n",
 635                                 MAX_NB_SESSIONS);
 636                 return TEST_FAILED;
 637         }
 638
 639         ts_params->session_mpool = rte_cryptodev_sym_session_pool_create(
 640                         "test_sess_mp", MAX_NB_SESSIONS, 0, 0, 0,
 641                         SOCKET_ID_ANY);
 642         TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
 643                         "session mempool allocation failed");
 644
 645         ts_params->session_priv_mpool = rte_mempool_create(
 646                         "test_sess_mp_priv",
 647                         MAX_NB_SESSIONS,
 648                         session_size,
 649                         0, 0, NULL, NULL, NULL,
 650                         NULL, SOCKET_ID_ANY,
 651                         0);
 652         TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
 653                         "session mempool allocation failed");
 654
 655
 656
 657         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id,
 658                         &ts_params->conf),
 659                         "Failed to configure cryptodev %u with %u qps",
 660                         dev_id, ts_params->conf.nb_queue_pairs);
 661
 662         ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
 663         ts_params->qp_conf.mp_session = ts_params->session_mpool;
 664         ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
 665
 666         for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) {
 667                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 668                         dev_id, qp_id, &ts_params->qp_conf,
 669                         rte_cryptodev_socket_id(dev_id)),
 670                         "Failed to setup queue pair %u on cryptodev %u",
 671                         qp_id, dev_id);
 672         }
 673
 674         return TEST_SUCCESS;
 675 }
 676
 677 static void
 678 testsuite_teardown(void)
 679 {
 680         struct crypto_testsuite_params *ts_params = &testsuite_params;
 681         int res;
 682
 683         if (ts_params->mbuf_pool != NULL) {
 684                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
 685                 rte_mempool_avail_count(ts_params->mbuf_pool));
 686         }
 687
 688         if (ts_params->op_mpool != NULL) {
 689                 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n",
 690                 rte_mempool_avail_count(ts_params->op_mpool));
 691         }
 692
 693         /* Free session mempools */
 694         if (ts_params->session_priv_mpool != NULL) {
 695                 rte_mempool_free(ts_params->session_priv_mpool);
 696                 ts_params->session_priv_mpool = NULL;
 697         }
 698
 699         if (ts_params->session_mpool != NULL) {
 700                 rte_mempool_free(ts_params->session_mpool);
 701                 ts_params->session_mpool = NULL;
 702         }
 703
 704         res = rte_cryptodev_close(ts_params->valid_devs[0]);
 705         if (res)
 706                 RTE_LOG(ERR, USER1, "Crypto device close error %d\n", res);
 707 }
 708
 709 static int
 710 check_capabilities_supported(enum rte_crypto_sym_xform_type type,
 711                 const int *algs, uint16_t num_algs)
 712 {
 713         uint8_t dev_id = testsuite_params.valid_devs[0];
 714         bool some_alg_supported = FALSE;
 715         uint16_t i;
 716
 717         for (i = 0; i < num_algs && !some_alg_supported; i++) {
 718                 struct rte_cryptodev_sym_capability_idx alg = {
 719                         type, {algs[i]}
 720                 };
 721                 if (rte_cryptodev_sym_capability_get(dev_id,
 722                                 &alg) != NULL)
 723                         some_alg_supported = TRUE;
 724         }
 725         if (!some_alg_supported)
 726                 return TEST_SKIPPED;
 727
 728         return 0;
 729 }
 730
 731 int
 732 check_cipher_capabilities_supported(const enum rte_crypto_cipher_algorithm *ciphers,
 733                 uint16_t num_ciphers)
 734 {
 735         return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_CIPHER,
 736                         (const int *) ciphers, num_ciphers);
 737 }
 738
 739 int
 740 check_auth_capabilities_supported(const enum rte_crypto_auth_algorithm *auths,
 741                 uint16_t num_auths)
 742 {
 743         return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_AUTH,
 744                         (const int *) auths, num_auths);
 745 }
 746
 747 int
 748 check_aead_capabilities_supported(const enum rte_crypto_aead_algorithm *aeads,
 749                 uint16_t num_aeads)
 750 {
 751         return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_AEAD,
 752                         (const int *) aeads, num_aeads);
 753 }
 754
 755 static int
 756 null_testsuite_setup(void)
 757 {
 758         struct crypto_testsuite_params *ts_params = &testsuite_params;
 759         uint8_t dev_id = ts_params->valid_devs[0];
 760         struct rte_cryptodev_info dev_info;
 761         const enum rte_crypto_cipher_algorithm ciphers[] = {
 762                 RTE_CRYPTO_CIPHER_NULL
 763         };
 764         const enum rte_crypto_auth_algorithm auths[] = {
 765                 RTE_CRYPTO_AUTH_NULL
 766         };
 767
 768         rte_cryptodev_info_get(dev_id, &dev_info);
 769
 770         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
 771                 RTE_LOG(INFO, USER1, "Feature flag requirements for NULL "
 772                                 "testsuite not met\n");
 773                 return TEST_SKIPPED;
 774         }
 775
 776         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
 777                         && check_auth_capabilities_supported(auths,
 778                         RTE_DIM(auths)) != 0) {
 779                 RTE_LOG(INFO, USER1, "Capability requirements for NULL "
 780                                 "testsuite not met\n");
 781                 return TEST_SKIPPED;
 782         }
 783
 784         return 0;
 785 }
 786
 787 static int
 788 crypto_gen_testsuite_setup(void)
 789 {
 790         struct crypto_testsuite_params *ts_params = &testsuite_params;
 791         uint8_t dev_id = ts_params->valid_devs[0];
 792         struct rte_cryptodev_info dev_info;
 793
 794         rte_cryptodev_info_get(dev_id, &dev_info);
 795
 796         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
 797                 RTE_LOG(INFO, USER1, "Feature flag requirements for Crypto Gen "
 798                                 "testsuite not met\n");
 799                 return TEST_SKIPPED;
 800         }
 801
 802         return 0;
 803 }
 804
 805 #ifdef RTE_LIB_SECURITY
 806 static int
 807 ipsec_proto_testsuite_setup(void)
 808 {
 809         struct crypto_testsuite_params *ts_params = &testsuite_params;
 810         struct crypto_unittest_params *ut_params = &unittest_params;
 811         struct rte_cryptodev_info dev_info;
 812         int ret = 0;
 813
 814         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 815
 816         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SECURITY)) {
 817                 RTE_LOG(INFO, USER1, "Feature flag requirements for IPsec Proto "
 818                                 "testsuite not met\n");
 819                 return TEST_SKIPPED;
 820         }
 821
 822         /* Reconfigure to enable security */
 823         ret = dev_configure_and_start(0);
 824         if (ret != TEST_SUCCESS)
 825                 return ret;
 826
 827         /* Set action type */
 828         ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
 829
 830         if (security_proto_supported(
 831                         RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
 832                         RTE_SECURITY_PROTOCOL_IPSEC) < 0) {
 833                 RTE_LOG(INFO, USER1, "Capability requirements for IPsec Proto "
 834                                 "test not met\n");
 835                 ret = TEST_SKIPPED;
 836         }
 837
 838         test_ipsec_alg_list_populate();
 839
 840         /*
 841          * Stop the device. Device would be started again by individual test
 842          * case setup routine.
 843          */
 844         rte_cryptodev_stop(ts_params->valid_devs[0]);
 845
 846         return ret;
 847 }
 848
 849 static int
 850 pdcp_proto_testsuite_setup(void)
 851 {
 852         struct crypto_testsuite_params *ts_params = &testsuite_params;
 853         uint8_t dev_id = ts_params->valid_devs[0];
 854         struct rte_cryptodev_info dev_info;
 855         const enum rte_crypto_cipher_algorithm ciphers[] = {
 856                 RTE_CRYPTO_CIPHER_NULL,
 857                 RTE_CRYPTO_CIPHER_AES_CTR,
 858                 RTE_CRYPTO_CIPHER_ZUC_EEA3,
 859                 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
 860         };
 861         const enum rte_crypto_auth_algorithm auths[] = {
 862                 RTE_CRYPTO_AUTH_NULL,
 863                 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
 864                 RTE_CRYPTO_AUTH_AES_CMAC,
 865                 RTE_CRYPTO_AUTH_ZUC_EIA3
 866         };
 867
 868         rte_cryptodev_info_get(dev_id, &dev_info);
 869
 870         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 871                         !(dev_info.feature_flags &
 872                         RTE_CRYPTODEV_FF_SECURITY)) {
 873                 RTE_LOG(INFO, USER1, "Feature flag requirements for PDCP Proto "
 874                                 "testsuite not met\n");
 875                 return TEST_SKIPPED;
 876         }
 877
 878         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
 879                         && check_auth_capabilities_supported(auths,
 880                         RTE_DIM(auths)) != 0) {
 881                 RTE_LOG(INFO, USER1, "Capability requirements for PDCP Proto "
 882                                 "testsuite not met\n");
 883                 return TEST_SKIPPED;
 884         }
 885
 886         return 0;
 887 }
 888
 889 static int
 890 docsis_proto_testsuite_setup(void)
 891 {
 892         struct crypto_testsuite_params *ts_params = &testsuite_params;
 893         uint8_t dev_id = ts_params->valid_devs[0];
 894         struct rte_cryptodev_info dev_info;
 895         const enum rte_crypto_cipher_algorithm ciphers[] = {
 896                 RTE_CRYPTO_CIPHER_AES_DOCSISBPI
 897         };
 898
 899         rte_cryptodev_info_get(dev_id, &dev_info);
 900
 901         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 902                         !(dev_info.feature_flags &
 903                         RTE_CRYPTODEV_FF_SECURITY)) {
 904                 RTE_LOG(INFO, USER1, "Feature flag requirements for DOCSIS "
 905                                 "Proto testsuite not met\n");
 906                 return TEST_SKIPPED;
 907         }
 908
 909         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0) {
 910                 RTE_LOG(INFO, USER1, "Capability requirements for DOCSIS Proto "
 911                                 "testsuite not met\n");
 912                 return TEST_SKIPPED;
 913         }
 914
 915         return 0;
 916 }
 917 #endif
 918
 919 static int
 920 aes_ccm_auth_testsuite_setup(void)
 921 {
 922         struct crypto_testsuite_params *ts_params = &testsuite_params;
 923         uint8_t dev_id = ts_params->valid_devs[0];
 924         struct rte_cryptodev_info dev_info;
 925         const enum rte_crypto_aead_algorithm aeads[] = {
 926                 RTE_CRYPTO_AEAD_AES_CCM
 927         };
 928
 929         rte_cryptodev_info_get(dev_id, &dev_info);
 930
 931         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 932                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
 933                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
 934                 RTE_LOG(INFO, USER1, "Feature flag requirements for AES CCM "
 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 CCM "
 941                                 "testsuite not met\n");
 942                 return TEST_SKIPPED;
 943         }
 944
 945         return 0;
 946 }
 947
 948 static int
 949 aes_gcm_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_aead_algorithm aeads[] = {
 955                 RTE_CRYPTO_AEAD_AES_GCM
 956         };
 957
 958         rte_cryptodev_info_get(dev_id, &dev_info);
 959
 960         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
 961                 RTE_LOG(INFO, USER1, "Feature flag requirements for AES GCM "
 962                                 "testsuite not met\n");
 963                 return TEST_SKIPPED;
 964         }
 965
 966         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
 967                 RTE_LOG(INFO, USER1, "Capability requirements for AES GCM "
 968                                 "testsuite not met\n");
 969                 return TEST_SKIPPED;
 970         }
 971
 972         return 0;
 973 }
 974
 975 static int
 976 aes_gmac_auth_testsuite_setup(void)
 977 {
 978         struct crypto_testsuite_params *ts_params = &testsuite_params;
 979         uint8_t dev_id = ts_params->valid_devs[0];
 980         struct rte_cryptodev_info dev_info;
 981         const enum rte_crypto_auth_algorithm auths[] = {
 982                 RTE_CRYPTO_AUTH_AES_GMAC
 983         };
 984
 985         rte_cryptodev_info_get(dev_id, &dev_info);
 986
 987         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 988                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
 989                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
 990                 RTE_LOG(INFO, USER1, "Feature flag requirements for AES GMAC "
 991                                 "testsuite not met\n");
 992                 return TEST_SKIPPED;
 993         }
 994
 995         if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
 996                 RTE_LOG(INFO, USER1, "Capability requirements for AES GMAC "
 997                                 "testsuite not met\n");
 998                 return TEST_SKIPPED;
 999         }
1000
1001         return 0;
1002 }
1003
1004 static int
1005 chacha20_poly1305_testsuite_setup(void)
1006 {
1007         struct crypto_testsuite_params *ts_params = &testsuite_params;
1008         uint8_t dev_id = ts_params->valid_devs[0];
1009         struct rte_cryptodev_info dev_info;
1010         const enum rte_crypto_aead_algorithm aeads[] = {
1011                 RTE_CRYPTO_AEAD_CHACHA20_POLY1305
1012         };
1013
1014         rte_cryptodev_info_get(dev_id, &dev_info);
1015
1016         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1017                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1018                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1019                 RTE_LOG(INFO, USER1, "Feature flag requirements for "
1020                                 "Chacha20-Poly1305 testsuite not met\n");
1021                 return TEST_SKIPPED;
1022         }
1023
1024         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
1025                 RTE_LOG(INFO, USER1, "Capability requirements for "
1026                                 "Chacha20-Poly1305 testsuite not met\n");
1027                 return TEST_SKIPPED;
1028         }
1029
1030         return 0;
1031 }
1032
1033 static int
1034 snow3g_testsuite_setup(void)
1035 {
1036         struct crypto_testsuite_params *ts_params = &testsuite_params;
1037         uint8_t dev_id = ts_params->valid_devs[0];
1038         struct rte_cryptodev_info dev_info;
1039         const enum rte_crypto_cipher_algorithm ciphers[] = {
1040                 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
1041
1042         };
1043         const enum rte_crypto_auth_algorithm auths[] = {
1044                 RTE_CRYPTO_AUTH_SNOW3G_UIA2
1045         };
1046
1047         rte_cryptodev_info_get(dev_id, &dev_info);
1048
1049         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1050                 RTE_LOG(INFO, USER1, "Feature flag requirements for Snow3G "
1051                                 "testsuite not met\n");
1052                 return TEST_SKIPPED;
1053         }
1054
1055         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1056                         && check_auth_capabilities_supported(auths,
1057                         RTE_DIM(auths)) != 0) {
1058                 RTE_LOG(INFO, USER1, "Capability requirements for Snow3G "
1059                                 "testsuite not met\n");
1060                 return TEST_SKIPPED;
1061         }
1062
1063         return 0;
1064 }
1065
1066 static int
1067 zuc_testsuite_setup(void)
1068 {
1069         struct crypto_testsuite_params *ts_params = &testsuite_params;
1070         uint8_t dev_id = ts_params->valid_devs[0];
1071         struct rte_cryptodev_info dev_info;
1072         const enum rte_crypto_cipher_algorithm ciphers[] = {
1073                 RTE_CRYPTO_CIPHER_ZUC_EEA3
1074         };
1075         const enum rte_crypto_auth_algorithm auths[] = {
1076                 RTE_CRYPTO_AUTH_ZUC_EIA3
1077         };
1078
1079         rte_cryptodev_info_get(dev_id, &dev_info);
1080
1081         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1082                 RTE_LOG(INFO, USER1, "Feature flag requirements for ZUC "
1083                                 "testsuite not met\n");
1084                 return TEST_SKIPPED;
1085         }
1086
1087         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1088                         && check_auth_capabilities_supported(auths,
1089                         RTE_DIM(auths)) != 0) {
1090                 RTE_LOG(INFO, USER1, "Capability requirements for ZUC "
1091                                 "testsuite not met\n");
1092                 return TEST_SKIPPED;
1093         }
1094
1095         return 0;
1096 }
1097
1098 static int
1099 hmac_md5_auth_testsuite_setup(void)
1100 {
1101         struct crypto_testsuite_params *ts_params = &testsuite_params;
1102         uint8_t dev_id = ts_params->valid_devs[0];
1103         struct rte_cryptodev_info dev_info;
1104         const enum rte_crypto_auth_algorithm auths[] = {
1105                 RTE_CRYPTO_AUTH_MD5_HMAC
1106         };
1107
1108         rte_cryptodev_info_get(dev_id, &dev_info);
1109
1110         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1111                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1112                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1113                 RTE_LOG(INFO, USER1, "Feature flag requirements for HMAC MD5 "
1114                                 "Auth testsuite not met\n");
1115                 return TEST_SKIPPED;
1116         }
1117
1118         if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
1119                 RTE_LOG(INFO, USER1, "Capability requirements for HMAC MD5 "
1120                                 "testsuite not met\n");
1121                 return TEST_SKIPPED;
1122         }
1123
1124         return 0;
1125 }
1126
1127 static int
1128 kasumi_testsuite_setup(void)
1129 {
1130         struct crypto_testsuite_params *ts_params = &testsuite_params;
1131         uint8_t dev_id = ts_params->valid_devs[0];
1132         struct rte_cryptodev_info dev_info;
1133         const enum rte_crypto_cipher_algorithm ciphers[] = {
1134                 RTE_CRYPTO_CIPHER_KASUMI_F8
1135         };
1136         const enum rte_crypto_auth_algorithm auths[] = {
1137                 RTE_CRYPTO_AUTH_KASUMI_F9
1138         };
1139
1140         rte_cryptodev_info_get(dev_id, &dev_info);
1141
1142         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1143                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1144                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1145                 RTE_LOG(INFO, USER1, "Feature flag requirements for Kasumi "
1146                                 "testsuite not met\n");
1147                 return TEST_SKIPPED;
1148         }
1149
1150         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1151                         && check_auth_capabilities_supported(auths,
1152                         RTE_DIM(auths)) != 0) {
1153                 RTE_LOG(INFO, USER1, "Capability requirements for Kasumi "
1154                                 "testsuite not met\n");
1155                 return TEST_SKIPPED;
1156         }
1157
1158         return 0;
1159 }
1160
1161 static int
1162 negative_aes_gcm_testsuite_setup(void)
1163 {
1164         struct crypto_testsuite_params *ts_params = &testsuite_params;
1165         uint8_t dev_id = ts_params->valid_devs[0];
1166         struct rte_cryptodev_info dev_info;
1167         const enum rte_crypto_aead_algorithm aeads[] = {
1168                 RTE_CRYPTO_AEAD_AES_GCM
1169         };
1170
1171         rte_cryptodev_info_get(dev_id, &dev_info);
1172
1173         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1174                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1175                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1176                 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1177                                 "AES GCM testsuite not met\n");
1178                 return TEST_SKIPPED;
1179         }
1180
1181         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
1182                 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1183                                 "AES GCM testsuite not met\n");
1184                 return TEST_SKIPPED;
1185         }
1186
1187         return 0;
1188 }
1189
1190 static int
1191 negative_aes_gmac_testsuite_setup(void)
1192 {
1193         struct crypto_testsuite_params *ts_params = &testsuite_params;
1194         uint8_t dev_id = ts_params->valid_devs[0];
1195         struct rte_cryptodev_info dev_info;
1196         const enum rte_crypto_auth_algorithm auths[] = {
1197                 RTE_CRYPTO_AUTH_AES_GMAC
1198         };
1199
1200         rte_cryptodev_info_get(dev_id, &dev_info);
1201
1202         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1203                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1204                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1205                 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1206                                 "AES GMAC testsuite not met\n");
1207                 return TEST_SKIPPED;
1208         }
1209
1210         if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
1211                 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1212                                 "AES GMAC testsuite not met\n");
1213                 return TEST_SKIPPED;
1214         }
1215
1216         return 0;
1217 }
1218
1219 static int
1220 mixed_cipher_hash_testsuite_setup(void)
1221 {
1222         struct crypto_testsuite_params *ts_params = &testsuite_params;
1223         uint8_t dev_id = ts_params->valid_devs[0];
1224         struct rte_cryptodev_info dev_info;
1225         uint64_t feat_flags;
1226         const enum rte_crypto_cipher_algorithm ciphers[] = {
1227                 RTE_CRYPTO_CIPHER_NULL,
1228                 RTE_CRYPTO_CIPHER_AES_CTR,
1229                 RTE_CRYPTO_CIPHER_ZUC_EEA3,
1230                 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
1231         };
1232         const enum rte_crypto_auth_algorithm auths[] = {
1233                 RTE_CRYPTO_AUTH_NULL,
1234                 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
1235                 RTE_CRYPTO_AUTH_AES_CMAC,
1236                 RTE_CRYPTO_AUTH_ZUC_EIA3
1237         };
1238
1239         rte_cryptodev_info_get(dev_id, &dev_info);
1240         feat_flags = dev_info.feature_flags;
1241
1242         if (!(feat_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1243                         (global_api_test_type == CRYPTODEV_RAW_API_TEST)) {
1244                 RTE_LOG(INFO, USER1, "Feature flag requirements for Mixed "
1245                                 "Cipher Hash testsuite not met\n");
1246                 return TEST_SKIPPED;
1247         }
1248
1249         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1250                         && check_auth_capabilities_supported(auths,
1251                         RTE_DIM(auths)) != 0) {
1252                 RTE_LOG(INFO, USER1, "Capability requirements for Mixed "
1253                                 "Cipher Hash testsuite not met\n");
1254                 return TEST_SKIPPED;
1255         }
1256
1257         return 0;
1258 }
1259
1260 static int
1261 esn_testsuite_setup(void)
1262 {
1263         struct crypto_testsuite_params *ts_params = &testsuite_params;
1264         uint8_t dev_id = ts_params->valid_devs[0];
1265         struct rte_cryptodev_info dev_info;
1266         const enum rte_crypto_cipher_algorithm ciphers[] = {
1267                 RTE_CRYPTO_CIPHER_AES_CBC
1268         };
1269         const enum rte_crypto_auth_algorithm auths[] = {
1270                 RTE_CRYPTO_AUTH_SHA1_HMAC
1271         };
1272
1273         rte_cryptodev_info_get(dev_id, &dev_info);
1274
1275         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1276                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1277                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1278                 RTE_LOG(INFO, USER1, "Feature flag requirements for ESN "
1279                                 "testsuite not met\n");
1280                 return TEST_SKIPPED;
1281         }
1282
1283         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1284                         && check_auth_capabilities_supported(auths,
1285                         RTE_DIM(auths)) != 0) {
1286                 RTE_LOG(INFO, USER1, "Capability requirements for ESN "
1287                                 "testsuite not met\n");
1288                 return TEST_SKIPPED;
1289         }
1290
1291         return 0;
1292 }
1293
1294 static int
1295 multi_session_testsuite_setup(void)
1296 {
1297         struct crypto_testsuite_params *ts_params = &testsuite_params;
1298         uint8_t dev_id = ts_params->valid_devs[0];
1299         struct rte_cryptodev_info dev_info;
1300         const enum rte_crypto_cipher_algorithm ciphers[] = {
1301                 RTE_CRYPTO_CIPHER_AES_CBC
1302         };
1303         const enum rte_crypto_auth_algorithm auths[] = {
1304                 RTE_CRYPTO_AUTH_SHA512_HMAC
1305         };
1306
1307         rte_cryptodev_info_get(dev_id, &dev_info);
1308
1309         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1310                 RTE_LOG(INFO, USER1, "Feature flag requirements for Multi "
1311                                 "Session testsuite not met\n");
1312                 return TEST_SKIPPED;
1313         }
1314
1315         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1316                         && check_auth_capabilities_supported(auths,
1317                         RTE_DIM(auths)) != 0) {
1318                 RTE_LOG(INFO, USER1, "Capability requirements for Multi "
1319                                 "Session testsuite not met\n");
1320                 return TEST_SKIPPED;
1321         }
1322
1323         return 0;
1324 }
1325
1326 static int
1327 negative_hmac_sha1_testsuite_setup(void)
1328 {
1329         struct crypto_testsuite_params *ts_params = &testsuite_params;
1330         uint8_t dev_id = ts_params->valid_devs[0];
1331         struct rte_cryptodev_info dev_info;
1332         const enum rte_crypto_cipher_algorithm ciphers[] = {
1333                 RTE_CRYPTO_CIPHER_AES_CBC
1334         };
1335         const enum rte_crypto_auth_algorithm auths[] = {
1336                 RTE_CRYPTO_AUTH_SHA1_HMAC
1337         };
1338
1339         rte_cryptodev_info_get(dev_id, &dev_info);
1340
1341         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1342                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1343                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1344                 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1345                                 "HMAC SHA1 testsuite not met\n");
1346                 return TEST_SKIPPED;
1347         }
1348
1349         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1350                         && check_auth_capabilities_supported(auths,
1351                         RTE_DIM(auths)) != 0) {
1352                 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1353                                 "HMAC SHA1 testsuite not met\n");
1354                 return TEST_SKIPPED;
1355         }
1356
1357         return 0;
1358 }
1359
1360 static int
1361 dev_configure_and_start(uint64_t ff_disable)
1362 {
1363         struct crypto_testsuite_params *ts_params = &testsuite_params;
1364         struct crypto_unittest_params *ut_params = &unittest_params;
1365
1366         uint16_t qp_id;
1367
1368         /* Clear unit test parameters before running test */
1369         memset(ut_params, 0, sizeof(*ut_params));
1370
1371         /* Reconfigure device to default parameters */
1372         ts_params->conf.socket_id = SOCKET_ID_ANY;
1373         ts_params->conf.ff_disable = ff_disable;
1374         ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
1375         ts_params->qp_conf.mp_session = ts_params->session_mpool;
1376         ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
1377
1378         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1379                         &ts_params->conf),
1380                         "Failed to configure cryptodev %u",
1381                         ts_params->valid_devs[0]);
1382
1383         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
1384                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1385                         ts_params->valid_devs[0], qp_id,
1386                         &ts_params->qp_conf,
1387                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1388                         "Failed to setup queue pair %u on cryptodev %u",
1389                         qp_id, ts_params->valid_devs[0]);
1390         }
1391
1392
1393         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
1394
1395         /* Start the device */
1396         TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
1397                         "Failed to start cryptodev %u",
1398                         ts_params->valid_devs[0]);
1399
1400         return TEST_SUCCESS;
1401 }
1402
1403 int
1404 ut_setup(void)
1405 {
1406         /* Configure and start the device with security feature disabled */
1407         return dev_configure_and_start(RTE_CRYPTODEV_FF_SECURITY);
1408 }
1409
1410 static int
1411 ut_setup_security(void)
1412 {
1413         /* Configure and start the device with no features disabled */
1414         return dev_configure_and_start(0);
1415 }
1416
1417 void
1418 ut_teardown(void)
1419 {
1420         struct crypto_testsuite_params *ts_params = &testsuite_params;
1421         struct crypto_unittest_params *ut_params = &unittest_params;
1422
1423         /* free crypto session structure */
1424 #ifdef RTE_LIB_SECURITY
1425         if (ut_params->type == RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL) {
1426                 if (ut_params->sec_session) {
1427                         rte_security_session_destroy(rte_cryptodev_get_sec_ctx
1428                                                 (ts_params->valid_devs[0]),
1429                                                 ut_params->sec_session);
1430                         ut_params->sec_session = NULL;
1431                 }
1432         } else
1433 #endif
1434         {
1435                 if (ut_params->sess) {
1436                         rte_cryptodev_sym_session_clear(
1437                                         ts_params->valid_devs[0],
1438                                         ut_params->sess);
1439                         rte_cryptodev_sym_session_free(ut_params->sess);
1440                         ut_params->sess = NULL;
1441                 }
1442         }
1443
1444         /* free crypto operation structure */
1445         if (ut_params->op)
1446                 rte_crypto_op_free(ut_params->op);
1447
1448         /*
1449          * free mbuf - both obuf and ibuf are usually the same,
1450          * so check if they point at the same address is necessary,
1451          * to avoid freeing the mbuf twice.
1452          */
1453         if (ut_params->obuf) {
1454                 rte_pktmbuf_free(ut_params->obuf);
1455                 if (ut_params->ibuf == ut_params->obuf)
1456                         ut_params->ibuf = 0;
1457                 ut_params->obuf = 0;
1458         }
1459         if (ut_params->ibuf) {
1460                 rte_pktmbuf_free(ut_params->ibuf);
1461                 ut_params->ibuf = 0;
1462         }
1463
1464         if (ts_params->mbuf_pool != NULL)
1465                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
1466                         rte_mempool_avail_count(ts_params->mbuf_pool));
1467
1468         /* Stop the device */
1469         rte_cryptodev_stop(ts_params->valid_devs[0]);
1470 }
1471
1472 static int
1473 test_device_configure_invalid_dev_id(void)
1474 {
1475         struct crypto_testsuite_params *ts_params = &testsuite_params;
1476         uint16_t dev_id, num_devs = 0;
1477
1478         TEST_ASSERT((num_devs = rte_cryptodev_count()) >= 1,
1479                         "Need at least %d devices for test", 1);
1480
1481         /* valid dev_id values */
1482         dev_id = ts_params->valid_devs[0];
1483
1484         /* Stop the device in case it's started so it can be configured */
1485         rte_cryptodev_stop(dev_id);
1486
1487         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf),
1488                         "Failed test for rte_cryptodev_configure: "
1489                         "invalid dev_num %u", dev_id);
1490
1491         /* invalid dev_id values */
1492         dev_id = num_devs;
1493
1494         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
1495                         "Failed test for rte_cryptodev_configure: "
1496                         "invalid dev_num %u", dev_id);
1497
1498         dev_id = 0xff;
1499
1500         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
1501                         "Failed test for rte_cryptodev_configure:"
1502                         "invalid dev_num %u", dev_id);
1503
1504         return TEST_SUCCESS;
1505 }
1506
1507 static int
1508 test_device_configure_invalid_queue_pair_ids(void)
1509 {
1510         struct crypto_testsuite_params *ts_params = &testsuite_params;
1511         uint16_t orig_nb_qps = ts_params->conf.nb_queue_pairs;
1512
1513         /* Stop the device in case it's started so it can be configured */
1514         rte_cryptodev_stop(ts_params->valid_devs[0]);
1515
1516         /* valid - max value queue pairs */
1517         ts_params->conf.nb_queue_pairs = orig_nb_qps;
1518
1519         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1520                         &ts_params->conf),
1521                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
1522                         ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
1523
1524         /* valid - one queue pairs */
1525         ts_params->conf.nb_queue_pairs = 1;
1526
1527         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1528                         &ts_params->conf),
1529                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
1530                         ts_params->valid_devs[0],
1531                         ts_params->conf.nb_queue_pairs);
1532
1533
1534         /* invalid - zero queue pairs */
1535         ts_params->conf.nb_queue_pairs = 0;
1536
1537         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1538                         &ts_params->conf),
1539                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1540                         " invalid qps: %u",
1541                         ts_params->valid_devs[0],
1542                         ts_params->conf.nb_queue_pairs);
1543
1544
1545         /* invalid - max value supported by field queue pairs */
1546         ts_params->conf.nb_queue_pairs = UINT16_MAX;
1547
1548         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1549                         &ts_params->conf),
1550                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1551                         " invalid qps: %u",
1552                         ts_params->valid_devs[0],
1553                         ts_params->conf.nb_queue_pairs);
1554
1555
1556         /* invalid - max value + 1 queue pairs */
1557         ts_params->conf.nb_queue_pairs = orig_nb_qps + 1;
1558
1559         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1560                         &ts_params->conf),
1561                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1562                         " invalid qps: %u",
1563                         ts_params->valid_devs[0],
1564                         ts_params->conf.nb_queue_pairs);
1565
1566         /* revert to original testsuite value */
1567         ts_params->conf.nb_queue_pairs = orig_nb_qps;
1568
1569         return TEST_SUCCESS;
1570 }
1571
1572 static int
1573 test_queue_pair_descriptor_setup(void)
1574 {
1575         struct crypto_testsuite_params *ts_params = &testsuite_params;
1576         struct rte_cryptodev_qp_conf qp_conf = {
1577                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
1578         };
1579         uint16_t qp_id;
1580
1581         /* Stop the device in case it's started so it can be configured */
1582         rte_cryptodev_stop(ts_params->valid_devs[0]);
1583
1584         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1585                         &ts_params->conf),
1586                         "Failed to configure cryptodev %u",
1587                         ts_params->valid_devs[0]);
1588
1589         /*
1590          * Test various ring sizes on this device. memzones can't be
1591          * freed so are re-used if ring is released and re-created.
1592          */
1593         qp_conf.nb_descriptors = MIN_NUM_OPS_INFLIGHT; /* min size*/
1594         qp_conf.mp_session = ts_params->session_mpool;
1595         qp_conf.mp_session_private = ts_params->session_priv_mpool;
1596
1597         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1598                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1599                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1600                                 rte_cryptodev_socket_id(
1601                                                 ts_params->valid_devs[0])),
1602                                 "Failed test for "
1603                                 "rte_cryptodev_queue_pair_setup: num_inflights "
1604                                 "%u on qp %u on cryptodev %u",
1605                                 qp_conf.nb_descriptors, qp_id,
1606                                 ts_params->valid_devs[0]);
1607         }
1608
1609         qp_conf.nb_descriptors = (uint32_t)(MAX_NUM_OPS_INFLIGHT / 2);
1610
1611         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1612                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1613                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1614                                 rte_cryptodev_socket_id(
1615                                                 ts_params->valid_devs[0])),
1616                                 "Failed test for"
1617                                 " rte_cryptodev_queue_pair_setup: num_inflights"
1618                                 " %u on qp %u on cryptodev %u",
1619                                 qp_conf.nb_descriptors, qp_id,
1620                                 ts_params->valid_devs[0]);
1621         }
1622
1623         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; /* valid */
1624
1625         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1626                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1627                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1628                                 rte_cryptodev_socket_id(
1629                                                 ts_params->valid_devs[0])),
1630                                 "Failed test for "
1631                                 "rte_cryptodev_queue_pair_setup: num_inflights"
1632                                 " %u on qp %u on cryptodev %u",
1633                                 qp_conf.nb_descriptors, qp_id,
1634                                 ts_params->valid_devs[0]);
1635         }
1636
1637         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
1638
1639         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1640                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1641                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1642                                 rte_cryptodev_socket_id(
1643                                                 ts_params->valid_devs[0])),
1644                                 "Failed test for"
1645                                 " rte_cryptodev_queue_pair_setup:"
1646                                 "num_inflights %u on qp %u on cryptodev %u",
1647                                 qp_conf.nb_descriptors, qp_id,
1648                                 ts_params->valid_devs[0]);
1649         }
1650
1651         /* test invalid queue pair id */
1652         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;      /*valid */
1653
1654         qp_id = ts_params->conf.nb_queue_pairs;         /*invalid */
1655
1656         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
1657                         ts_params->valid_devs[0],
1658                         qp_id, &qp_conf,
1659                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1660                         "Failed test for rte_cryptodev_queue_pair_setup:"
1661                         "invalid qp %u on cryptodev %u",
1662                         qp_id, ts_params->valid_devs[0]);
1663
1664         qp_id = 0xffff; /*invalid*/
1665
1666         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
1667                         ts_params->valid_devs[0],
1668                         qp_id, &qp_conf,
1669                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1670                         "Failed test for rte_cryptodev_queue_pair_setup:"
1671                         "invalid qp %u on cryptodev %u",
1672                         qp_id, ts_params->valid_devs[0]);
1673
1674         return TEST_SUCCESS;
1675 }
1676
1677 /* ***** Plaintext data for tests ***** */
1678
1679 const char catch_22_quote_1[] =
1680                 "There was only one catch and that was Catch-22, which "
1681                 "specified that a concern for one's safety in the face of "
1682                 "dangers that were real and immediate was the process of a "
1683                 "rational mind. Orr was crazy and could be grounded. All he "
1684                 "had to do was ask; and as soon as he did, he would no longer "
1685                 "be crazy and would have to fly more missions. Orr would be "
1686                 "crazy to fly more missions and sane if he didn't, but if he "
1687                 "was sane he had to fly them. If he flew them he was crazy "
1688                 "and didn't have to; but if he didn't want to he was sane and "
1689                 "had to. Yossarian was moved very deeply by the absolute "
1690                 "simplicity of this clause of Catch-22 and let out a "
1691                 "respectful whistle. \"That's some catch, that Catch-22\", he "
1692                 "observed. \"It's the best there is,\" Doc Daneeka agreed.";
1693
1694 const char catch_22_quote[] =
1695                 "What a lousy earth! He wondered how many people were "
1696                 "destitute that same night even in his own prosperous country, "
1697                 "how many homes were shanties, how many husbands were drunk "
1698                 "and wives socked, and how many children were bullied, abused, "
1699                 "or abandoned. How many families hungered for food they could "
1700                 "not afford to buy? How many hearts were broken? How many "
1701                 "suicides would take place that same night, how many people "
1702                 "would go insane? How many cockroaches and landlords would "
1703                 "triumph? How many winners were losers, successes failures, "
1704                 "and rich men poor men? How many wise guys were stupid? How "
1705                 "many happy endings were unhappy endings? How many honest men "
1706                 "were liars, brave men cowards, loyal men traitors, how many "
1707                 "sainted men were corrupt, how many people in positions of "
1708                 "trust had sold their souls to bodyguards, how many had never "
1709                 "had souls? How many straight-and-narrow paths were crooked "
1710                 "paths? How many best families were worst families and how "
1711                 "many good people were bad people? When you added them all up "
1712                 "and then subtracted, you might be left with only the children, "
1713                 "and perhaps with Albert Einstein and an old violinist or "
1714                 "sculptor somewhere.";
1715
1716 #define QUOTE_480_BYTES         (480)
1717 #define QUOTE_512_BYTES         (512)
1718 #define QUOTE_768_BYTES         (768)
1719 #define QUOTE_1024_BYTES        (1024)
1720
1721
1722
1723 /* ***** SHA1 Hash Tests ***** */
1724
1725 #define HMAC_KEY_LENGTH_SHA1    (DIGEST_BYTE_LENGTH_SHA1)
1726
1727 static uint8_t hmac_sha1_key[] = {
1728         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
1729         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
1730         0xDE, 0xF4, 0xDE, 0xAD };
1731
1732 /* ***** SHA224 Hash Tests ***** */
1733
1734 #define HMAC_KEY_LENGTH_SHA224  (DIGEST_BYTE_LENGTH_SHA224)
1735
1736
1737 /* ***** AES-CBC Cipher Tests ***** */
1738
1739 #define CIPHER_KEY_LENGTH_AES_CBC       (16)
1740 #define CIPHER_IV_LENGTH_AES_CBC        (CIPHER_KEY_LENGTH_AES_CBC)
1741
1742 static uint8_t aes_cbc_key[] = {
1743         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
1744         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A };
1745
1746 static uint8_t aes_cbc_iv[] = {
1747         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1748         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
1749
1750
1751 /* ***** AES-CBC / HMAC-SHA1 Hash Tests ***** */
1752
1753 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_ciphertext[] = {
1754         0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31,
1755         0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76,
1756         0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E,
1757         0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A,
1758         0x3F, 0x6B, 0x5D, 0xDF, 0x52, 0x85, 0x5F, 0x8E,
1759         0x42, 0x3C, 0xFB, 0xE9, 0x1A, 0x24, 0xD6, 0x08,
1760         0xDD, 0xFD, 0x16, 0xFB, 0xE9, 0x55, 0xEF, 0xF0,
1761         0xA0, 0x8D, 0x13, 0xAB, 0x81, 0xC6, 0x90, 0x01,
1762         0xB5, 0x18, 0x84, 0xB3, 0xF6, 0xE6, 0x11, 0x57,
1763         0xD6, 0x71, 0xC6, 0x3C, 0x3F, 0x2F, 0x33, 0xEE,
1764         0x24, 0x42, 0x6E, 0xAC, 0x0B, 0xCA, 0xEC, 0xF9,
1765         0x84, 0xF8, 0x22, 0xAA, 0x60, 0xF0, 0x32, 0xA9,
1766         0x75, 0x75, 0x3B, 0xCB, 0x70, 0x21, 0x0A, 0x8D,
1767         0x0F, 0xE0, 0xC4, 0x78, 0x2B, 0xF8, 0x97, 0xE3,
1768         0xE4, 0x26, 0x4B, 0x29, 0xDA, 0x88, 0xCD, 0x46,
1769         0xEC, 0xAA, 0xF9, 0x7F, 0xF1, 0x15, 0xEA, 0xC3,
1770         0x87, 0xE6, 0x31, 0xF2, 0xCF, 0xDE, 0x4D, 0x80,
1771         0x70, 0x91, 0x7E, 0x0C, 0xF7, 0x26, 0x3A, 0x92,
1772         0x4F, 0x18, 0x83, 0xC0, 0x8F, 0x59, 0x01, 0xA5,
1773         0x88, 0xD1, 0xDB, 0x26, 0x71, 0x27, 0x16, 0xF5,
1774         0xEE, 0x10, 0x82, 0xAC, 0x68, 0x26, 0x9B, 0xE2,
1775         0x6D, 0xD8, 0x9A, 0x80, 0xDF, 0x04, 0x31, 0xD5,
1776         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1777         0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
1778         0x73, 0x02, 0x42, 0xC9, 0x23, 0x18, 0x8E, 0xB4,
1779         0x6F, 0xB4, 0xA3, 0x54, 0x6E, 0x88, 0x3B, 0x62,
1780         0x7C, 0x02, 0x8D, 0x4C, 0x9F, 0xC8, 0x45, 0xF4,
1781         0xC9, 0xDE, 0x4F, 0xEB, 0x22, 0x83, 0x1B, 0xE4,
1782         0x49, 0x37, 0xE4, 0xAD, 0xE7, 0xCD, 0x21, 0x54,
1783         0xBC, 0x1C, 0xC2, 0x04, 0x97, 0xB4, 0x10, 0x61,
1784         0xF0, 0xE4, 0xEF, 0x27, 0x63, 0x3A, 0xDA, 0x91,
1785         0x41, 0x25, 0x62, 0x1C, 0x5C, 0xB6, 0x38, 0x4A,
1786         0x88, 0x71, 0x59, 0x5A, 0x8D, 0xA0, 0x09, 0xAF,
1787         0x72, 0x94, 0xD7, 0x79, 0x5C, 0x60, 0x7C, 0x8F,
1788         0x4C, 0xF5, 0xD9, 0xA1, 0x39, 0x6D, 0x81, 0x28,
1789         0xEF, 0x13, 0x28, 0xDF, 0xF5, 0x3E, 0xF7, 0x8E,
1790         0x09, 0x9C, 0x78, 0x18, 0x79, 0xB8, 0x68, 0xD7,
1791         0xA8, 0x29, 0x62, 0xAD, 0xDE, 0xE1, 0x61, 0x76,
1792         0x1B, 0x05, 0x16, 0xCD, 0xBF, 0x02, 0x8E, 0xA6,
1793         0x43, 0x6E, 0x92, 0x55, 0x4F, 0x60, 0x9C, 0x03,
1794         0xB8, 0x4F, 0xA3, 0x02, 0xAC, 0xA8, 0xA7, 0x0C,
1795         0x1E, 0xB5, 0x6B, 0xF8, 0xC8, 0x4D, 0xDE, 0xD2,
1796         0xB0, 0x29, 0x6E, 0x40, 0xE6, 0xD6, 0xC9, 0xE6,
1797         0xB9, 0x0F, 0xB6, 0x63, 0xF5, 0xAA, 0x2B, 0x96,
1798         0xA7, 0x16, 0xAC, 0x4E, 0x0A, 0x33, 0x1C, 0xA6,
1799         0xE6, 0xBD, 0x8A, 0xCF, 0x40, 0xA9, 0xB2, 0xFA,
1800         0x63, 0x27, 0xFD, 0x9B, 0xD9, 0xFC, 0xD5, 0x87,
1801         0x8D, 0x4C, 0xB6, 0xA4, 0xCB, 0xE7, 0x74, 0x55,
1802         0xF4, 0xFB, 0x41, 0x25, 0xB5, 0x4B, 0x0A, 0x1B,
1803         0xB1, 0xD6, 0xB7, 0xD9, 0x47, 0x2A, 0xC3, 0x98,
1804         0x6A, 0xC4, 0x03, 0x73, 0x1F, 0x93, 0x6E, 0x53,
1805         0x19, 0x25, 0x64, 0x15, 0x83, 0xF9, 0x73, 0x2A,
1806         0x74, 0xB4, 0x93, 0x69, 0xC4, 0x72, 0xFC, 0x26,
1807         0xA2, 0x9F, 0x43, 0x45, 0xDD, 0xB9, 0xEF, 0x36,
1808         0xC8, 0x3A, 0xCD, 0x99, 0x9B, 0x54, 0x1A, 0x36,
1809         0xC1, 0x59, 0xF8, 0x98, 0xA8, 0xCC, 0x28, 0x0D,
1810         0x73, 0x4C, 0xEE, 0x98, 0xCB, 0x7C, 0x58, 0x7E,
1811         0x20, 0x75, 0x1E, 0xB7, 0xC9, 0xF8, 0xF2, 0x0E,
1812         0x63, 0x9E, 0x05, 0x78, 0x1A, 0xB6, 0xA8, 0x7A,
1813         0xF9, 0x98, 0x6A, 0xA6, 0x46, 0x84, 0x2E, 0xF6,
1814         0x4B, 0xDC, 0x9B, 0x8F, 0x9B, 0x8F, 0xEE, 0xB4,
1815         0xAA, 0x3F, 0xEE, 0xC0, 0x37, 0x27, 0x76, 0xC7,
1816         0x95, 0xBB, 0x26, 0x74, 0x69, 0x12, 0x7F, 0xF1,
1817         0xBB, 0xFF, 0xAE, 0xB5, 0x99, 0x6E, 0xCB, 0x0C
1818 };
1819
1820 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest[] = {
1821         0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60,
1822         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1823         0x18, 0x8c, 0x1d, 0x32
1824 };
1825
1826
1827 /* Multisession Vector context Test */
1828 /*Begin Session 0 */
1829 static uint8_t ms_aes_cbc_key0[] = {
1830         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1831         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1832 };
1833
1834 static uint8_t ms_aes_cbc_iv0[] = {
1835         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1836         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1837 };
1838
1839 static const uint8_t ms_aes_cbc_cipher0[] = {
1840                 0x3C, 0xE4, 0xEE, 0x42, 0xB6, 0x9B, 0xC3, 0x38,
1841                 0x5F, 0xAD, 0x54, 0xDC, 0xA8, 0x32, 0x81, 0xDC,
1842                 0x7A, 0x6F, 0x85, 0x58, 0x07, 0x35, 0xED, 0xEB,
1843                 0xAD, 0x79, 0x79, 0x96, 0xD3, 0x0E, 0xA6, 0xD9,
1844                 0xAA, 0x86, 0xA4, 0x8F, 0xB5, 0xD6, 0x6E, 0x6D,
1845                 0x0C, 0x91, 0x2F, 0xC4, 0x67, 0x98, 0x0E, 0xC4,
1846                 0x8D, 0x83, 0x68, 0x69, 0xC4, 0xD3, 0x94, 0x34,
1847                 0xC4, 0x5D, 0x60, 0x55, 0x22, 0x87, 0x8F, 0x6F,
1848                 0x17, 0x8E, 0x75, 0xE4, 0x02, 0xF5, 0x1B, 0x99,
1849                 0xC8, 0x39, 0xA9, 0xAB, 0x23, 0x91, 0x12, 0xED,
1850                 0x08, 0xE7, 0xD9, 0x25, 0x89, 0x24, 0x4F, 0x8D,
1851                 0x68, 0xF3, 0x10, 0x39, 0x0A, 0xEE, 0x45, 0x24,
1852                 0xDF, 0x7A, 0x9D, 0x00, 0x25, 0xE5, 0x35, 0x71,
1853                 0x4E, 0x40, 0x59, 0x6F, 0x0A, 0x13, 0xB3, 0x72,
1854                 0x1D, 0x98, 0x63, 0x94, 0x89, 0xA5, 0x39, 0x8E,
1855                 0xD3, 0x9C, 0x8A, 0x7F, 0x71, 0x2F, 0xC7, 0xCD,
1856                 0x81, 0x05, 0xDC, 0xC0, 0x8D, 0xCE, 0x6D, 0x18,
1857                 0x30, 0xC4, 0x72, 0x51, 0xF0, 0x27, 0xC8, 0xF6,
1858                 0x60, 0x5B, 0x7C, 0xB2, 0xE3, 0x49, 0x0C, 0x29,
1859                 0xC6, 0x9F, 0x39, 0x57, 0x80, 0x55, 0x24, 0x2C,
1860                 0x9B, 0x0F, 0x5A, 0xB3, 0x89, 0x55, 0x31, 0x96,
1861                 0x0D, 0xCD, 0xF6, 0x51, 0x03, 0x2D, 0x89, 0x26,
1862                 0x74, 0x44, 0xD6, 0xE8, 0xDC, 0xEA, 0x44, 0x55,
1863                 0x64, 0x71, 0x9C, 0x9F, 0x5D, 0xBA, 0x39, 0x46,
1864                 0xA8, 0x17, 0xA1, 0x9C, 0x52, 0x9D, 0xBC, 0x6B,
1865                 0x4A, 0x98, 0xE6, 0xEA, 0x33, 0xEC, 0x58, 0xB4,
1866                 0x43, 0xF0, 0x32, 0x45, 0xA4, 0xC1, 0x55, 0xB7,
1867                 0x5D, 0xB5, 0x59, 0xB2, 0xE3, 0x96, 0xFF, 0xA5,
1868                 0xAF, 0xE1, 0x86, 0x1B, 0x42, 0xE6, 0x3B, 0xA0,
1869                 0x90, 0x4A, 0xE8, 0x8C, 0x21, 0x7F, 0x36, 0x1E,
1870                 0x5B, 0x65, 0x25, 0xD1, 0xC1, 0x5A, 0xCA, 0x3D,
1871                 0x10, 0xED, 0x2D, 0x79, 0xD0, 0x0F, 0x58, 0x44,
1872                 0x69, 0x81, 0xF5, 0xD4, 0xC9, 0x0F, 0x90, 0x76,
1873                 0x1F, 0x54, 0xD2, 0xD5, 0x97, 0xCE, 0x2C, 0xE3,
1874                 0xEF, 0xF4, 0xB7, 0xC6, 0x3A, 0x87, 0x7F, 0x83,
1875                 0x2A, 0xAF, 0xCD, 0x90, 0x12, 0xA7, 0x7D, 0x85,
1876                 0x1D, 0x62, 0xD3, 0x85, 0x25, 0x05, 0xDB, 0x45,
1877                 0x92, 0xA3, 0xF6, 0xA2, 0xA8, 0x41, 0xE4, 0x25,
1878                 0x86, 0x87, 0x67, 0x24, 0xEC, 0x89, 0x23, 0x2A,
1879                 0x9B, 0x20, 0x4D, 0x93, 0xEE, 0xE2, 0x2E, 0xC1,
1880                 0x0B, 0x15, 0x33, 0xCF, 0x00, 0xD1, 0x1A, 0xDA,
1881                 0x93, 0xFD, 0x28, 0x21, 0x5B, 0xCF, 0xD1, 0xF3,
1882                 0x5A, 0x81, 0xBA, 0x82, 0x5E, 0x2F, 0x61, 0xB4,
1883                 0x05, 0x71, 0xB5, 0xF4, 0x39, 0x3C, 0x1F, 0x60,
1884                 0x00, 0x7A, 0xC4, 0xF8, 0x35, 0x20, 0x6C, 0x3A,
1885                 0xCC, 0x03, 0x8F, 0x7B, 0xA2, 0xB6, 0x65, 0x8A,
1886                 0xB6, 0x5F, 0xFD, 0x25, 0xD3, 0x5F, 0x92, 0xF9,
1887                 0xAE, 0x17, 0x9B, 0x5E, 0x6E, 0x9A, 0xE4, 0x55,
1888                 0x10, 0x25, 0x07, 0xA4, 0xAF, 0x21, 0x69, 0x13,
1889                 0xD8, 0xFA, 0x31, 0xED, 0xF7, 0xA7, 0xA7, 0x3B,
1890                 0xB8, 0x96, 0x8E, 0x10, 0x86, 0x74, 0xD8, 0xB1,
1891                 0x34, 0x9E, 0x9B, 0x6A, 0x26, 0xA8, 0xD4, 0xD0,
1892                 0xB5, 0xF6, 0xDE, 0xE7, 0xCA, 0x06, 0xDC, 0xA3,
1893                 0x6F, 0xEE, 0x6B, 0x1E, 0xB5, 0x30, 0x99, 0x23,
1894                 0xF9, 0x76, 0xF0, 0xA0, 0xCF, 0x3B, 0x94, 0x7B,
1895                 0x19, 0x8D, 0xA5, 0x0C, 0x18, 0xA6, 0x1D, 0x07,
1896                 0x89, 0xBE, 0x5B, 0x61, 0xE5, 0xF1, 0x42, 0xDB,
1897                 0xD4, 0x2E, 0x02, 0x1F, 0xCE, 0xEF, 0x92, 0xB1,
1898                 0x1B, 0x56, 0x50, 0xF2, 0x16, 0xE5, 0xE7, 0x4F,
1899                 0xFD, 0xBB, 0x3E, 0xD2, 0xFC, 0x3C, 0xC6, 0x0F,
1900                 0xF9, 0x12, 0x4E, 0xCB, 0x1E, 0x0C, 0x15, 0x84,
1901                 0x2A, 0x14, 0x8A, 0x02, 0xE4, 0x7E, 0x95, 0x5B,
1902                 0x86, 0xDB, 0x9B, 0x62, 0x5B, 0x19, 0xD2, 0x17,
1903                 0xFA, 0x13, 0xBB, 0x6B, 0x3F, 0x45, 0x9F, 0xBF
1904 };
1905
1906
1907 static  uint8_t ms_hmac_key0[] = {
1908                 0xFF, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1909                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1910                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1911                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1912                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1913                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1914                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1915                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1916 };
1917
1918 static const uint8_t ms_hmac_digest0[] = {
1919                 0x43, 0x52, 0xED, 0x34, 0xAB, 0x36, 0xB2, 0x51,
1920                 0xFB, 0xA3, 0xA6, 0x7C, 0x38, 0xFC, 0x42, 0x8F,
1921                 0x57, 0x64, 0xAB, 0x81, 0xA7, 0x89, 0xB7, 0x6C,
1922                 0xA0, 0xDC, 0xB9, 0x4D, 0xC4, 0x30, 0xF9, 0xD4,
1923                 0x10, 0x82, 0x55, 0xD0, 0xAB, 0x32, 0xFB, 0x56,
1924                 0x0D, 0xE4, 0x68, 0x3D, 0x76, 0xD0, 0x7B, 0xE4,
1925                 0xA6, 0x2C, 0x34, 0x9E, 0x8C, 0x41, 0xF8, 0x23,
1926                 0x28, 0x1B, 0x3A, 0x90, 0x26, 0x34, 0x47, 0x90
1927                 };
1928
1929 /* End Session 0 */
1930 /* Begin session 1 */
1931
1932 static  uint8_t ms_aes_cbc_key1[] = {
1933                 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1934                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1935 };
1936
1937 static  uint8_t ms_aes_cbc_iv1[] = {
1938         0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1939         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1940 };
1941
1942 static const uint8_t ms_aes_cbc_cipher1[] = {
1943                 0x5A, 0x7A, 0x67, 0x5D, 0xB8, 0xE1, 0xDC, 0x71,
1944                 0x39, 0xA8, 0x74, 0x93, 0x9C, 0x4C, 0xFE, 0x23,
1945                 0x61, 0xCD, 0xA4, 0xB3, 0xD9, 0xCE, 0x99, 0x09,
1946                 0x2A, 0x23, 0xF3, 0x29, 0xBF, 0x4C, 0xB4, 0x6A,
1947                 0x1B, 0x6B, 0x73, 0x4D, 0x48, 0x0C, 0xCF, 0x6C,
1948                 0x5E, 0x34, 0x9E, 0x7F, 0xBC, 0x8F, 0xCC, 0x8F,
1949                 0x75, 0x1D, 0x3D, 0x77, 0x10, 0x76, 0xC8, 0xB9,
1950                 0x99, 0x6F, 0xD6, 0x56, 0x75, 0xA9, 0xB2, 0x66,
1951                 0xC2, 0x24, 0x2B, 0x9C, 0xFE, 0x40, 0x8E, 0x43,
1952                 0x20, 0x97, 0x1B, 0xFA, 0xD0, 0xCF, 0x04, 0xAB,
1953                 0xBB, 0xF6, 0x5D, 0xF5, 0xA0, 0x19, 0x7C, 0x23,
1954                 0x5D, 0x80, 0x8C, 0x49, 0xF6, 0x76, 0x88, 0x29,
1955                 0x27, 0x4C, 0x59, 0x2B, 0x43, 0xA6, 0xB2, 0x26,
1956                 0x27, 0x78, 0xBE, 0x1B, 0xE1, 0x4F, 0x5A, 0x1F,
1957                 0xFC, 0x68, 0x08, 0xE7, 0xC4, 0xD1, 0x34, 0x68,
1958                 0xB7, 0x13, 0x14, 0x41, 0x62, 0x6B, 0x1F, 0x77,
1959                 0x0C, 0x68, 0x1D, 0x0D, 0xED, 0x89, 0xAA, 0xD8,
1960                 0x97, 0x02, 0xBA, 0x5E, 0xD4, 0x84, 0x25, 0x97,
1961                 0x03, 0xA5, 0xA6, 0x13, 0x66, 0x02, 0xF4, 0xC3,
1962                 0xF3, 0xD3, 0xCC, 0x95, 0xC3, 0x87, 0x46, 0x90,
1963                 0x1F, 0x6E, 0x14, 0xA8, 0x00, 0xF2, 0x6F, 0xD5,
1964                 0xA1, 0xAD, 0xD5, 0x40, 0xA2, 0x0F, 0x32, 0x7E,
1965                 0x99, 0xA3, 0xF5, 0x53, 0xC3, 0x26, 0xA1, 0x45,
1966                 0x01, 0x88, 0x57, 0x84, 0x3E, 0x7B, 0x4E, 0x0B,
1967                 0x3C, 0xB5, 0x3E, 0x9E, 0xE9, 0x78, 0x77, 0xC5,
1968                 0xC0, 0x89, 0xA8, 0xF8, 0xF1, 0xA5, 0x2D, 0x5D,
1969                 0xF9, 0xC6, 0xFB, 0xCB, 0x05, 0x23, 0xBD, 0x6E,
1970                 0x5E, 0x14, 0xC6, 0x57, 0x73, 0xCF, 0x98, 0xBD,
1971                 0x10, 0x8B, 0x18, 0xA6, 0x01, 0x5B, 0x13, 0xAE,
1972                 0x8E, 0xDE, 0x1F, 0xB5, 0xB7, 0x40, 0x6C, 0xC1,
1973                 0x1E, 0xA1, 0x19, 0x20, 0x9E, 0x95, 0xE0, 0x2F,
1974                 0x1C, 0xF5, 0xD9, 0xD0, 0x2B, 0x1E, 0x82, 0x25,
1975                 0x62, 0xB4, 0xEB, 0xA1, 0x1F, 0xCE, 0x44, 0xA1,
1976                 0xCB, 0x92, 0x01, 0x6B, 0xE4, 0x26, 0x23, 0xE3,
1977                 0xC5, 0x67, 0x35, 0x55, 0xDA, 0xE5, 0x27, 0xEE,
1978                 0x8D, 0x12, 0x84, 0xB7, 0xBA, 0xA7, 0x1C, 0xD6,
1979                 0x32, 0x3F, 0x67, 0xED, 0xFB, 0x5B, 0x8B, 0x52,
1980                 0x46, 0x8C, 0xF9, 0x69, 0xCD, 0xAE, 0x79, 0xAA,
1981                 0x37, 0x78, 0x49, 0xEB, 0xC6, 0x8E, 0x76, 0x63,
1982                 0x84, 0xFF, 0x9D, 0x22, 0x99, 0x51, 0xB7, 0x5E,
1983                 0x83, 0x4C, 0x8B, 0xDF, 0x5A, 0x07, 0xCC, 0xBA,
1984                 0x42, 0xA5, 0x98, 0xB6, 0x47, 0x0E, 0x66, 0xEB,
1985                 0x23, 0x0E, 0xBA, 0x44, 0xA8, 0xAA, 0x20, 0x71,
1986                 0x79, 0x9C, 0x77, 0x5F, 0xF5, 0xFE, 0xEC, 0xEF,
1987                 0xC6, 0x64, 0x3D, 0x84, 0xD0, 0x2B, 0xA7, 0x0A,
1988                 0xC3, 0x72, 0x5B, 0x9C, 0xFA, 0xA8, 0x87, 0x95,
1989                 0x94, 0x11, 0x38, 0xA7, 0x1E, 0x58, 0xE3, 0x73,
1990                 0xC6, 0xC9, 0xD1, 0x7B, 0x92, 0xDB, 0x0F, 0x49,
1991                 0x74, 0xC2, 0xA2, 0x0E, 0x35, 0x57, 0xAC, 0xDB,
1992                 0x9A, 0x1C, 0xCF, 0x5A, 0x32, 0x3E, 0x26, 0x9B,
1993                 0xEC, 0xB3, 0xEF, 0x9C, 0xFE, 0xBE, 0x52, 0xAC,
1994                 0xB1, 0x29, 0xDD, 0xFD, 0x07, 0xE2, 0xEE, 0xED,
1995                 0xE4, 0x46, 0x37, 0xFE, 0xD1, 0xDC, 0xCD, 0x02,
1996                 0xF9, 0x31, 0xB0, 0xFB, 0x36, 0xB7, 0x34, 0xA4,
1997                 0x76, 0xE8, 0x57, 0xBF, 0x99, 0x92, 0xC7, 0xAF,
1998                 0x98, 0x10, 0xE2, 0x70, 0xCA, 0xC9, 0x2B, 0x82,
1999                 0x06, 0x96, 0x88, 0x0D, 0xB3, 0xAC, 0x9E, 0x6D,
2000                 0x43, 0xBC, 0x5B, 0x31, 0xCF, 0x65, 0x8D, 0xA6,
2001                 0xC7, 0xFE, 0x73, 0xE1, 0x54, 0xF7, 0x10, 0xF9,
2002                 0x86, 0xF7, 0xDF, 0xA1, 0xA1, 0xD8, 0xAE, 0x35,
2003                 0xB3, 0x90, 0xDC, 0x6F, 0x43, 0x7A, 0x8B, 0xE0,
2004                 0xFE, 0x8F, 0x33, 0x4D, 0x29, 0x6C, 0x45, 0x53,
2005                 0x73, 0xDD, 0x21, 0x0B, 0x85, 0x30, 0xB5, 0xA5,
2006                 0xF3, 0x5D, 0xEC, 0x79, 0x61, 0x9D, 0x9E, 0xB3
2007
2008 };
2009
2010 static uint8_t ms_hmac_key1[] = {
2011                 0xFE, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
2012                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
2013                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
2014                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
2015                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
2016                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
2017                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
2018                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
2019 };
2020
2021 static const uint8_t ms_hmac_digest1[] = {
2022                 0xCE, 0x6E, 0x5F, 0x77, 0x96, 0x9A, 0xB1, 0x69,
2023                 0x2D, 0x5E, 0xF3, 0x2F, 0x32, 0x10, 0xCB, 0x50,
2024                 0x0E, 0x09, 0x56, 0x25, 0x07, 0x34, 0xC9, 0x20,
2025                 0xEC, 0x13, 0x43, 0x23, 0x5C, 0x08, 0x8B, 0xCD,
2026                 0xDC, 0x86, 0x8C, 0xEE, 0x0A, 0x95, 0x2E, 0xB9,
2027                 0x8C, 0x7B, 0x02, 0x7A, 0xD4, 0xE1, 0x49, 0xB4,
2028                 0x45, 0xB5, 0x52, 0x37, 0xC6, 0xFF, 0xFE, 0xAA,
2029                 0x0A, 0x87, 0xB8, 0x51, 0xF9, 0x2A, 0x01, 0x8F
2030 };
2031 /* End Session 1  */
2032 /* Begin Session 2 */
2033 static  uint8_t ms_aes_cbc_key2[] = {
2034                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
2035                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
2036 };
2037
2038 static  uint8_t ms_aes_cbc_iv2[] = {
2039                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
2040                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
2041 };
2042
2043 static const uint8_t ms_aes_cbc_cipher2[] = {
2044                 0xBB, 0x3C, 0x68, 0x25, 0xFD, 0xB6, 0xA2, 0x91,
2045                 0x20, 0x56, 0xF6, 0x30, 0x35, 0xFC, 0x9E, 0x97,
2046                 0xF2, 0x90, 0xFC, 0x7E, 0x3E, 0x0A, 0x75, 0xC8,
2047                 0x4C, 0xF2, 0x2D, 0xAC, 0xD3, 0x93, 0xF0, 0xC5,
2048                 0x14, 0x88, 0x8A, 0x23, 0xC2, 0x59, 0x9A, 0x98,
2049                 0x4B, 0xD5, 0x2C, 0xDA, 0x43, 0xA9, 0x34, 0x69,
2050                 0x7C, 0x6D, 0xDB, 0xDC, 0xCB, 0xC0, 0xA0, 0x09,
2051                 0xA7, 0x86, 0x16, 0x4B, 0xBF, 0xA8, 0xB6, 0xCF,
2052                 0x7F, 0x74, 0x1F, 0x22, 0xF0, 0xF6, 0xBB, 0x44,
2053                 0x8B, 0x4C, 0x9E, 0x23, 0xF8, 0x9F, 0xFC, 0x5B,
2054                 0x9E, 0x9C, 0x2A, 0x79, 0x30, 0x8F, 0xBF, 0xA9,
2055                 0x68, 0xA1, 0x20, 0x71, 0x7C, 0x77, 0x22, 0x34,
2056                 0x07, 0xCD, 0xC6, 0xF6, 0x50, 0x0A, 0x08, 0x99,
2057                 0x17, 0x98, 0xE3, 0x93, 0x8A, 0xB0, 0xEE, 0xDF,
2058                 0xC2, 0xBA, 0x3B, 0x44, 0x73, 0xDF, 0xDD, 0xDC,
2059                 0x14, 0x4D, 0x3B, 0xBB, 0x5E, 0x58, 0xC1, 0x26,
2060                 0xA7, 0xAE, 0x47, 0xF3, 0x24, 0x6D, 0x4F, 0xD3,
2061                 0x6E, 0x3E, 0x33, 0xE6, 0x7F, 0xCA, 0x50, 0xAF,
2062                 0x5D, 0x3D, 0xA0, 0xDD, 0xC9, 0xF3, 0x30, 0xD3,
2063                 0x6E, 0x8B, 0x2E, 0x12, 0x24, 0x34, 0xF0, 0xD3,
2064                 0xC7, 0x8D, 0x23, 0x29, 0xAA, 0x05, 0xE1, 0xFA,
2065                 0x2E, 0xF6, 0x8D, 0x37, 0x86, 0xC0, 0x6D, 0x13,
2066                 0x2D, 0x98, 0xF3, 0x52, 0x39, 0x22, 0xCE, 0x38,
2067                 0xC2, 0x1A, 0x72, 0xED, 0xFB, 0xCC, 0xE4, 0x71,
2068                 0x5A, 0x0C, 0x0D, 0x09, 0xF8, 0xE8, 0x1B, 0xBC,
2069                 0x53, 0xC8, 0xD8, 0x8F, 0xE5, 0x98, 0x5A, 0xB1,
2070                 0x06, 0xA6, 0x5B, 0xE6, 0xA2, 0x88, 0x21, 0x9E,
2071                 0x36, 0xC0, 0x34, 0xF9, 0xFB, 0x3B, 0x0A, 0x22,
2072                 0x00, 0x00, 0x39, 0x48, 0x8D, 0x23, 0x74, 0x62,
2073                 0x72, 0x91, 0xE6, 0x36, 0xAA, 0x77, 0x9C, 0x72,
2074                 0x9D, 0xA8, 0xC3, 0xA9, 0xD5, 0x44, 0x72, 0xA6,
2075                 0xB9, 0x28, 0x8F, 0x64, 0x4C, 0x8A, 0x64, 0xE6,
2076                 0x4E, 0xFA, 0xEF, 0x87, 0xDE, 0x7B, 0x22, 0x44,
2077                 0xB0, 0xDF, 0x2E, 0x5F, 0x0B, 0xA5, 0xF2, 0x24,
2078                 0x07, 0x5C, 0x2D, 0x39, 0xB7, 0x3D, 0x8A, 0xE5,
2079                 0x0E, 0x9D, 0x4E, 0x50, 0xED, 0x03, 0x99, 0x8E,
2080                 0xF0, 0x06, 0x55, 0x4E, 0xA2, 0x24, 0xE7, 0x17,
2081                 0x46, 0xDF, 0x6C, 0xCD, 0xC6, 0x44, 0xE8, 0xF9,
2082                 0xB9, 0x1B, 0x36, 0xF6, 0x7F, 0x10, 0xA4, 0x7D,
2083                 0x90, 0xBD, 0xE4, 0xAA, 0xD6, 0x9E, 0x18, 0x9D,
2084                 0x22, 0x35, 0xD6, 0x55, 0x54, 0xAA, 0xF7, 0x22,
2085                 0xA3, 0x3E, 0xEF, 0xC8, 0xA2, 0x34, 0x8D, 0xA9,
2086                 0x37, 0x63, 0xA6, 0xC3, 0x57, 0xCB, 0x0C, 0x49,
2087                 0x7D, 0x02, 0xBE, 0xAA, 0x13, 0x75, 0xB7, 0x4E,
2088                 0x52, 0x62, 0xA5, 0xC2, 0x33, 0xC7, 0x6C, 0x1B,
2089                 0xF6, 0x34, 0xF6, 0x09, 0xA5, 0x0C, 0xC7, 0xA2,
2090                 0x61, 0x48, 0x62, 0x7D, 0x17, 0x15, 0xE3, 0x95,
2091                 0xC8, 0x63, 0xD2, 0xA4, 0x43, 0xA9, 0x49, 0x07,
2092                 0xB2, 0x3B, 0x2B, 0x62, 0x7D, 0xCB, 0x51, 0xB3,
2093                 0x25, 0x33, 0x47, 0x0E, 0x14, 0x67, 0xDC, 0x6A,
2094                 0x9B, 0x51, 0xAC, 0x9D, 0x8F, 0xA2, 0x2B, 0x57,
2095                 0x8C, 0x5C, 0x5F, 0x76, 0x23, 0x92, 0x0F, 0x84,
2096                 0x46, 0x0E, 0x40, 0x85, 0x38, 0x60, 0xFA, 0x61,
2097                 0x20, 0xC5, 0xE3, 0xF1, 0x70, 0xAC, 0x1B, 0xBF,
2098                 0xC4, 0x2B, 0xC5, 0x67, 0xD1, 0x43, 0xC5, 0x17,
2099                 0x74, 0x71, 0x69, 0x6F, 0x82, 0x89, 0x19, 0x8A,
2100                 0x70, 0x43, 0x92, 0x01, 0xC4, 0x63, 0x7E, 0xB1,
2101                 0x59, 0x4E, 0xCD, 0xEA, 0x93, 0xA4, 0x52, 0x53,
2102                 0x9B, 0x61, 0x5B, 0xD2, 0x3E, 0x19, 0x39, 0xB7,
2103                 0x32, 0xEA, 0x8E, 0xF8, 0x1D, 0x76, 0x5C, 0xB2,
2104                 0x73, 0x2D, 0x91, 0xC0, 0x18, 0xED, 0x25, 0x2A,
2105                 0x53, 0x64, 0xF0, 0x92, 0x31, 0x55, 0x21, 0xA8,
2106                 0x24, 0xA9, 0xD1, 0x02, 0xF6, 0x6C, 0x2B, 0x70,
2107                 0xA9, 0x59, 0xC1, 0xD6, 0xC3, 0x57, 0x5B, 0x92
2108 };
2109
2110 static  uint8_t ms_hmac_key2[] = {
2111                 0xFC, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
2112                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
2113                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
2114                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
2115                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
2116                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
2117                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
2118                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
2119 };
2120
2121 static const uint8_t ms_hmac_digest2[] = {
2122                 0xA5, 0x0F, 0x9C, 0xFB, 0x08, 0x62, 0x59, 0xFF,
2123                 0x80, 0x2F, 0xEB, 0x4B, 0xE1, 0x46, 0x21, 0xD6,
2124                 0x02, 0x98, 0xF2, 0x8E, 0xF4, 0xEC, 0xD4, 0x77,
2125                 0x86, 0x4C, 0x31, 0x28, 0xC8, 0x25, 0x80, 0x27,
2126                 0x3A, 0x72, 0x5D, 0x6A, 0x56, 0x8A, 0xD3, 0x82,
2127                 0xB0, 0xEC, 0x31, 0x6D, 0x8B, 0x6B, 0xB4, 0x24,
2128                 0xE7, 0x62, 0xC1, 0x52, 0xBC, 0x14, 0x1B, 0x8E,
2129                 0xEC, 0x9A, 0xF1, 0x47, 0x80, 0xD2, 0xB0, 0x59
2130 };
2131
2132 /* End Session 2 */
2133
2134
2135 static int
2136 test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
2137 {
2138         struct crypto_testsuite_params *ts_params = &testsuite_params;
2139         struct crypto_unittest_params *ut_params = &unittest_params;
2140         int status;
2141
2142         /* Verify the capabilities */
2143         struct rte_cryptodev_sym_capability_idx cap_idx;
2144         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2145         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
2146         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2147                         &cap_idx) == NULL)
2148                 return TEST_SKIPPED;
2149         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2150         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
2151         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2152                         &cap_idx) == NULL)
2153                 return TEST_SKIPPED;
2154
2155         /* Generate test mbuf data and space for digest */
2156         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
2157                         catch_22_quote, QUOTE_512_BYTES, 0);
2158
2159         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2160                         DIGEST_BYTE_LENGTH_SHA1);
2161         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
2162
2163         /* Setup Cipher Parameters */
2164         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2165         ut_params->cipher_xform.next = &ut_params->auth_xform;
2166
2167         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
2168         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2169         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
2170         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
2171         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2172         ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
2173
2174         /* Setup HMAC Parameters */
2175         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2176
2177         ut_params->auth_xform.next = NULL;
2178
2179         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2180         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
2181         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1;
2182         ut_params->auth_xform.auth.key.data = hmac_sha1_key;
2183         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
2184
2185         ut_params->sess = rte_cryptodev_sym_session_create(
2186                         ts_params->session_mpool);
2187         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2188
2189         /* Create crypto session*/
2190         status = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
2191                         ut_params->sess, &ut_params->cipher_xform,
2192                         ts_params->session_priv_mpool);
2193
2194         if (status == -ENOTSUP)
2195                 return TEST_SKIPPED;
2196
2197         TEST_ASSERT_EQUAL(status, 0, "Session init failed");
2198
2199         /* Generate crypto op data structure */
2200         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2201                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2202         TEST_ASSERT_NOT_NULL(ut_params->op,
2203                         "Failed to allocate symmetric crypto operation struct");
2204
2205         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2206
2207         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2208
2209         /* set crypto operation source mbuf */
2210         sym_op->m_src = ut_params->ibuf;
2211
2212         /* Set crypto operation authentication parameters */
2213         sym_op->auth.digest.data = ut_params->digest;
2214         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2215                         ut_params->ibuf, QUOTE_512_BYTES);
2216
2217         sym_op->auth.data.offset = 0;
2218         sym_op->auth.data.length = QUOTE_512_BYTES;
2219
2220         /* Copy IV at the end of the crypto operation */
2221         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2222                         aes_cbc_iv, CIPHER_IV_LENGTH_AES_CBC);
2223
2224         /* Set crypto operation cipher parameters */
2225         sym_op->cipher.data.offset = 0;
2226         sym_op->cipher.data.length = QUOTE_512_BYTES;
2227
2228         /* Process crypto operation */
2229         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2230                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
2231                         ut_params->op);
2232         else
2233                 TEST_ASSERT_NOT_NULL(
2234                         process_crypto_request(ts_params->valid_devs[0],
2235                                 ut_params->op),
2236                                 "failed to process sym crypto op");
2237
2238         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2239                         "crypto op processing failed");
2240
2241         /* Validate obuf */
2242         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
2243                         uint8_t *);
2244
2245         TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext,
2246                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
2247                         QUOTE_512_BYTES,
2248                         "ciphertext data not as expected");
2249
2250         uint8_t *digest = ciphertext + QUOTE_512_BYTES;
2251
2252         TEST_ASSERT_BUFFERS_ARE_EQUAL(digest,
2253                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
2254                         gbl_driver_id == rte_cryptodev_driver_id_get(
2255                                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) ?
2256                                         TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
2257                                         DIGEST_BYTE_LENGTH_SHA1,
2258                         "Generated digest data not as expected");
2259
2260         return TEST_SUCCESS;
2261 }
2262
2263 /* ***** AES-CBC / HMAC-SHA512 Hash Tests ***** */
2264
2265 #define HMAC_KEY_LENGTH_SHA512  (DIGEST_BYTE_LENGTH_SHA512)
2266
2267 static uint8_t hmac_sha512_key[] = {
2268         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
2269         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
2270         0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
2271         0x9a, 0xaf, 0x88, 0x1b, 0xb6, 0x8f, 0xf8, 0x60,
2272         0xa2, 0x5a, 0x7f, 0x3f, 0xf4, 0x72, 0x70, 0xf1,
2273         0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
2274         0x47, 0x3a, 0x75, 0x61, 0x5C, 0xa2, 0x10, 0x76,
2275         0x9a, 0xaf, 0x77, 0x5b, 0xb6, 0x7f, 0xf7, 0x60 };
2276
2277 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest[] = {
2278         0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8,
2279         0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48,
2280         0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8,
2281         0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70,
2282         0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8,
2283         0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E,
2284         0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D,
2285         0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A };
2286
2287
2288
2289 static int
2290 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
2291                 struct crypto_unittest_params *ut_params,
2292                 uint8_t *cipher_key,
2293                 uint8_t *hmac_key);
2294
2295 static int
2296 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
2297                 struct crypto_unittest_params *ut_params,
2298                 struct crypto_testsuite_params *ts_params,
2299                 const uint8_t *cipher,
2300                 const uint8_t *digest,
2301                 const uint8_t *iv);
2302
2303
2304 static int
2305 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
2306                 struct crypto_unittest_params *ut_params,
2307                 uint8_t *cipher_key,
2308                 uint8_t *hmac_key)
2309 {
2310
2311         /* Setup Cipher Parameters */
2312         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2313         ut_params->cipher_xform.next = NULL;
2314
2315         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
2316         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
2317         ut_params->cipher_xform.cipher.key.data = cipher_key;
2318         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
2319         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2320         ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
2321
2322         /* Setup HMAC Parameters */
2323         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2324         ut_params->auth_xform.next = &ut_params->cipher_xform;
2325
2326         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
2327         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC;
2328         ut_params->auth_xform.auth.key.data = hmac_key;
2329         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512;
2330         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512;
2331
2332         return TEST_SUCCESS;
2333 }
2334
2335
2336 static int
2337 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
2338                 struct crypto_unittest_params *ut_params,
2339                 struct crypto_testsuite_params *ts_params,
2340                 const uint8_t *cipher,
2341                 const uint8_t *digest,
2342                 const uint8_t *iv)
2343 {
2344         /* Generate test mbuf data and digest */
2345         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
2346                         (const char *)
2347                         cipher,
2348                         QUOTE_512_BYTES, 0);
2349
2350         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2351                         DIGEST_BYTE_LENGTH_SHA512);
2352         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
2353
2354         rte_memcpy(ut_params->digest,
2355                         digest,
2356                         DIGEST_BYTE_LENGTH_SHA512);
2357
2358         /* Generate Crypto op data structure */
2359         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2360                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2361         TEST_ASSERT_NOT_NULL(ut_params->op,
2362                         "Failed to allocate symmetric crypto operation struct");
2363
2364         rte_crypto_op_attach_sym_session(ut_params->op, sess);
2365
2366         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2367
2368         /* set crypto operation source mbuf */
2369         sym_op->m_src = ut_params->ibuf;
2370
2371         sym_op->auth.digest.data = ut_params->digest;
2372         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2373                         ut_params->ibuf, QUOTE_512_BYTES);
2374
2375         sym_op->auth.data.offset = 0;
2376         sym_op->auth.data.length = QUOTE_512_BYTES;
2377
2378         /* Copy IV at the end of the crypto operation */
2379         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2380                         iv, CIPHER_IV_LENGTH_AES_CBC);
2381
2382         sym_op->cipher.data.offset = 0;
2383         sym_op->cipher.data.length = QUOTE_512_BYTES;
2384
2385         /* Process crypto operation */
2386         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2387                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
2388                         ut_params->op);
2389         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
2390                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
2391                                 ut_params->op, 1, 1, 0, 0);
2392         else
2393                 TEST_ASSERT_NOT_NULL(
2394                                 process_crypto_request(ts_params->valid_devs[0],
2395                                         ut_params->op),
2396                                         "failed to process sym crypto op");
2397
2398         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2399                         "crypto op processing failed");
2400
2401         ut_params->obuf = ut_params->op->sym->m_src;
2402
2403         /* Validate obuf */
2404         TEST_ASSERT_BUFFERS_ARE_EQUAL(
2405                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *),
2406                         catch_22_quote,
2407                         QUOTE_512_BYTES,
2408                         "Plaintext data not as expected");
2409
2410         /* Validate obuf */
2411         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2412                         "Digest verification failed");
2413
2414         return TEST_SUCCESS;
2415 }
2416
2417 /* ***** SNOW 3G Tests ***** */
2418 static int
2419 create_wireless_algo_hash_session(uint8_t dev_id,
2420         const uint8_t *key, const uint8_t key_len,
2421         const uint8_t iv_len, const uint8_t auth_len,
2422         enum rte_crypto_auth_operation op,
2423         enum rte_crypto_auth_algorithm algo)
2424 {
2425         uint8_t hash_key[key_len];
2426         int status;
2427
2428         struct crypto_testsuite_params *ts_params = &testsuite_params;
2429         struct crypto_unittest_params *ut_params = &unittest_params;
2430
2431         memcpy(hash_key, key, key_len);
2432
2433         debug_hexdump(stdout, "key:", key, key_len);
2434
2435         /* Setup Authentication Parameters */
2436         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2437         ut_params->auth_xform.next = NULL;
2438
2439         ut_params->auth_xform.auth.op = op;
2440         ut_params->auth_xform.auth.algo = algo;
2441         ut_params->auth_xform.auth.key.length = key_len;
2442         ut_params->auth_xform.auth.key.data = hash_key;
2443         ut_params->auth_xform.auth.digest_length = auth_len;
2444         ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
2445         ut_params->auth_xform.auth.iv.length = iv_len;
2446         ut_params->sess = rte_cryptodev_sym_session_create(
2447                         ts_params->session_mpool);
2448
2449         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2450                         &ut_params->auth_xform,
2451                         ts_params->session_priv_mpool);
2452         if (status == -ENOTSUP)
2453                 return TEST_SKIPPED;
2454
2455         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2456         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2457         return 0;
2458 }
2459
2460 static int
2461 create_wireless_algo_cipher_session(uint8_t dev_id,
2462                         enum rte_crypto_cipher_operation op,
2463                         enum rte_crypto_cipher_algorithm algo,
2464                         const uint8_t *key, const uint8_t key_len,
2465                         uint8_t iv_len)
2466 {
2467         uint8_t cipher_key[key_len];
2468         int status;
2469         struct crypto_testsuite_params *ts_params = &testsuite_params;
2470         struct crypto_unittest_params *ut_params = &unittest_params;
2471
2472         memcpy(cipher_key, key, key_len);
2473
2474         /* Setup Cipher Parameters */
2475         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2476         ut_params->cipher_xform.next = NULL;
2477
2478         ut_params->cipher_xform.cipher.algo = algo;
2479         ut_params->cipher_xform.cipher.op = op;
2480         ut_params->cipher_xform.cipher.key.data = cipher_key;
2481         ut_params->cipher_xform.cipher.key.length = key_len;
2482         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2483         ut_params->cipher_xform.cipher.iv.length = iv_len;
2484
2485         debug_hexdump(stdout, "key:", key, key_len);
2486
2487         /* Create Crypto session */
2488         ut_params->sess = rte_cryptodev_sym_session_create(
2489                         ts_params->session_mpool);
2490
2491         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2492                         &ut_params->cipher_xform,
2493                         ts_params->session_priv_mpool);
2494         if (status == -ENOTSUP)
2495                 return TEST_SKIPPED;
2496
2497         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2498         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2499         return 0;
2500 }
2501
2502 static int
2503 create_wireless_algo_cipher_operation(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
2524         /* iv */
2525         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2526                         iv, iv_len);
2527         sym_op->cipher.data.length = cipher_len;
2528         sym_op->cipher.data.offset = cipher_offset;
2529         return 0;
2530 }
2531
2532 static int
2533 create_wireless_algo_cipher_operation_oop(const uint8_t *iv, uint8_t iv_len,
2534                         unsigned int cipher_len,
2535                         unsigned int cipher_offset)
2536 {
2537         struct crypto_testsuite_params *ts_params = &testsuite_params;
2538         struct crypto_unittest_params *ut_params = &unittest_params;
2539
2540         /* Generate Crypto op data structure */
2541         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2542                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2543         TEST_ASSERT_NOT_NULL(ut_params->op,
2544                                 "Failed to allocate pktmbuf offload");
2545
2546         /* Set crypto operation data parameters */
2547         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2548
2549         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2550
2551         /* set crypto operation source mbuf */
2552         sym_op->m_src = ut_params->ibuf;
2553         sym_op->m_dst = ut_params->obuf;
2554
2555         /* iv */
2556         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2557                         iv, iv_len);
2558         sym_op->cipher.data.length = cipher_len;
2559         sym_op->cipher.data.offset = cipher_offset;
2560         return 0;
2561 }
2562
2563 static int
2564 create_wireless_algo_cipher_auth_session(uint8_t dev_id,
2565                 enum rte_crypto_cipher_operation cipher_op,
2566                 enum rte_crypto_auth_operation auth_op,
2567                 enum rte_crypto_auth_algorithm auth_algo,
2568                 enum rte_crypto_cipher_algorithm cipher_algo,
2569                 const uint8_t *key, uint8_t key_len,
2570                 uint8_t auth_iv_len, uint8_t auth_len,
2571                 uint8_t cipher_iv_len)
2572
2573 {
2574         uint8_t cipher_auth_key[key_len];
2575         int status;
2576
2577         struct crypto_testsuite_params *ts_params = &testsuite_params;
2578         struct crypto_unittest_params *ut_params = &unittest_params;
2579
2580         memcpy(cipher_auth_key, key, key_len);
2581
2582         /* Setup Authentication Parameters */
2583         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2584         ut_params->auth_xform.next = NULL;
2585
2586         ut_params->auth_xform.auth.op = auth_op;
2587         ut_params->auth_xform.auth.algo = auth_algo;
2588         ut_params->auth_xform.auth.key.length = key_len;
2589         /* Hash key = cipher key */
2590         ut_params->auth_xform.auth.key.data = cipher_auth_key;
2591         ut_params->auth_xform.auth.digest_length = auth_len;
2592         /* Auth IV will be after cipher IV */
2593         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2594         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2595
2596         /* Setup Cipher Parameters */
2597         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2598         ut_params->cipher_xform.next = &ut_params->auth_xform;
2599
2600         ut_params->cipher_xform.cipher.algo = cipher_algo;
2601         ut_params->cipher_xform.cipher.op = cipher_op;
2602         ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2603         ut_params->cipher_xform.cipher.key.length = key_len;
2604         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2605         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2606
2607         debug_hexdump(stdout, "key:", key, key_len);
2608
2609         /* Create Crypto session*/
2610         ut_params->sess = rte_cryptodev_sym_session_create(
2611                         ts_params->session_mpool);
2612         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2613
2614         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2615                         &ut_params->cipher_xform,
2616                         ts_params->session_priv_mpool);
2617         if (status == -ENOTSUP)
2618                 return TEST_SKIPPED;
2619
2620         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2621         return 0;
2622 }
2623
2624 static int
2625 create_wireless_cipher_auth_session(uint8_t dev_id,
2626                 enum rte_crypto_cipher_operation cipher_op,
2627                 enum rte_crypto_auth_operation auth_op,
2628                 enum rte_crypto_auth_algorithm auth_algo,
2629                 enum rte_crypto_cipher_algorithm cipher_algo,
2630                 const struct wireless_test_data *tdata)
2631 {
2632         const uint8_t key_len = tdata->key.len;
2633         uint8_t cipher_auth_key[key_len];
2634         int status;
2635
2636         struct crypto_testsuite_params *ts_params = &testsuite_params;
2637         struct crypto_unittest_params *ut_params = &unittest_params;
2638         const uint8_t *key = tdata->key.data;
2639         const uint8_t auth_len = tdata->digest.len;
2640         uint8_t cipher_iv_len = tdata->cipher_iv.len;
2641         uint8_t auth_iv_len = tdata->auth_iv.len;
2642
2643         memcpy(cipher_auth_key, key, key_len);
2644
2645         /* Setup Authentication Parameters */
2646         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2647         ut_params->auth_xform.next = NULL;
2648
2649         ut_params->auth_xform.auth.op = auth_op;
2650         ut_params->auth_xform.auth.algo = auth_algo;
2651         ut_params->auth_xform.auth.key.length = key_len;
2652         /* Hash key = cipher key */
2653         ut_params->auth_xform.auth.key.data = cipher_auth_key;
2654         ut_params->auth_xform.auth.digest_length = auth_len;
2655         /* Auth IV will be after cipher IV */
2656         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2657         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2658
2659         /* Setup Cipher Parameters */
2660         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2661         ut_params->cipher_xform.next = &ut_params->auth_xform;
2662
2663         ut_params->cipher_xform.cipher.algo = cipher_algo;
2664         ut_params->cipher_xform.cipher.op = cipher_op;
2665         ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2666         ut_params->cipher_xform.cipher.key.length = key_len;
2667         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2668         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2669
2670
2671         debug_hexdump(stdout, "key:", key, key_len);
2672
2673         /* Create Crypto session*/
2674         ut_params->sess = rte_cryptodev_sym_session_create(
2675                         ts_params->session_mpool);
2676
2677         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2678                         &ut_params->cipher_xform,
2679                         ts_params->session_priv_mpool);
2680         if (status == -ENOTSUP)
2681                 return TEST_SKIPPED;
2682
2683         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2684         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2685         return 0;
2686 }
2687
2688 static int
2689 create_zuc_cipher_auth_encrypt_generate_session(uint8_t dev_id,
2690                 const struct wireless_test_data *tdata)
2691 {
2692         return create_wireless_cipher_auth_session(dev_id,
2693                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2694                 RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_ZUC_EIA3,
2695                 RTE_CRYPTO_CIPHER_ZUC_EEA3, tdata);
2696 }
2697
2698 static int
2699 create_wireless_algo_auth_cipher_session(uint8_t dev_id,
2700                 enum rte_crypto_cipher_operation cipher_op,
2701                 enum rte_crypto_auth_operation auth_op,
2702                 enum rte_crypto_auth_algorithm auth_algo,
2703                 enum rte_crypto_cipher_algorithm cipher_algo,
2704                 const uint8_t *key, const uint8_t key_len,
2705                 uint8_t auth_iv_len, uint8_t auth_len,
2706                 uint8_t cipher_iv_len)
2707 {
2708         uint8_t auth_cipher_key[key_len];
2709         int status;
2710         struct crypto_testsuite_params *ts_params = &testsuite_params;
2711         struct crypto_unittest_params *ut_params = &unittest_params;
2712
2713         memcpy(auth_cipher_key, key, key_len);
2714
2715         /* Setup Authentication Parameters */
2716         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2717         ut_params->auth_xform.auth.op = auth_op;
2718         ut_params->auth_xform.next = &ut_params->cipher_xform;
2719         ut_params->auth_xform.auth.algo = auth_algo;
2720         ut_params->auth_xform.auth.key.length = key_len;
2721         ut_params->auth_xform.auth.key.data = auth_cipher_key;
2722         ut_params->auth_xform.auth.digest_length = auth_len;
2723         /* Auth IV will be after cipher IV */
2724         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2725         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2726
2727         /* Setup Cipher Parameters */
2728         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2729         ut_params->cipher_xform.next = NULL;
2730         ut_params->cipher_xform.cipher.algo = cipher_algo;
2731         ut_params->cipher_xform.cipher.op = cipher_op;
2732         ut_params->cipher_xform.cipher.key.data = auth_cipher_key;
2733         ut_params->cipher_xform.cipher.key.length = key_len;
2734         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2735         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2736
2737         debug_hexdump(stdout, "key:", key, key_len);
2738
2739         /* Create Crypto session*/
2740         ut_params->sess = rte_cryptodev_sym_session_create(
2741                         ts_params->session_mpool);
2742         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2743
2744         if (cipher_op == RTE_CRYPTO_CIPHER_OP_DECRYPT) {
2745                 ut_params->auth_xform.next = NULL;
2746                 ut_params->cipher_xform.next = &ut_params->auth_xform;
2747                 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2748                                 &ut_params->cipher_xform,
2749                                 ts_params->session_priv_mpool);
2750
2751         } else
2752                 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2753                                 &ut_params->auth_xform,
2754                                 ts_params->session_priv_mpool);
2755
2756         if (status == -ENOTSUP)
2757                 return TEST_SKIPPED;
2758
2759         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2760
2761         return 0;
2762 }
2763
2764 static int
2765 create_wireless_algo_hash_operation(const uint8_t *auth_tag,
2766                 unsigned int auth_tag_len,
2767                 const uint8_t *iv, unsigned int iv_len,
2768                 unsigned int data_pad_len,
2769                 enum rte_crypto_auth_operation op,
2770                 unsigned int auth_len, unsigned int auth_offset)
2771 {
2772         struct crypto_testsuite_params *ts_params = &testsuite_params;
2773
2774         struct crypto_unittest_params *ut_params = &unittest_params;
2775
2776         /* Generate Crypto op data structure */
2777         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2778                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2779         TEST_ASSERT_NOT_NULL(ut_params->op,
2780                 "Failed to allocate pktmbuf offload");
2781
2782         /* Set crypto operation data parameters */
2783         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2784
2785         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2786
2787         /* set crypto operation source mbuf */
2788         sym_op->m_src = ut_params->ibuf;
2789
2790         /* iv */
2791         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2792                         iv, iv_len);
2793         /* digest */
2794         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2795                                         ut_params->ibuf, auth_tag_len);
2796
2797         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2798                                 "no room to append auth tag");
2799         ut_params->digest = sym_op->auth.digest.data;
2800         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2801                         ut_params->ibuf, data_pad_len);
2802         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2803                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2804         else
2805                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2806
2807         debug_hexdump(stdout, "digest:",
2808                 sym_op->auth.digest.data,
2809                 auth_tag_len);
2810
2811         sym_op->auth.data.length = auth_len;
2812         sym_op->auth.data.offset = auth_offset;
2813
2814         return 0;
2815 }
2816
2817 static int
2818 create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata,
2819         enum rte_crypto_auth_operation op)
2820 {
2821         struct crypto_testsuite_params *ts_params = &testsuite_params;
2822         struct crypto_unittest_params *ut_params = &unittest_params;
2823
2824         const uint8_t *auth_tag = tdata->digest.data;
2825         const unsigned int auth_tag_len = tdata->digest.len;
2826         unsigned int plaintext_len = ceil_byte_length(tdata->plaintext.len);
2827         unsigned int data_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2828
2829         const uint8_t *cipher_iv = tdata->cipher_iv.data;
2830         const uint8_t cipher_iv_len = tdata->cipher_iv.len;
2831         const uint8_t *auth_iv = tdata->auth_iv.data;
2832         const uint8_t auth_iv_len = tdata->auth_iv.len;
2833         const unsigned int cipher_len = tdata->validCipherLenInBits.len;
2834         const unsigned int auth_len = tdata->validAuthLenInBits.len;
2835
2836         /* Generate Crypto op data structure */
2837         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2838                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2839         TEST_ASSERT_NOT_NULL(ut_params->op,
2840                         "Failed to allocate pktmbuf offload");
2841         /* Set crypto operation data parameters */
2842         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2843
2844         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2845
2846         /* set crypto operation source mbuf */
2847         sym_op->m_src = ut_params->ibuf;
2848
2849         /* digest */
2850         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2851                         ut_params->ibuf, auth_tag_len);
2852
2853         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2854                         "no room to append auth tag");
2855         ut_params->digest = sym_op->auth.digest.data;
2856         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2857                         ut_params->ibuf, data_pad_len);
2858         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2859                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2860         else
2861                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2862
2863         debug_hexdump(stdout, "digest:",
2864                 sym_op->auth.digest.data,
2865                 auth_tag_len);
2866
2867         /* Copy cipher and auth IVs at the end of the crypto operation */
2868         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2869                                                 IV_OFFSET);
2870         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2871         iv_ptr += cipher_iv_len;
2872         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2873
2874         sym_op->cipher.data.length = cipher_len;
2875         sym_op->cipher.data.offset = 0;
2876         sym_op->auth.data.length = auth_len;
2877         sym_op->auth.data.offset = 0;
2878
2879         return 0;
2880 }
2881
2882 static int
2883 create_zuc_cipher_hash_generate_operation(
2884                 const struct wireless_test_data *tdata)
2885 {
2886         return create_wireless_cipher_hash_operation(tdata,
2887                 RTE_CRYPTO_AUTH_OP_GENERATE);
2888 }
2889
2890 static int
2891 create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
2892                 const unsigned auth_tag_len,
2893                 const uint8_t *auth_iv, uint8_t auth_iv_len,
2894                 unsigned data_pad_len,
2895                 enum rte_crypto_auth_operation op,
2896                 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2897                 const unsigned cipher_len, const unsigned cipher_offset,
2898                 const unsigned auth_len, const unsigned auth_offset)
2899 {
2900         struct crypto_testsuite_params *ts_params = &testsuite_params;
2901         struct crypto_unittest_params *ut_params = &unittest_params;
2902
2903         enum rte_crypto_cipher_algorithm cipher_algo =
2904                         ut_params->cipher_xform.cipher.algo;
2905         enum rte_crypto_auth_algorithm auth_algo =
2906                         ut_params->auth_xform.auth.algo;
2907
2908         /* Generate Crypto op data structure */
2909         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2910                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2911         TEST_ASSERT_NOT_NULL(ut_params->op,
2912                         "Failed to allocate pktmbuf offload");
2913         /* Set crypto operation data parameters */
2914         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2915
2916         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2917
2918         /* set crypto operation source mbuf */
2919         sym_op->m_src = ut_params->ibuf;
2920
2921         /* digest */
2922         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2923                         ut_params->ibuf, auth_tag_len);
2924
2925         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2926                         "no room to append auth tag");
2927         ut_params->digest = sym_op->auth.digest.data;
2928
2929         if (rte_pktmbuf_is_contiguous(ut_params->ibuf)) {
2930                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2931                                 ut_params->ibuf, data_pad_len);
2932         } else {
2933                 struct rte_mbuf *m = ut_params->ibuf;
2934                 unsigned int offset = data_pad_len;
2935
2936                 while (offset > m->data_len && m->next != NULL) {
2937                         offset -= m->data_len;
2938                         m = m->next;
2939                 }
2940                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2941                         m, offset);
2942         }
2943
2944         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2945                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2946         else
2947                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2948
2949         debug_hexdump(stdout, "digest:",
2950                 sym_op->auth.digest.data,
2951                 auth_tag_len);
2952
2953         /* Copy cipher and auth IVs at the end of the crypto operation */
2954         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2955                                                 IV_OFFSET);
2956         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2957         iv_ptr += cipher_iv_len;
2958         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2959
2960         if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
2961                 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
2962                 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
2963                 sym_op->cipher.data.length = cipher_len;
2964                 sym_op->cipher.data.offset = cipher_offset;
2965         } else {
2966                 sym_op->cipher.data.length = cipher_len >> 3;
2967                 sym_op->cipher.data.offset = cipher_offset >> 3;
2968         }
2969
2970         if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
2971                 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
2972                 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
2973                 sym_op->auth.data.length = auth_len;
2974                 sym_op->auth.data.offset = auth_offset;
2975         } else {
2976                 sym_op->auth.data.length = auth_len >> 3;
2977                 sym_op->auth.data.offset = auth_offset >> 3;
2978         }
2979
2980         return 0;
2981 }
2982
2983 static int
2984 create_wireless_algo_auth_cipher_operation(
2985                 const uint8_t *auth_tag, unsigned int auth_tag_len,
2986                 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2987                 const uint8_t *auth_iv, uint8_t auth_iv_len,
2988                 unsigned int data_pad_len,
2989                 unsigned int cipher_len, unsigned int cipher_offset,
2990                 unsigned int auth_len, unsigned int auth_offset,
2991                 uint8_t op_mode, uint8_t do_sgl, uint8_t verify)
2992 {
2993         struct crypto_testsuite_params *ts_params = &testsuite_params;
2994         struct crypto_unittest_params *ut_params = &unittest_params;
2995
2996         enum rte_crypto_cipher_algorithm cipher_algo =
2997                         ut_params->cipher_xform.cipher.algo;
2998         enum rte_crypto_auth_algorithm auth_algo =
2999                         ut_params->auth_xform.auth.algo;
3000
3001         /* Generate Crypto op data structure */
3002         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
3003                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
3004         TEST_ASSERT_NOT_NULL(ut_params->op,
3005                         "Failed to allocate pktmbuf offload");
3006
3007         /* Set crypto operation data parameters */
3008         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
3009
3010         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
3011
3012         /* set crypto operation mbufs */
3013         sym_op->m_src = ut_params->ibuf;
3014         if (op_mode == OUT_OF_PLACE)
3015                 sym_op->m_dst = ut_params->obuf;
3016
3017         /* digest */
3018         if (!do_sgl) {
3019                 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(
3020                         (op_mode == IN_PLACE ?
3021                                 ut_params->ibuf : ut_params->obuf),
3022                         uint8_t *, data_pad_len);
3023                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
3024                         (op_mode == IN_PLACE ?
3025                                 ut_params->ibuf : ut_params->obuf),
3026                         data_pad_len);
3027                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
3028         } else {
3029                 uint16_t remaining_off = (auth_offset >> 3) + (auth_len >> 3);
3030                 struct rte_mbuf *sgl_buf = (op_mode == IN_PLACE ?
3031                                 sym_op->m_src : sym_op->m_dst);
3032                 while (remaining_off >= rte_pktmbuf_data_len(sgl_buf)) {
3033                         remaining_off -= rte_pktmbuf_data_len(sgl_buf);
3034                         sgl_buf = sgl_buf->next;
3035                 }
3036                 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(sgl_buf,
3037                                 uint8_t *, remaining_off);
3038                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(sgl_buf,
3039                                 remaining_off);
3040                 memset(sym_op->auth.digest.data, 0, remaining_off);
3041                 while (sgl_buf->next != NULL) {
3042                         memset(rte_pktmbuf_mtod(sgl_buf, uint8_t *),
3043                                 0, rte_pktmbuf_data_len(sgl_buf));
3044                         sgl_buf = sgl_buf->next;
3045                 }
3046         }
3047
3048         /* Copy digest for the verification */
3049         if (verify)
3050                 memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
3051
3052         /* Copy cipher and auth IVs at the end of the crypto operation */
3053         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(
3054                         ut_params->op, uint8_t *, IV_OFFSET);
3055
3056         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
3057         iv_ptr += cipher_iv_len;
3058         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
3059
3060         /* Only copy over the offset data needed from src to dst in OOP,
3061          * if the auth and cipher offsets are not aligned
3062          */
3063         if (op_mode == OUT_OF_PLACE) {
3064                 if (cipher_offset > auth_offset)
3065                         rte_memcpy(
3066                                 rte_pktmbuf_mtod_offset(
3067                                         sym_op->m_dst,
3068                                         uint8_t *, auth_offset >> 3),
3069                                 rte_pktmbuf_mtod_offset(
3070                                         sym_op->m_src,
3071                                         uint8_t *, auth_offset >> 3),
3072                                 ((cipher_offset >> 3) - (auth_offset >> 3)));
3073         }
3074
3075         if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
3076                 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
3077                 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
3078                 sym_op->cipher.data.length = cipher_len;
3079                 sym_op->cipher.data.offset = cipher_offset;
3080         } else {
3081                 sym_op->cipher.data.length = cipher_len >> 3;
3082                 sym_op->cipher.data.offset = cipher_offset >> 3;
3083         }
3084
3085         if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
3086                 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
3087                 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
3088                 sym_op->auth.data.length = auth_len;
3089                 sym_op->auth.data.offset = auth_offset;
3090         } else {
3091                 sym_op->auth.data.length = auth_len >> 3;
3092                 sym_op->auth.data.offset = auth_offset >> 3;
3093         }
3094
3095         return 0;
3096 }
3097
3098 static int
3099 test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
3100 {
3101         struct crypto_testsuite_params *ts_params = &testsuite_params;
3102         struct crypto_unittest_params *ut_params = &unittest_params;
3103
3104         int retval;
3105         unsigned plaintext_pad_len;
3106         unsigned plaintext_len;
3107         uint8_t *plaintext;
3108         struct rte_cryptodev_info dev_info;
3109
3110         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3111         uint64_t feat_flags = dev_info.feature_flags;
3112
3113         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
3114                         ((tdata->validAuthLenInBits.len % 8) != 0)) {
3115                 printf("Device doesn't support NON-Byte Aligned Data.\n");
3116                 return TEST_SKIPPED;
3117         }
3118
3119         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3120                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3121                 printf("Device doesn't support RAW data-path APIs.\n");
3122                 return TEST_SKIPPED;
3123         }
3124
3125         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3126                 return TEST_SKIPPED;
3127
3128         /* Verify the capabilities */
3129         struct rte_cryptodev_sym_capability_idx cap_idx;
3130         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3131         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
3132         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3133                         &cap_idx) == NULL)
3134                 return TEST_SKIPPED;
3135
3136         /* Create SNOW 3G session */
3137         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3138                         tdata->key.data, tdata->key.len,
3139                         tdata->auth_iv.len, tdata->digest.len,
3140                         RTE_CRYPTO_AUTH_OP_GENERATE,
3141                         RTE_CRYPTO_AUTH_SNOW3G_UIA2);
3142         if (retval < 0)
3143                 return retval;
3144
3145         /* alloc mbuf and set payload */
3146         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3147
3148         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3149         rte_pktmbuf_tailroom(ut_params->ibuf));
3150
3151         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3152         /* Append data which is padded to a multiple of */
3153         /* the algorithms block size */
3154         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3155         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3156                                 plaintext_pad_len);
3157         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3158
3159         /* Create SNOW 3G operation */
3160         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
3161                         tdata->auth_iv.data, tdata->auth_iv.len,
3162                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3163                         tdata->validAuthLenInBits.len,
3164                         0);
3165         if (retval < 0)
3166                 return retval;
3167
3168         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3169                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3170                                 ut_params->op, 0, 1, 1, 0);
3171         else
3172                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3173                                 ut_params->op);
3174         ut_params->obuf = ut_params->op->sym->m_src;
3175         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3176         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3177                         + plaintext_pad_len;
3178
3179         /* Validate obuf */
3180         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3181         ut_params->digest,
3182         tdata->digest.data,
3183         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
3184         "SNOW 3G Generated auth tag not as expected");
3185
3186         return 0;
3187 }
3188
3189 static int
3190 test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
3191 {
3192         struct crypto_testsuite_params *ts_params = &testsuite_params;
3193         struct crypto_unittest_params *ut_params = &unittest_params;
3194
3195         int retval;
3196         unsigned plaintext_pad_len;
3197         unsigned plaintext_len;
3198         uint8_t *plaintext;
3199         struct rte_cryptodev_info dev_info;
3200
3201         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3202         uint64_t feat_flags = dev_info.feature_flags;
3203
3204         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
3205                         ((tdata->validAuthLenInBits.len % 8) != 0)) {
3206                 printf("Device doesn't support NON-Byte Aligned Data.\n");
3207                 return TEST_SKIPPED;
3208         }
3209
3210         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3211                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3212                 printf("Device doesn't support RAW data-path APIs.\n");
3213                 return TEST_SKIPPED;
3214         }
3215
3216         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3217                 return TEST_SKIPPED;
3218
3219         /* Verify the capabilities */
3220         struct rte_cryptodev_sym_capability_idx cap_idx;
3221         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3222         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
3223         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3224                         &cap_idx) == NULL)
3225                 return TEST_SKIPPED;
3226
3227         /* Create SNOW 3G session */
3228         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3229                                 tdata->key.data, tdata->key.len,
3230                                 tdata->auth_iv.len, tdata->digest.len,
3231                                 RTE_CRYPTO_AUTH_OP_VERIFY,
3232                                 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
3233         if (retval < 0)
3234                 return retval;
3235         /* alloc mbuf and set payload */
3236         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3237
3238         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3239         rte_pktmbuf_tailroom(ut_params->ibuf));
3240
3241         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3242         /* Append data which is padded to a multiple of */
3243         /* the algorithms block size */
3244         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3245         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3246                                 plaintext_pad_len);
3247         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3248
3249         /* Create SNOW 3G operation */
3250         retval = create_wireless_algo_hash_operation(tdata->digest.data,
3251                         tdata->digest.len,
3252                         tdata->auth_iv.data, tdata->auth_iv.len,
3253                         plaintext_pad_len,
3254                         RTE_CRYPTO_AUTH_OP_VERIFY,
3255                         tdata->validAuthLenInBits.len,
3256                         0);
3257         if (retval < 0)
3258                 return retval;
3259
3260         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3261                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3262                                 ut_params->op, 0, 1, 1, 0);
3263         else
3264                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3265                                 ut_params->op);
3266         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3267         ut_params->obuf = ut_params->op->sym->m_src;
3268         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3269                                 + plaintext_pad_len;
3270
3271         /* Validate obuf */
3272         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
3273                 return 0;
3274         else
3275                 return -1;
3276
3277         return 0;
3278 }
3279
3280 static int
3281 test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
3282 {
3283         struct crypto_testsuite_params *ts_params = &testsuite_params;
3284         struct crypto_unittest_params *ut_params = &unittest_params;
3285
3286         int retval;
3287         unsigned plaintext_pad_len;
3288         unsigned plaintext_len;
3289         uint8_t *plaintext;
3290         struct rte_cryptodev_info dev_info;
3291
3292         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3293         uint64_t feat_flags = dev_info.feature_flags;
3294
3295         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3296                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3297                 printf("Device doesn't support RAW data-path APIs.\n");
3298                 return TEST_SKIPPED;
3299         }
3300
3301         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3302                 return TEST_SKIPPED;
3303
3304         /* Verify the capabilities */
3305         struct rte_cryptodev_sym_capability_idx cap_idx;
3306         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3307         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
3308         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3309                         &cap_idx) == NULL)
3310                 return TEST_SKIPPED;
3311
3312         /* Create KASUMI session */
3313         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3314                         tdata->key.data, tdata->key.len,
3315                         0, tdata->digest.len,
3316                         RTE_CRYPTO_AUTH_OP_GENERATE,
3317                         RTE_CRYPTO_AUTH_KASUMI_F9);
3318         if (retval < 0)
3319                 return retval;
3320
3321         /* alloc mbuf and set payload */
3322         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3323
3324         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3325         rte_pktmbuf_tailroom(ut_params->ibuf));
3326
3327         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3328         /* Append data which is padded to a multiple of */
3329         /* the algorithms block size */
3330         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3331         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3332                                 plaintext_pad_len);
3333         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3334
3335         /* Create KASUMI operation */
3336         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
3337                         NULL, 0,
3338                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3339                         tdata->plaintext.len,
3340                         0);
3341         if (retval < 0)
3342                 return retval;
3343
3344         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3345                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
3346                         ut_params->op);
3347         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3348                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3349                                 ut_params->op, 0, 1, 1, 0);
3350         else
3351                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3352                         ut_params->op);
3353
3354         ut_params->obuf = ut_params->op->sym->m_src;
3355         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3356         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3357                         + plaintext_pad_len;
3358
3359         /* Validate obuf */
3360         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3361         ut_params->digest,
3362         tdata->digest.data,
3363         DIGEST_BYTE_LENGTH_KASUMI_F9,
3364         "KASUMI Generated auth tag not as expected");
3365
3366         return 0;
3367 }
3368
3369 static int
3370 test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
3371 {
3372         struct crypto_testsuite_params *ts_params = &testsuite_params;
3373         struct crypto_unittest_params *ut_params = &unittest_params;
3374
3375         int retval;
3376         unsigned plaintext_pad_len;
3377         unsigned plaintext_len;
3378         uint8_t *plaintext;
3379         struct rte_cryptodev_info dev_info;
3380
3381         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3382         uint64_t feat_flags = dev_info.feature_flags;
3383
3384         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3385                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3386                 printf("Device doesn't support RAW data-path APIs.\n");
3387                 return TEST_SKIPPED;
3388         }
3389
3390         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3391                 return TEST_SKIPPED;
3392
3393         /* Verify the capabilities */
3394         struct rte_cryptodev_sym_capability_idx cap_idx;
3395         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3396         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
3397         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3398                         &cap_idx) == NULL)
3399                 return TEST_SKIPPED;
3400
3401         /* Create KASUMI session */
3402         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3403                                 tdata->key.data, tdata->key.len,
3404                                 0, tdata->digest.len,
3405                                 RTE_CRYPTO_AUTH_OP_VERIFY,
3406                                 RTE_CRYPTO_AUTH_KASUMI_F9);
3407         if (retval < 0)
3408                 return retval;
3409         /* alloc mbuf and set payload */
3410         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3411
3412         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3413         rte_pktmbuf_tailroom(ut_params->ibuf));
3414
3415         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3416         /* Append data which is padded to a multiple */
3417         /* of the algorithms block size */
3418         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3419         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3420                                 plaintext_pad_len);
3421         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3422
3423         /* Create KASUMI operation */
3424         retval = create_wireless_algo_hash_operation(tdata->digest.data,
3425                         tdata->digest.len,
3426                         NULL, 0,
3427                         plaintext_pad_len,
3428                         RTE_CRYPTO_AUTH_OP_VERIFY,
3429                         tdata->plaintext.len,
3430                         0);
3431         if (retval < 0)
3432                 return retval;
3433
3434         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3435                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3436                                 ut_params->op, 0, 1, 1, 0);
3437         else
3438                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3439                                 ut_params->op);
3440         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3441         ut_params->obuf = ut_params->op->sym->m_src;
3442         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3443                                 + plaintext_pad_len;
3444
3445         /* Validate obuf */
3446         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
3447                 return 0;
3448         else
3449                 return -1;
3450
3451         return 0;
3452 }
3453
3454 static int
3455 test_snow3g_hash_generate_test_case_1(void)
3456 {
3457         return test_snow3g_authentication(&snow3g_hash_test_case_1);
3458 }
3459
3460 static int
3461 test_snow3g_hash_generate_test_case_2(void)
3462 {
3463         return test_snow3g_authentication(&snow3g_hash_test_case_2);
3464 }
3465
3466 static int
3467 test_snow3g_hash_generate_test_case_3(void)
3468 {
3469         return test_snow3g_authentication(&snow3g_hash_test_case_3);
3470 }
3471
3472 static int
3473 test_snow3g_hash_generate_test_case_4(void)
3474 {
3475         return test_snow3g_authentication(&snow3g_hash_test_case_4);
3476 }
3477
3478 static int
3479 test_snow3g_hash_generate_test_case_5(void)
3480 {
3481         return test_snow3g_authentication(&snow3g_hash_test_case_5);
3482 }
3483
3484 static int
3485 test_snow3g_hash_generate_test_case_6(void)
3486 {
3487         return test_snow3g_authentication(&snow3g_hash_test_case_6);
3488 }
3489
3490 static int
3491 test_snow3g_hash_verify_test_case_1(void)
3492 {
3493         return test_snow3g_authentication_verify(&snow3g_hash_test_case_1);
3494
3495 }
3496
3497 static int
3498 test_snow3g_hash_verify_test_case_2(void)
3499 {
3500         return test_snow3g_authentication_verify(&snow3g_hash_test_case_2);
3501 }
3502
3503 static int
3504 test_snow3g_hash_verify_test_case_3(void)
3505 {
3506         return test_snow3g_authentication_verify(&snow3g_hash_test_case_3);
3507 }
3508
3509 static int
3510 test_snow3g_hash_verify_test_case_4(void)
3511 {
3512         return test_snow3g_authentication_verify(&snow3g_hash_test_case_4);
3513 }
3514
3515 static int
3516 test_snow3g_hash_verify_test_case_5(void)
3517 {
3518         return test_snow3g_authentication_verify(&snow3g_hash_test_case_5);
3519 }
3520
3521 static int
3522 test_snow3g_hash_verify_test_case_6(void)
3523 {
3524         return test_snow3g_authentication_verify(&snow3g_hash_test_case_6);
3525 }
3526
3527 static int
3528 test_kasumi_hash_generate_test_case_1(void)
3529 {
3530         return test_kasumi_authentication(&kasumi_hash_test_case_1);
3531 }
3532
3533 static int
3534 test_kasumi_hash_generate_test_case_2(void)
3535 {
3536         return test_kasumi_authentication(&kasumi_hash_test_case_2);
3537 }
3538
3539 static int
3540 test_kasumi_hash_generate_test_case_3(void)
3541 {
3542         return test_kasumi_authentication(&kasumi_hash_test_case_3);
3543 }
3544
3545 static int
3546 test_kasumi_hash_generate_test_case_4(void)
3547 {
3548         return test_kasumi_authentication(&kasumi_hash_test_case_4);
3549 }
3550
3551 static int
3552 test_kasumi_hash_generate_test_case_5(void)
3553 {
3554         return test_kasumi_authentication(&kasumi_hash_test_case_5);
3555 }
3556
3557 static int
3558 test_kasumi_hash_generate_test_case_6(void)
3559 {
3560         return test_kasumi_authentication(&kasumi_hash_test_case_6);
3561 }
3562
3563 static int
3564 test_kasumi_hash_verify_test_case_1(void)
3565 {
3566         return test_kasumi_authentication_verify(&kasumi_hash_test_case_1);
3567 }
3568
3569 static int
3570 test_kasumi_hash_verify_test_case_2(void)
3571 {
3572         return test_kasumi_authentication_verify(&kasumi_hash_test_case_2);
3573 }
3574
3575 static int
3576 test_kasumi_hash_verify_test_case_3(void)
3577 {
3578         return test_kasumi_authentication_verify(&kasumi_hash_test_case_3);
3579 }
3580
3581 static int
3582 test_kasumi_hash_verify_test_case_4(void)
3583 {
3584         return test_kasumi_authentication_verify(&kasumi_hash_test_case_4);
3585 }
3586
3587 static int
3588 test_kasumi_hash_verify_test_case_5(void)
3589 {
3590         return test_kasumi_authentication_verify(&kasumi_hash_test_case_5);
3591 }
3592
3593 static int
3594 test_kasumi_encryption(const struct kasumi_test_data *tdata)
3595 {
3596         struct crypto_testsuite_params *ts_params = &testsuite_params;
3597         struct crypto_unittest_params *ut_params = &unittest_params;
3598
3599         int retval;
3600         uint8_t *plaintext, *ciphertext;
3601         unsigned plaintext_pad_len;
3602         unsigned plaintext_len;
3603         struct rte_cryptodev_info dev_info;
3604
3605         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3606         uint64_t feat_flags = dev_info.feature_flags;
3607
3608         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3609                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3610                 printf("Device doesn't support RAW data-path APIs.\n");
3611                 return TEST_SKIPPED;
3612         }
3613
3614         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3615                 return TEST_SKIPPED;
3616
3617         /* Verify the capabilities */
3618         struct rte_cryptodev_sym_capability_idx cap_idx;
3619         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3620         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3621         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3622                         &cap_idx) == NULL)
3623                 return TEST_SKIPPED;
3624
3625         /* Create KASUMI session */
3626         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3627                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3628                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3629                                         tdata->key.data, tdata->key.len,
3630                                         tdata->cipher_iv.len);
3631         if (retval < 0)
3632                 return retval;
3633
3634         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3635
3636         /* Clear mbuf payload */
3637         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3638                rte_pktmbuf_tailroom(ut_params->ibuf));
3639
3640         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3641         /* Append data which is padded to a multiple */
3642         /* of the algorithms block size */
3643         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3644         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3645                                 plaintext_pad_len);
3646         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3647
3648         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3649
3650         /* Create KASUMI operation */
3651         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3652                                 tdata->cipher_iv.len,
3653                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3654                                 tdata->validCipherOffsetInBits.len);
3655         if (retval < 0)
3656                 return retval;
3657
3658         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3659                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3660                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
3661         else
3662                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3663                                 ut_params->op);
3664         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3665
3666         ut_params->obuf = ut_params->op->sym->m_dst;
3667         if (ut_params->obuf)
3668                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3669         else
3670                 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3671
3672         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3673
3674         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3675                                 (tdata->validCipherOffsetInBits.len >> 3);
3676         /* Validate obuf */
3677         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3678                 ciphertext,
3679                 reference_ciphertext,
3680                 tdata->validCipherLenInBits.len,
3681                 "KASUMI Ciphertext data not as expected");
3682         return 0;
3683 }
3684
3685 static int
3686 test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
3687 {
3688         struct crypto_testsuite_params *ts_params = &testsuite_params;
3689         struct crypto_unittest_params *ut_params = &unittest_params;
3690
3691         int retval;
3692
3693         unsigned int plaintext_pad_len;
3694         unsigned int plaintext_len;
3695
3696         uint8_t buffer[10000];
3697         const uint8_t *ciphertext;
3698
3699         struct rte_cryptodev_info dev_info;
3700
3701         /* Verify the capabilities */
3702         struct rte_cryptodev_sym_capability_idx cap_idx;
3703         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3704         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3705         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3706                         &cap_idx) == NULL)
3707                 return TEST_SKIPPED;
3708
3709         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3710
3711         uint64_t feat_flags = dev_info.feature_flags;
3712
3713         if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
3714                 printf("Device doesn't support in-place scatter-gather. "
3715                                 "Test Skipped.\n");
3716                 return TEST_SKIPPED;
3717         }
3718
3719         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3720                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3721                 printf("Device doesn't support RAW data-path APIs.\n");
3722                 return TEST_SKIPPED;
3723         }
3724
3725         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3726                 return TEST_SKIPPED;
3727
3728         /* Create KASUMI session */
3729         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3730                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3731                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3732                                         tdata->key.data, tdata->key.len,
3733                                         tdata->cipher_iv.len);
3734         if (retval < 0)
3735                 return retval;
3736
3737         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3738
3739
3740         /* Append data which is padded to a multiple */
3741         /* of the algorithms block size */
3742         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3743
3744         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3745                         plaintext_pad_len, 10, 0);
3746
3747         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3748
3749         /* Create KASUMI operation */
3750         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3751                                 tdata->cipher_iv.len,
3752                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3753                                 tdata->validCipherOffsetInBits.len);
3754         if (retval < 0)
3755                 return retval;
3756
3757         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3758                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3759                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
3760         else
3761                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3762                                                 ut_params->op);
3763         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3764
3765         ut_params->obuf = ut_params->op->sym->m_dst;
3766
3767         if (ut_params->obuf)
3768                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3769                                 plaintext_len, buffer);
3770         else
3771                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3772                                 tdata->validCipherOffsetInBits.len >> 3,
3773                                 plaintext_len, buffer);
3774
3775         /* Validate obuf */
3776         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3777
3778         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3779                                 (tdata->validCipherOffsetInBits.len >> 3);
3780         /* Validate obuf */
3781         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3782                 ciphertext,
3783                 reference_ciphertext,
3784                 tdata->validCipherLenInBits.len,
3785                 "KASUMI Ciphertext data not as expected");
3786         return 0;
3787 }
3788
3789 static int
3790 test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
3791 {
3792         struct crypto_testsuite_params *ts_params = &testsuite_params;
3793         struct crypto_unittest_params *ut_params = &unittest_params;
3794
3795         int retval;
3796         uint8_t *plaintext, *ciphertext;
3797         unsigned plaintext_pad_len;
3798         unsigned plaintext_len;
3799
3800         /* Verify the capabilities */
3801         struct rte_cryptodev_sym_capability_idx cap_idx;
3802         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3803         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3804         /* Data-path service does not support OOP */
3805         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3806                         &cap_idx) == NULL)
3807                 return TEST_SKIPPED;
3808
3809         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3810                 return TEST_SKIPPED;
3811
3812         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3813                 return TEST_SKIPPED;
3814
3815         /* Create KASUMI session */
3816         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3817                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3818                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3819                                         tdata->key.data, tdata->key.len,
3820                                         tdata->cipher_iv.len);
3821         if (retval < 0)
3822                 return retval;
3823
3824         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3825         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3826
3827         /* Clear mbuf payload */
3828         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3829                rte_pktmbuf_tailroom(ut_params->ibuf));
3830
3831         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3832         /* Append data which is padded to a multiple */
3833         /* of the algorithms block size */
3834         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3835         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3836                                 plaintext_pad_len);
3837         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3838         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3839
3840         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3841
3842         /* Create KASUMI operation */
3843         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3844                                 tdata->cipher_iv.len,
3845                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3846                                 tdata->validCipherOffsetInBits.len);
3847         if (retval < 0)
3848                 return retval;
3849
3850         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3851                                                 ut_params->op);
3852         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3853
3854         ut_params->obuf = ut_params->op->sym->m_dst;
3855         if (ut_params->obuf)
3856                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3857         else
3858                 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3859
3860         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3861
3862         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3863                                 (tdata->validCipherOffsetInBits.len >> 3);
3864         /* Validate obuf */
3865         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3866                 ciphertext,
3867                 reference_ciphertext,
3868                 tdata->validCipherLenInBits.len,
3869                 "KASUMI Ciphertext data not as expected");
3870         return 0;
3871 }
3872
3873 static int
3874 test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
3875 {
3876         struct crypto_testsuite_params *ts_params = &testsuite_params;
3877         struct crypto_unittest_params *ut_params = &unittest_params;
3878
3879         int retval;
3880         unsigned int plaintext_pad_len;
3881         unsigned int plaintext_len;
3882
3883         const uint8_t *ciphertext;
3884         uint8_t buffer[2048];
3885
3886         struct rte_cryptodev_info dev_info;
3887
3888         /* Verify the capabilities */
3889         struct rte_cryptodev_sym_capability_idx cap_idx;
3890         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3891         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3892         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3893                         &cap_idx) == NULL)
3894                 return TEST_SKIPPED;
3895
3896         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3897                 return TEST_SKIPPED;
3898
3899         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3900                 return TEST_SKIPPED;
3901
3902         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3903
3904         uint64_t feat_flags = dev_info.feature_flags;
3905         if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
3906                 printf("Device doesn't support out-of-place scatter-gather "
3907                                 "in both input and output mbufs. "
3908                                 "Test Skipped.\n");
3909                 return TEST_SKIPPED;
3910         }
3911
3912         /* Create KASUMI session */
3913         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3914                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3915                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3916                                         tdata->key.data, tdata->key.len,
3917                                         tdata->cipher_iv.len);
3918         if (retval < 0)
3919                 return retval;
3920
3921         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3922         /* Append data which is padded to a multiple */
3923         /* of the algorithms block size */
3924         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3925
3926         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3927                         plaintext_pad_len, 10, 0);
3928         ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
3929                         plaintext_pad_len, 3, 0);
3930
3931         /* Append data which is padded to a multiple */
3932         /* of the algorithms block size */
3933         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3934
3935         /* Create KASUMI operation */
3936         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3937                                 tdata->cipher_iv.len,
3938                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3939                                 tdata->validCipherOffsetInBits.len);
3940         if (retval < 0)
3941                 return retval;
3942
3943         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3944                                                 ut_params->op);
3945         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3946
3947         ut_params->obuf = ut_params->op->sym->m_dst;
3948         if (ut_params->obuf)
3949                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3950                                 plaintext_pad_len, buffer);
3951         else
3952                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3953                                 tdata->validCipherOffsetInBits.len >> 3,
3954                                 plaintext_pad_len, buffer);
3955
3956         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3957                                 (tdata->validCipherOffsetInBits.len >> 3);
3958         /* Validate obuf */
3959         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3960                 ciphertext,
3961                 reference_ciphertext,
3962                 tdata->validCipherLenInBits.len,
3963                 "KASUMI Ciphertext data not as expected");
3964         return 0;
3965 }
3966
3967
3968 static int
3969 test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
3970 {
3971         struct crypto_testsuite_params *ts_params = &testsuite_params;
3972         struct crypto_unittest_params *ut_params = &unittest_params;
3973
3974         int retval;
3975         uint8_t *ciphertext, *plaintext;
3976         unsigned ciphertext_pad_len;
3977         unsigned ciphertext_len;
3978
3979         /* Verify the capabilities */
3980         struct rte_cryptodev_sym_capability_idx cap_idx;
3981         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3982         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3983         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3984                         &cap_idx) == NULL)
3985                 return TEST_SKIPPED;
3986
3987         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3988                 return TEST_SKIPPED;
3989
3990         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3991                 return TEST_SKIPPED;
3992
3993         /* Create KASUMI session */
3994         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3995                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
3996                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3997                                         tdata->key.data, tdata->key.len,
3998                                         tdata->cipher_iv.len);
3999         if (retval < 0)
4000                 return retval;
4001
4002         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4003         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4004
4005         /* Clear mbuf payload */
4006         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4007                rte_pktmbuf_tailroom(ut_params->ibuf));
4008
4009         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4010         /* Append data which is padded to a multiple */
4011         /* of the algorithms block size */
4012         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
4013         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4014                                 ciphertext_pad_len);
4015         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4016         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4017
4018         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4019
4020         /* Create KASUMI operation */
4021         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4022                                 tdata->cipher_iv.len,
4023                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
4024                                 tdata->validCipherOffsetInBits.len);
4025         if (retval < 0)
4026                 return retval;
4027
4028         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4029                                                 ut_params->op);
4030         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4031
4032         ut_params->obuf = ut_params->op->sym->m_dst;
4033         if (ut_params->obuf)
4034                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4035         else
4036                 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
4037
4038         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4039
4040         const uint8_t *reference_plaintext = tdata->plaintext.data +
4041                                 (tdata->validCipherOffsetInBits.len >> 3);
4042         /* Validate obuf */
4043         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4044                 plaintext,
4045                 reference_plaintext,
4046                 tdata->validCipherLenInBits.len,
4047                 "KASUMI Plaintext data not as expected");
4048         return 0;
4049 }
4050
4051 static int
4052 test_kasumi_decryption(const struct kasumi_test_data *tdata)
4053 {
4054         struct crypto_testsuite_params *ts_params = &testsuite_params;
4055         struct crypto_unittest_params *ut_params = &unittest_params;
4056
4057         int retval;
4058         uint8_t *ciphertext, *plaintext;
4059         unsigned ciphertext_pad_len;
4060         unsigned ciphertext_len;
4061         struct rte_cryptodev_info dev_info;
4062
4063         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4064         uint64_t feat_flags = dev_info.feature_flags;
4065
4066         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4067                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4068                 printf("Device doesn't support RAW data-path APIs.\n");
4069                 return TEST_SKIPPED;
4070         }
4071
4072         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4073                 return TEST_SKIPPED;
4074
4075         /* Verify the capabilities */
4076         struct rte_cryptodev_sym_capability_idx cap_idx;
4077         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4078         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
4079         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4080                         &cap_idx) == NULL)
4081                 return TEST_SKIPPED;
4082
4083         /* Create KASUMI session */
4084         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4085                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4086                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
4087                                         tdata->key.data, tdata->key.len,
4088                                         tdata->cipher_iv.len);
4089         if (retval < 0)
4090                 return retval;
4091
4092         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4093
4094         /* Clear mbuf payload */
4095         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4096                rte_pktmbuf_tailroom(ut_params->ibuf));
4097
4098         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4099         /* Append data which is padded to a multiple */
4100         /* of the algorithms block size */
4101         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
4102         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4103                                 ciphertext_pad_len);
4104         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4105
4106         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4107
4108         /* Create KASUMI operation */
4109         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4110                         tdata->cipher_iv.len,
4111                         RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
4112                         tdata->validCipherOffsetInBits.len);
4113         if (retval < 0)
4114                 return retval;
4115
4116         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4117                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4118                                 ut_params->op, 1, 0, 1, 0);
4119         else
4120                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4121                                                 ut_params->op);
4122         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4123
4124         ut_params->obuf = ut_params->op->sym->m_dst;
4125         if (ut_params->obuf)
4126                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4127         else
4128                 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
4129
4130         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4131
4132         const uint8_t *reference_plaintext = tdata->plaintext.data +
4133                                 (tdata->validCipherOffsetInBits.len >> 3);
4134         /* Validate obuf */
4135         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4136                 plaintext,
4137                 reference_plaintext,
4138                 tdata->validCipherLenInBits.len,
4139                 "KASUMI Plaintext data not as expected");
4140         return 0;
4141 }
4142
4143 static int
4144 test_snow3g_encryption(const struct snow3g_test_data *tdata)
4145 {
4146         struct crypto_testsuite_params *ts_params = &testsuite_params;
4147         struct crypto_unittest_params *ut_params = &unittest_params;
4148
4149         int retval;
4150         uint8_t *plaintext, *ciphertext;
4151         unsigned plaintext_pad_len;
4152         unsigned plaintext_len;
4153         struct rte_cryptodev_info dev_info;
4154
4155         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4156         uint64_t feat_flags = dev_info.feature_flags;
4157
4158         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4159                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4160                 printf("Device doesn't support RAW data-path APIs.\n");
4161                 return TEST_SKIPPED;
4162         }
4163
4164         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4165                 return TEST_SKIPPED;
4166
4167         /* Verify the capabilities */
4168         struct rte_cryptodev_sym_capability_idx cap_idx;
4169         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4170         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4171         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4172                         &cap_idx) == NULL)
4173                 return TEST_SKIPPED;
4174
4175         /* Create SNOW 3G session */
4176         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4177                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4178                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4179                                         tdata->key.data, tdata->key.len,
4180                                         tdata->cipher_iv.len);
4181         if (retval < 0)
4182                 return retval;
4183
4184         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4185
4186         /* Clear mbuf payload */
4187         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4188                rte_pktmbuf_tailroom(ut_params->ibuf));
4189
4190         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4191         /* Append data which is padded to a multiple of */
4192         /* the algorithms block size */
4193         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4194         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4195                                 plaintext_pad_len);
4196         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4197
4198         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4199
4200         /* Create SNOW 3G operation */
4201         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4202                                         tdata->cipher_iv.len,
4203                                         tdata->validCipherLenInBits.len,
4204                                         0);
4205         if (retval < 0)
4206                 return retval;
4207
4208         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4209                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4210                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4211         else
4212                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4213                                                 ut_params->op);
4214         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4215
4216         ut_params->obuf = ut_params->op->sym->m_dst;
4217         if (ut_params->obuf)
4218                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4219         else
4220                 ciphertext = plaintext;
4221
4222         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4223
4224         /* Validate obuf */
4225         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4226                 ciphertext,
4227                 tdata->ciphertext.data,
4228                 tdata->validDataLenInBits.len,
4229                 "SNOW 3G Ciphertext data not as expected");
4230         return 0;
4231 }
4232
4233
4234 static int
4235 test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
4236 {
4237         struct crypto_testsuite_params *ts_params = &testsuite_params;
4238         struct crypto_unittest_params *ut_params = &unittest_params;
4239         uint8_t *plaintext, *ciphertext;
4240
4241         int retval;
4242         unsigned plaintext_pad_len;
4243         unsigned plaintext_len;
4244         struct rte_cryptodev_info dev_info;
4245
4246         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4247         uint64_t feat_flags = dev_info.feature_flags;
4248
4249         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4250                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4251                 printf("Device does not support RAW data-path APIs.\n");
4252                 return -ENOTSUP;
4253         }
4254
4255         /* Verify the capabilities */
4256         struct rte_cryptodev_sym_capability_idx cap_idx;
4257         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4258         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4259         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4260                         &cap_idx) == NULL)
4261                 return TEST_SKIPPED;
4262
4263         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4264                 return TEST_SKIPPED;
4265
4266         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4267                 return TEST_SKIPPED;
4268
4269         /* Create SNOW 3G session */
4270         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4271                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4272                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4273                                         tdata->key.data, tdata->key.len,
4274                                         tdata->cipher_iv.len);
4275         if (retval < 0)
4276                 return retval;
4277
4278         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4279         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4280
4281         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4282                         "Failed to allocate input buffer in mempool");
4283         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4284                         "Failed to allocate output buffer in mempool");
4285
4286         /* Clear mbuf payload */
4287         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4288                rte_pktmbuf_tailroom(ut_params->ibuf));
4289
4290         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4291         /* Append data which is padded to a multiple of */
4292         /* the algorithms block size */
4293         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4294         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4295                                 plaintext_pad_len);
4296         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4297         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4298
4299         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4300
4301         /* Create SNOW 3G operation */
4302         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4303                                         tdata->cipher_iv.len,
4304                                         tdata->validCipherLenInBits.len,
4305                                         0);
4306         if (retval < 0)
4307                 return retval;
4308
4309         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4310                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4311                         ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4312         else
4313                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4314                                                 ut_params->op);
4315         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4316
4317         ut_params->obuf = ut_params->op->sym->m_dst;
4318         if (ut_params->obuf)
4319                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4320         else
4321                 ciphertext = plaintext;
4322
4323         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4324
4325         /* Validate obuf */
4326         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4327                 ciphertext,
4328                 tdata->ciphertext.data,
4329                 tdata->validDataLenInBits.len,
4330                 "SNOW 3G Ciphertext data not as expected");
4331         return 0;
4332 }
4333
4334 static int
4335 test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
4336 {
4337         struct crypto_testsuite_params *ts_params = &testsuite_params;
4338         struct crypto_unittest_params *ut_params = &unittest_params;
4339
4340         int retval;
4341         unsigned int plaintext_pad_len;
4342         unsigned int plaintext_len;
4343         uint8_t buffer[10000];
4344         const uint8_t *ciphertext;
4345
4346         struct rte_cryptodev_info dev_info;
4347
4348         /* Verify the capabilities */
4349         struct rte_cryptodev_sym_capability_idx cap_idx;
4350         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4351         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4352         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4353                         &cap_idx) == NULL)
4354                 return TEST_SKIPPED;
4355
4356         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4357                 return TEST_SKIPPED;
4358
4359         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4360                 return TEST_SKIPPED;
4361
4362         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4363
4364         uint64_t feat_flags = dev_info.feature_flags;
4365
4366         if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
4367                 printf("Device doesn't support out-of-place scatter-gather "
4368                                 "in both input and output mbufs. "
4369                                 "Test Skipped.\n");
4370                 return TEST_SKIPPED;
4371         }
4372
4373         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4374                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4375                 printf("Device does not support RAW data-path APIs.\n");
4376                 return -ENOTSUP;
4377         }
4378
4379         /* Create SNOW 3G session */
4380         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4381                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4382                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4383                                         tdata->key.data, tdata->key.len,
4384                                         tdata->cipher_iv.len);
4385         if (retval < 0)
4386                 return retval;
4387
4388         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4389         /* Append data which is padded to a multiple of */
4390         /* the algorithms block size */
4391         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4392
4393         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
4394                         plaintext_pad_len, 10, 0);
4395         ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
4396                         plaintext_pad_len, 3, 0);
4397
4398         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4399                         "Failed to allocate input buffer in mempool");
4400         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4401                         "Failed to allocate output buffer in mempool");
4402
4403         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
4404
4405         /* Create SNOW 3G operation */
4406         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4407                                         tdata->cipher_iv.len,
4408                                         tdata->validCipherLenInBits.len,
4409                                         0);
4410         if (retval < 0)
4411                 return retval;
4412
4413         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4414                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4415                         ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4416         else
4417                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4418                                                 ut_params->op);
4419         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4420
4421         ut_params->obuf = ut_params->op->sym->m_dst;
4422         if (ut_params->obuf)
4423                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
4424                                 plaintext_len, buffer);
4425         else
4426                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
4427                                 plaintext_len, buffer);
4428
4429         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4430
4431         /* Validate obuf */
4432         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4433                 ciphertext,
4434                 tdata->ciphertext.data,
4435                 tdata->validDataLenInBits.len,
4436                 "SNOW 3G Ciphertext data not as expected");
4437
4438         return 0;
4439 }
4440
4441 /* Shift right a buffer by "offset" bits, "offset" < 8 */
4442 static void
4443 buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset)
4444 {
4445         uint8_t curr_byte, prev_byte;
4446         uint32_t length_in_bytes = ceil_byte_length(length + offset);
4447         uint8_t lower_byte_mask = (1 << offset) - 1;
4448         unsigned i;
4449
4450         prev_byte = buffer[0];
4451         buffer[0] >>= offset;
4452
4453         for (i = 1; i < length_in_bytes; i++) {
4454                 curr_byte = buffer[i];
4455                 buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) |
4456                                 (curr_byte >> offset);
4457                 prev_byte = curr_byte;
4458         }
4459 }
4460
4461 static int
4462 test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
4463 {
4464         struct crypto_testsuite_params *ts_params = &testsuite_params;
4465         struct crypto_unittest_params *ut_params = &unittest_params;
4466         uint8_t *plaintext, *ciphertext;
4467         int retval;
4468         uint32_t plaintext_len;
4469         uint32_t plaintext_pad_len;
4470         uint8_t extra_offset = 4;
4471         uint8_t *expected_ciphertext_shifted;
4472         struct rte_cryptodev_info dev_info;
4473
4474         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4475         uint64_t feat_flags = dev_info.feature_flags;
4476
4477         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
4478                         ((tdata->validDataLenInBits.len % 8) != 0)) {
4479                 printf("Device doesn't support NON-Byte Aligned Data.\n");
4480                 return TEST_SKIPPED;
4481         }
4482
4483         /* Verify the capabilities */
4484         struct rte_cryptodev_sym_capability_idx cap_idx;
4485         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4486         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4487         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4488                         &cap_idx) == NULL)
4489                 return TEST_SKIPPED;
4490
4491         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4492                 return TEST_SKIPPED;
4493
4494         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4495                 return TEST_SKIPPED;
4496
4497         /* Create SNOW 3G session */
4498         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4499                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4500                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4501                                         tdata->key.data, tdata->key.len,
4502                                         tdata->cipher_iv.len);
4503         if (retval < 0)
4504                 return retval;
4505
4506         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4507         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4508
4509         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4510                         "Failed to allocate input buffer in mempool");
4511         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4512                         "Failed to allocate output buffer in mempool");
4513
4514         /* Clear mbuf payload */
4515         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4516                rte_pktmbuf_tailroom(ut_params->ibuf));
4517
4518         plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset);
4519         /*
4520          * Append data which is padded to a
4521          * multiple of the algorithms block size
4522          */
4523         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4524
4525         plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf,
4526                                                 plaintext_pad_len);
4527
4528         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4529
4530         memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3));
4531         buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset);
4532
4533 #ifdef RTE_APP_TEST_DEBUG
4534         rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
4535 #endif
4536         /* Create SNOW 3G operation */
4537         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4538                                         tdata->cipher_iv.len,
4539                                         tdata->validCipherLenInBits.len,
4540                                         extra_offset);
4541         if (retval < 0)
4542                 return retval;
4543
4544         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4545                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4546                         ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4547         else
4548                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4549                                                 ut_params->op);
4550         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4551
4552         ut_params->obuf = ut_params->op->sym->m_dst;
4553         if (ut_params->obuf)
4554                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4555         else
4556                 ciphertext = plaintext;
4557
4558 #ifdef RTE_APP_TEST_DEBUG
4559         rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4560 #endif
4561
4562         expected_ciphertext_shifted = rte_malloc(NULL, plaintext_len, 8);
4563
4564         TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted,
4565                         "failed to reserve memory for ciphertext shifted\n");
4566
4567         memcpy(expected_ciphertext_shifted, tdata->ciphertext.data,
4568                         ceil_byte_length(tdata->ciphertext.len));
4569         buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len,
4570                         extra_offset);
4571         /* Validate obuf */
4572         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
4573                 ciphertext,
4574                 expected_ciphertext_shifted,
4575                 tdata->validDataLenInBits.len,
4576                 extra_offset,
4577                 "SNOW 3G Ciphertext data not as expected");
4578         return 0;
4579 }
4580
4581 static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
4582 {
4583         struct crypto_testsuite_params *ts_params = &testsuite_params;
4584         struct crypto_unittest_params *ut_params = &unittest_params;
4585
4586         int retval;
4587
4588         uint8_t *plaintext, *ciphertext;
4589         unsigned ciphertext_pad_len;
4590         unsigned ciphertext_len;
4591         struct rte_cryptodev_info dev_info;
4592
4593         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4594         uint64_t feat_flags = dev_info.feature_flags;
4595
4596         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4597                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4598                 printf("Device doesn't support RAW data-path APIs.\n");
4599                 return TEST_SKIPPED;
4600         }
4601
4602         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4603                 return TEST_SKIPPED;
4604
4605         /* Verify the capabilities */
4606         struct rte_cryptodev_sym_capability_idx cap_idx;
4607         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4608         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4609         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4610                         &cap_idx) == NULL)
4611                 return TEST_SKIPPED;
4612
4613         /* Create SNOW 3G session */
4614         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4615                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4616                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4617                                         tdata->key.data, tdata->key.len,
4618                                         tdata->cipher_iv.len);
4619         if (retval < 0)
4620                 return retval;
4621
4622         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4623
4624         /* Clear mbuf payload */
4625         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4626                rte_pktmbuf_tailroom(ut_params->ibuf));
4627
4628         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4629         /* Append data which is padded to a multiple of */
4630         /* the algorithms block size */
4631         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4632         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4633                                 ciphertext_pad_len);
4634         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4635
4636         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4637
4638         /* Create SNOW 3G operation */
4639         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4640                                         tdata->cipher_iv.len,
4641                                         tdata->validCipherLenInBits.len,
4642                                         tdata->cipher.offset_bits);
4643         if (retval < 0)
4644                 return retval;
4645
4646         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4647                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4648                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4649         else
4650                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4651                                                 ut_params->op);
4652         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4653         ut_params->obuf = ut_params->op->sym->m_dst;
4654         if (ut_params->obuf)
4655                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4656         else
4657                 plaintext = ciphertext;
4658
4659         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4660
4661         /* Validate obuf */
4662         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4663                                 tdata->plaintext.data,
4664                                 tdata->validDataLenInBits.len,
4665                                 "SNOW 3G Plaintext data not as expected");
4666         return 0;
4667 }
4668
4669 static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
4670 {
4671         struct crypto_testsuite_params *ts_params = &testsuite_params;
4672         struct crypto_unittest_params *ut_params = &unittest_params;
4673
4674         int retval;
4675
4676         uint8_t *plaintext, *ciphertext;
4677         unsigned ciphertext_pad_len;
4678         unsigned ciphertext_len;
4679         struct rte_cryptodev_info dev_info;
4680
4681         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4682         uint64_t feat_flags = dev_info.feature_flags;
4683
4684         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4685                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4686                 printf("Device does not support RAW data-path APIs.\n");
4687                 return -ENOTSUP;
4688         }
4689         /* Verify the capabilities */
4690         struct rte_cryptodev_sym_capability_idx cap_idx;
4691         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4692         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4693         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4694                         &cap_idx) == NULL)
4695                 return TEST_SKIPPED;
4696
4697         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4698                 return TEST_SKIPPED;
4699
4700         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4701                 return TEST_SKIPPED;
4702
4703         /* Create SNOW 3G session */
4704         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4705                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4706                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4707                                         tdata->key.data, tdata->key.len,
4708                                         tdata->cipher_iv.len);
4709         if (retval < 0)
4710                 return retval;
4711
4712         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4713         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4714
4715         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4716                         "Failed to allocate input buffer");
4717         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4718                         "Failed to allocate output buffer");
4719
4720         /* Clear mbuf payload */
4721         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4722                rte_pktmbuf_tailroom(ut_params->ibuf));
4723
4724         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
4725                        rte_pktmbuf_tailroom(ut_params->obuf));
4726
4727         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4728         /* Append data which is padded to a multiple of */
4729         /* the algorithms block size */
4730         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4731         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4732                                 ciphertext_pad_len);
4733         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4734         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4735
4736         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4737
4738         /* Create SNOW 3G operation */
4739         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4740                                         tdata->cipher_iv.len,
4741                                         tdata->validCipherLenInBits.len,
4742                                         0);
4743         if (retval < 0)
4744                 return retval;
4745
4746         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4747                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4748                         ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4749         else
4750                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4751                                                 ut_params->op);
4752         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4753         ut_params->obuf = ut_params->op->sym->m_dst;
4754         if (ut_params->obuf)
4755                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4756         else
4757                 plaintext = ciphertext;
4758
4759         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4760
4761         /* Validate obuf */
4762         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4763                                 tdata->plaintext.data,
4764                                 tdata->validDataLenInBits.len,
4765                                 "SNOW 3G Plaintext data not as expected");
4766         return 0;
4767 }
4768
4769 static int
4770 test_zuc_cipher_auth(const struct wireless_test_data *tdata)
4771 {
4772         struct crypto_testsuite_params *ts_params = &testsuite_params;
4773         struct crypto_unittest_params *ut_params = &unittest_params;
4774
4775         int retval;
4776
4777         uint8_t *plaintext, *ciphertext;
4778         unsigned int plaintext_pad_len;
4779         unsigned int plaintext_len;
4780
4781         struct rte_cryptodev_info dev_info;
4782         struct rte_cryptodev_sym_capability_idx cap_idx;
4783
4784         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4785         uint64_t feat_flags = dev_info.feature_flags;
4786
4787         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
4788                         ((tdata->validAuthLenInBits.len % 8 != 0) ||
4789                         (tdata->validDataLenInBits.len % 8 != 0))) {
4790                 printf("Device doesn't support NON-Byte Aligned Data.\n");
4791                 return TEST_SKIPPED;
4792         }
4793
4794         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4795                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4796                 printf("Device doesn't support RAW data-path APIs.\n");
4797                 return TEST_SKIPPED;
4798         }
4799
4800         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4801                 return TEST_SKIPPED;
4802
4803         /* Check if device supports ZUC EEA3 */
4804         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4805         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
4806
4807         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4808                         &cap_idx) == NULL)
4809                 return TEST_SKIPPED;
4810
4811         /* Check if device supports ZUC EIA3 */
4812         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4813         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
4814
4815         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4816                         &cap_idx) == NULL)
4817                 return TEST_SKIPPED;
4818
4819         /* Create ZUC session */
4820         retval = create_zuc_cipher_auth_encrypt_generate_session(
4821                         ts_params->valid_devs[0],
4822                         tdata);
4823         if (retval != 0)
4824                 return retval;
4825         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4826
4827         /* clear mbuf payload */
4828         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4829                         rte_pktmbuf_tailroom(ut_params->ibuf));
4830
4831         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4832         /* Append data which is padded to a multiple of */
4833         /* the algorithms block size */
4834         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4835         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4836                                 plaintext_pad_len);
4837         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4838
4839         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4840
4841         /* Create ZUC operation */
4842         retval = create_zuc_cipher_hash_generate_operation(tdata);
4843         if (retval < 0)
4844                 return retval;
4845
4846         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4847                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4848                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4849         else
4850                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4851                         ut_params->op);
4852         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4853         ut_params->obuf = ut_params->op->sym->m_src;
4854         if (ut_params->obuf)
4855                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4856         else
4857                 ciphertext = plaintext;
4858
4859         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4860         /* Validate obuf */
4861         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4862                         ciphertext,
4863                         tdata->ciphertext.data,
4864                         tdata->validDataLenInBits.len,
4865                         "ZUC Ciphertext data not as expected");
4866
4867         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4868             + plaintext_pad_len;
4869
4870         /* Validate obuf */
4871         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4872                         ut_params->digest,
4873                         tdata->digest.data,
4874                         4,
4875                         "ZUC Generated auth tag not as expected");
4876         return 0;
4877 }
4878
4879 static int
4880 test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
4881 {
4882         struct crypto_testsuite_params *ts_params = &testsuite_params;
4883         struct crypto_unittest_params *ut_params = &unittest_params;
4884
4885         int retval;
4886
4887         uint8_t *plaintext, *ciphertext;
4888         unsigned plaintext_pad_len;
4889         unsigned plaintext_len;
4890         struct rte_cryptodev_info dev_info;
4891
4892         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4893         uint64_t feat_flags = dev_info.feature_flags;
4894
4895         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4896                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4897                 printf("Device doesn't support RAW data-path APIs.\n");
4898                 return TEST_SKIPPED;
4899         }
4900
4901         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4902                 return TEST_SKIPPED;
4903
4904         /* Verify the capabilities */
4905         struct rte_cryptodev_sym_capability_idx cap_idx;
4906         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4907         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
4908         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4909                         &cap_idx) == NULL)
4910                 return TEST_SKIPPED;
4911         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4912         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4913         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4914                         &cap_idx) == NULL)
4915                 return TEST_SKIPPED;
4916
4917         /* Create SNOW 3G session */
4918         retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0],
4919                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4920                         RTE_CRYPTO_AUTH_OP_GENERATE,
4921                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4922                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4923                         tdata->key.data, tdata->key.len,
4924                         tdata->auth_iv.len, tdata->digest.len,
4925                         tdata->cipher_iv.len);
4926         if (retval != 0)
4927                 return retval;
4928         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4929
4930         /* clear mbuf payload */
4931         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4932                         rte_pktmbuf_tailroom(ut_params->ibuf));
4933
4934         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4935         /* Append data which is padded to a multiple of */
4936         /* the algorithms block size */
4937         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4938         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4939                                 plaintext_pad_len);
4940         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4941
4942         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4943
4944         /* Create SNOW 3G operation */
4945         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
4946                         tdata->digest.len, tdata->auth_iv.data,
4947                         tdata->auth_iv.len,
4948                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
4949                         tdata->cipher_iv.data, tdata->cipher_iv.len,
4950                         tdata->validCipherLenInBits.len,
4951                         0,
4952                         tdata->validAuthLenInBits.len,
4953                         0
4954                         );
4955         if (retval < 0)
4956                 return retval;
4957
4958         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4959                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4960                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4961         else
4962                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4963                         ut_params->op);
4964         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4965         ut_params->obuf = ut_params->op->sym->m_src;
4966         if (ut_params->obuf)
4967                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4968         else
4969                 ciphertext = plaintext;
4970
4971         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4972         /* Validate obuf */
4973         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4974                         ciphertext,
4975                         tdata->ciphertext.data,
4976                         tdata->validDataLenInBits.len,
4977                         "SNOW 3G Ciphertext data not as expected");
4978
4979         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4980             + plaintext_pad_len;
4981
4982         /* Validate obuf */
4983         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4984                         ut_params->digest,
4985                         tdata->digest.data,
4986                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4987                         "SNOW 3G Generated auth tag not as expected");
4988         return 0;
4989 }
4990
4991 static int
4992 test_snow3g_auth_cipher(const struct snow3g_test_data *tdata,
4993         uint8_t op_mode, uint8_t verify)
4994 {
4995         struct crypto_testsuite_params *ts_params = &testsuite_params;
4996         struct crypto_unittest_params *ut_params = &unittest_params;
4997
4998         int retval;
4999
5000         uint8_t *plaintext = NULL, *ciphertext = NULL;
5001         unsigned int plaintext_pad_len;
5002         unsigned int plaintext_len;
5003         unsigned int ciphertext_pad_len;
5004         unsigned int ciphertext_len;
5005
5006         struct rte_cryptodev_info dev_info;
5007
5008         /* Verify the capabilities */
5009         struct rte_cryptodev_sym_capability_idx cap_idx;
5010         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5011         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
5012         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5013                         &cap_idx) == NULL)
5014                 return TEST_SKIPPED;
5015         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5016         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
5017         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5018                         &cap_idx) == NULL)
5019                 return TEST_SKIPPED;
5020
5021         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5022                 return TEST_SKIPPED;
5023
5024         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5025
5026         uint64_t feat_flags = dev_info.feature_flags;
5027
5028         if (op_mode == OUT_OF_PLACE) {
5029                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5030                         printf("Device doesn't support digest encrypted.\n");
5031                         return TEST_SKIPPED;
5032                 }
5033                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5034                         return TEST_SKIPPED;
5035         }
5036
5037         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5038                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5039                 printf("Device doesn't support RAW data-path APIs.\n");
5040                 return TEST_SKIPPED;
5041         }
5042
5043         /* Create SNOW 3G session */
5044         retval = create_wireless_algo_auth_cipher_session(
5045                         ts_params->valid_devs[0],
5046                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5047                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5048                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5049                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5050                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
5051                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
5052                         tdata->key.data, tdata->key.len,
5053                         tdata->auth_iv.len, tdata->digest.len,
5054                         tdata->cipher_iv.len);
5055         if (retval != 0)
5056                 return retval;
5057
5058         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5059         if (op_mode == OUT_OF_PLACE)
5060                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5061
5062         /* clear mbuf payload */
5063         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5064                 rte_pktmbuf_tailroom(ut_params->ibuf));
5065         if (op_mode == OUT_OF_PLACE)
5066                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5067                         rte_pktmbuf_tailroom(ut_params->obuf));
5068
5069         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5070         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5071         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5072         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5073
5074         if (verify) {
5075                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5076                                         ciphertext_pad_len);
5077                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
5078                 if (op_mode == OUT_OF_PLACE)
5079                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
5080                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5081                         ciphertext_len);
5082         } else {
5083                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5084                                         plaintext_pad_len);
5085                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5086                 if (op_mode == OUT_OF_PLACE)
5087                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
5088                 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5089         }
5090
5091         /* Create SNOW 3G operation */
5092         retval = create_wireless_algo_auth_cipher_operation(
5093                 tdata->digest.data, tdata->digest.len,
5094                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5095                 tdata->auth_iv.data, tdata->auth_iv.len,
5096                 (tdata->digest.offset_bytes == 0 ?
5097                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5098                         : tdata->digest.offset_bytes),
5099                 tdata->validCipherLenInBits.len,
5100                 tdata->cipher.offset_bits,
5101                 tdata->validAuthLenInBits.len,
5102                 tdata->auth.offset_bits,
5103                 op_mode, 0, verify);
5104
5105         if (retval < 0)
5106                 return retval;
5107
5108         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5109                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5110                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5111         else
5112                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5113                         ut_params->op);
5114
5115         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5116
5117         ut_params->obuf = (op_mode == IN_PLACE ?
5118                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5119
5120         if (verify) {
5121                 if (ut_params->obuf)
5122                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5123                                                         uint8_t *);
5124                 else
5125                         plaintext = ciphertext +
5126                                 (tdata->cipher.offset_bits >> 3);
5127
5128                 debug_hexdump(stdout, "plaintext:", plaintext,
5129                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5130                 debug_hexdump(stdout, "plaintext expected:",
5131                         tdata->plaintext.data,
5132                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5133         } else {
5134                 if (ut_params->obuf)
5135                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5136                                                         uint8_t *);
5137                 else
5138                         ciphertext = plaintext;
5139
5140                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5141                         ciphertext_len);
5142                 debug_hexdump(stdout, "ciphertext expected:",
5143                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5144
5145                 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5146                         + (tdata->digest.offset_bytes == 0 ?
5147                 plaintext_pad_len : tdata->digest.offset_bytes);
5148
5149                 debug_hexdump(stdout, "digest:", ut_params->digest,
5150                         tdata->digest.len);
5151                 debug_hexdump(stdout, "digest expected:", tdata->digest.data,
5152                                 tdata->digest.len);
5153         }
5154
5155         /* Validate obuf */
5156         if (verify) {
5157                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5158                         plaintext,
5159                         tdata->plaintext.data,
5160                         (tdata->plaintext.len - tdata->cipher.offset_bits -
5161                          (tdata->digest.len << 3)),
5162                         tdata->cipher.offset_bits,
5163                         "SNOW 3G Plaintext data not as expected");
5164         } else {
5165                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5166                         ciphertext,
5167                         tdata->ciphertext.data,
5168                         (tdata->validDataLenInBits.len -
5169                          tdata->cipher.offset_bits),
5170                         tdata->cipher.offset_bits,
5171                         "SNOW 3G Ciphertext data not as expected");
5172
5173                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5174                         ut_params->digest,
5175                         tdata->digest.data,
5176                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5177                         "SNOW 3G Generated auth tag not as expected");
5178         }
5179         return 0;
5180 }
5181
5182 static int
5183 test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata,
5184         uint8_t op_mode, uint8_t verify)
5185 {
5186         struct crypto_testsuite_params *ts_params = &testsuite_params;
5187         struct crypto_unittest_params *ut_params = &unittest_params;
5188
5189         int retval;
5190
5191         const uint8_t *plaintext = NULL;
5192         const uint8_t *ciphertext = NULL;
5193         const uint8_t *digest = NULL;
5194         unsigned int plaintext_pad_len;
5195         unsigned int plaintext_len;
5196         unsigned int ciphertext_pad_len;
5197         unsigned int ciphertext_len;
5198         uint8_t buffer[10000];
5199         uint8_t digest_buffer[10000];
5200
5201         struct rte_cryptodev_info dev_info;
5202
5203         /* Verify the capabilities */
5204         struct rte_cryptodev_sym_capability_idx cap_idx;
5205         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5206         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
5207         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5208                         &cap_idx) == NULL)
5209                 return TEST_SKIPPED;
5210         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5211         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
5212         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5213                         &cap_idx) == NULL)
5214                 return TEST_SKIPPED;
5215
5216         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5217                 return TEST_SKIPPED;
5218
5219         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5220
5221         uint64_t feat_flags = dev_info.feature_flags;
5222
5223         if (op_mode == IN_PLACE) {
5224                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5225                         printf("Device doesn't support in-place scatter-gather "
5226                                         "in both input and output mbufs.\n");
5227                         return TEST_SKIPPED;
5228                 }
5229                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5230                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5231                         printf("Device doesn't support RAW data-path APIs.\n");
5232                         return TEST_SKIPPED;
5233                 }
5234         } else {
5235                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5236                         return TEST_SKIPPED;
5237                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5238                         printf("Device doesn't support out-of-place scatter-gather "
5239                                         "in both input and output mbufs.\n");
5240                         return TEST_SKIPPED;
5241                 }
5242                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5243                         printf("Device doesn't support digest encrypted.\n");
5244                         return TEST_SKIPPED;
5245                 }
5246         }
5247
5248         /* Create SNOW 3G session */
5249         retval = create_wireless_algo_auth_cipher_session(
5250                         ts_params->valid_devs[0],
5251                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5252                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5253                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5254                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5255                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
5256                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
5257                         tdata->key.data, tdata->key.len,
5258                         tdata->auth_iv.len, tdata->digest.len,
5259                         tdata->cipher_iv.len);
5260
5261         if (retval != 0)
5262                 return retval;
5263
5264         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5265         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5266         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5267         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5268
5269         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5270                         plaintext_pad_len, 15, 0);
5271         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5272                         "Failed to allocate input buffer in mempool");
5273
5274         if (op_mode == OUT_OF_PLACE) {
5275                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5276                                 plaintext_pad_len, 15, 0);
5277                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5278                                 "Failed to allocate output buffer in mempool");
5279         }
5280
5281         if (verify) {
5282                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
5283                         tdata->ciphertext.data);
5284                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5285                                         ciphertext_len, buffer);
5286                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5287                         ciphertext_len);
5288         } else {
5289                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5290                         tdata->plaintext.data);
5291                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5292                                         plaintext_len, buffer);
5293                 debug_hexdump(stdout, "plaintext:", plaintext,
5294                         plaintext_len);
5295         }
5296         memset(buffer, 0, sizeof(buffer));
5297
5298         /* Create SNOW 3G operation */
5299         retval = create_wireless_algo_auth_cipher_operation(
5300                 tdata->digest.data, tdata->digest.len,
5301                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5302                 tdata->auth_iv.data, tdata->auth_iv.len,
5303                 (tdata->digest.offset_bytes == 0 ?
5304                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5305                         : tdata->digest.offset_bytes),
5306                 tdata->validCipherLenInBits.len,
5307                 tdata->cipher.offset_bits,
5308                 tdata->validAuthLenInBits.len,
5309                 tdata->auth.offset_bits,
5310                 op_mode, 1, verify);
5311
5312         if (retval < 0)
5313                 return retval;
5314
5315         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5316                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5317                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5318         else
5319                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5320                         ut_params->op);
5321
5322         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5323
5324         ut_params->obuf = (op_mode == IN_PLACE ?
5325                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5326
5327         if (verify) {
5328                 if (ut_params->obuf)
5329                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
5330                                         plaintext_len, buffer);
5331                 else
5332                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5333                                         plaintext_len, buffer);
5334
5335                 debug_hexdump(stdout, "plaintext:", plaintext,
5336                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5337                 debug_hexdump(stdout, "plaintext expected:",
5338                         tdata->plaintext.data,
5339                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5340         } else {
5341                 if (ut_params->obuf)
5342                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
5343                                         ciphertext_len, buffer);
5344                 else
5345                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5346                                         ciphertext_len, buffer);
5347
5348                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5349                         ciphertext_len);
5350                 debug_hexdump(stdout, "ciphertext expected:",
5351                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5352
5353                 if (ut_params->obuf)
5354                         digest = rte_pktmbuf_read(ut_params->obuf,
5355                                 (tdata->digest.offset_bytes == 0 ?
5356                                 plaintext_pad_len : tdata->digest.offset_bytes),
5357                                 tdata->digest.len, digest_buffer);
5358                 else
5359                         digest = rte_pktmbuf_read(ut_params->ibuf,
5360                                 (tdata->digest.offset_bytes == 0 ?
5361                                 plaintext_pad_len : tdata->digest.offset_bytes),
5362                                 tdata->digest.len, digest_buffer);
5363
5364                 debug_hexdump(stdout, "digest:", digest,
5365                         tdata->digest.len);
5366                 debug_hexdump(stdout, "digest expected:",
5367                         tdata->digest.data, tdata->digest.len);
5368         }
5369
5370         /* Validate obuf */
5371         if (verify) {
5372                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5373                         plaintext,
5374                         tdata->plaintext.data,
5375                         (tdata->plaintext.len - tdata->cipher.offset_bits -
5376                          (tdata->digest.len << 3)),
5377                         tdata->cipher.offset_bits,
5378                         "SNOW 3G Plaintext data not as expected");
5379         } else {
5380                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5381                         ciphertext,
5382                         tdata->ciphertext.data,
5383                         (tdata->validDataLenInBits.len -
5384                          tdata->cipher.offset_bits),
5385                         tdata->cipher.offset_bits,
5386                         "SNOW 3G Ciphertext data not as expected");
5387
5388                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5389                         digest,
5390                         tdata->digest.data,
5391                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5392                         "SNOW 3G Generated auth tag not as expected");
5393         }
5394         return 0;
5395 }
5396
5397 static int
5398 test_kasumi_auth_cipher(const struct kasumi_test_data *tdata,
5399         uint8_t op_mode, uint8_t verify)
5400 {
5401         struct crypto_testsuite_params *ts_params = &testsuite_params;
5402         struct crypto_unittest_params *ut_params = &unittest_params;
5403
5404         int retval;
5405
5406         uint8_t *plaintext = NULL, *ciphertext = NULL;
5407         unsigned int plaintext_pad_len;
5408         unsigned int plaintext_len;
5409         unsigned int ciphertext_pad_len;
5410         unsigned int ciphertext_len;
5411
5412         struct rte_cryptodev_info dev_info;
5413
5414         /* Verify the capabilities */
5415         struct rte_cryptodev_sym_capability_idx cap_idx;
5416         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5417         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5418         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5419                         &cap_idx) == NULL)
5420                 return TEST_SKIPPED;
5421         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5422         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5423         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5424                         &cap_idx) == NULL)
5425                 return TEST_SKIPPED;
5426
5427         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5428
5429         uint64_t feat_flags = dev_info.feature_flags;
5430
5431         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5432                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5433                 printf("Device doesn't support RAW data-path APIs.\n");
5434                 return TEST_SKIPPED;
5435         }
5436
5437         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5438                 return TEST_SKIPPED;
5439
5440         if (op_mode == OUT_OF_PLACE) {
5441                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5442                         return TEST_SKIPPED;
5443                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5444                         printf("Device doesn't support digest encrypted.\n");
5445                         return TEST_SKIPPED;
5446                 }
5447         }
5448
5449         /* Create KASUMI session */
5450         retval = create_wireless_algo_auth_cipher_session(
5451                         ts_params->valid_devs[0],
5452                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5453                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5454                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5455                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5456                         RTE_CRYPTO_AUTH_KASUMI_F9,
5457                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5458                         tdata->key.data, tdata->key.len,
5459                         0, tdata->digest.len,
5460                         tdata->cipher_iv.len);
5461
5462         if (retval != 0)
5463                 return retval;
5464
5465         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5466         if (op_mode == OUT_OF_PLACE)
5467                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5468
5469         /* clear mbuf payload */
5470         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5471                 rte_pktmbuf_tailroom(ut_params->ibuf));
5472         if (op_mode == OUT_OF_PLACE)
5473                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5474                         rte_pktmbuf_tailroom(ut_params->obuf));
5475
5476         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5477         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5478         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5479         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5480
5481         if (verify) {
5482                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5483                                         ciphertext_pad_len);
5484                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
5485                 if (op_mode == OUT_OF_PLACE)
5486                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
5487                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5488                         ciphertext_len);
5489         } else {
5490                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5491                                         plaintext_pad_len);
5492                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5493                 if (op_mode == OUT_OF_PLACE)
5494                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
5495                 debug_hexdump(stdout, "plaintext:", plaintext,
5496                         plaintext_len);
5497         }
5498
5499         /* Create KASUMI operation */
5500         retval = create_wireless_algo_auth_cipher_operation(
5501                 tdata->digest.data, tdata->digest.len,
5502                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5503                 NULL, 0,
5504                 (tdata->digest.offset_bytes == 0 ?
5505                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5506                         : tdata->digest.offset_bytes),
5507                 tdata->validCipherLenInBits.len,
5508                 tdata->validCipherOffsetInBits.len,
5509                 tdata->validAuthLenInBits.len,
5510                 0,
5511                 op_mode, 0, verify);
5512
5513         if (retval < 0)
5514                 return retval;
5515
5516         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5517                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5518                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5519         else
5520                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5521                         ut_params->op);
5522
5523         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5524
5525         ut_params->obuf = (op_mode == IN_PLACE ?
5526                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5527
5528
5529         if (verify) {
5530                 if (ut_params->obuf)
5531                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5532                                                         uint8_t *);
5533                 else
5534                         plaintext = ciphertext;
5535
5536                 debug_hexdump(stdout, "plaintext:", plaintext,
5537                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5538                 debug_hexdump(stdout, "plaintext expected:",
5539                         tdata->plaintext.data,
5540                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5541         } else {
5542                 if (ut_params->obuf)
5543                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5544                                                         uint8_t *);
5545                 else
5546                         ciphertext = plaintext;
5547
5548                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5549                         ciphertext_len);
5550                 debug_hexdump(stdout, "ciphertext expected:",
5551                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5552
5553                 ut_params->digest = rte_pktmbuf_mtod(
5554                         ut_params->obuf, uint8_t *) +
5555                         (tdata->digest.offset_bytes == 0 ?
5556                         plaintext_pad_len : tdata->digest.offset_bytes);
5557
5558                 debug_hexdump(stdout, "digest:", ut_params->digest,
5559                         tdata->digest.len);
5560                 debug_hexdump(stdout, "digest expected:",
5561                         tdata->digest.data, tdata->digest.len);
5562         }
5563
5564         /* Validate obuf */
5565         if (verify) {
5566                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5567                         plaintext,
5568                         tdata->plaintext.data,
5569                         tdata->plaintext.len >> 3,
5570                         "KASUMI Plaintext data not as expected");
5571         } else {
5572                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5573                         ciphertext,
5574                         tdata->ciphertext.data,
5575                         tdata->ciphertext.len >> 3,
5576                         "KASUMI Ciphertext data not as expected");
5577
5578                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5579                         ut_params->digest,
5580                         tdata->digest.data,
5581                         DIGEST_BYTE_LENGTH_KASUMI_F9,
5582                         "KASUMI Generated auth tag not as expected");
5583         }
5584         return 0;
5585 }
5586
5587 static int
5588 test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata,
5589         uint8_t op_mode, uint8_t verify)
5590 {
5591         struct crypto_testsuite_params *ts_params = &testsuite_params;
5592         struct crypto_unittest_params *ut_params = &unittest_params;
5593
5594         int retval;
5595
5596         const uint8_t *plaintext = NULL;
5597         const uint8_t *ciphertext = NULL;
5598         const uint8_t *digest = NULL;
5599         unsigned int plaintext_pad_len;
5600         unsigned int plaintext_len;
5601         unsigned int ciphertext_pad_len;
5602         unsigned int ciphertext_len;
5603         uint8_t buffer[10000];
5604         uint8_t digest_buffer[10000];
5605
5606         struct rte_cryptodev_info dev_info;
5607
5608         /* Verify the capabilities */
5609         struct rte_cryptodev_sym_capability_idx cap_idx;
5610         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5611         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5612         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5613                         &cap_idx) == NULL)
5614                 return TEST_SKIPPED;
5615         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5616         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5617         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5618                         &cap_idx) == NULL)
5619                 return TEST_SKIPPED;
5620
5621         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5622                 return TEST_SKIPPED;
5623
5624         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5625
5626         uint64_t feat_flags = dev_info.feature_flags;
5627
5628         if (op_mode == IN_PLACE) {
5629                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5630                         printf("Device doesn't support in-place scatter-gather "
5631                                         "in both input and output mbufs.\n");
5632                         return TEST_SKIPPED;
5633                 }
5634                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5635                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5636                         printf("Device doesn't support RAW data-path APIs.\n");
5637                         return TEST_SKIPPED;
5638                 }
5639         } else {
5640                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5641                         return TEST_SKIPPED;
5642                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5643                         printf("Device doesn't support out-of-place scatter-gather "
5644                                         "in both input and output mbufs.\n");
5645                         return TEST_SKIPPED;
5646                 }
5647                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5648                         printf("Device doesn't support digest encrypted.\n");
5649                         return TEST_SKIPPED;
5650                 }
5651         }
5652
5653         /* Create KASUMI session */
5654         retval = create_wireless_algo_auth_cipher_session(
5655                         ts_params->valid_devs[0],
5656                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5657                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5658                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5659                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5660                         RTE_CRYPTO_AUTH_KASUMI_F9,
5661                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5662                         tdata->key.data, tdata->key.len,
5663                         0, tdata->digest.len,
5664                         tdata->cipher_iv.len);
5665
5666         if (retval != 0)
5667                 return retval;
5668
5669         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5670         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5671         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5672         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5673
5674         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5675                         plaintext_pad_len, 15, 0);
5676         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5677                         "Failed to allocate input buffer in mempool");
5678
5679         if (op_mode == OUT_OF_PLACE) {
5680                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5681                                 plaintext_pad_len, 15, 0);
5682                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5683                                 "Failed to allocate output buffer in mempool");
5684         }
5685
5686         if (verify) {
5687                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
5688                         tdata->ciphertext.data);
5689                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5690                                         ciphertext_len, buffer);
5691                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5692                         ciphertext_len);
5693         } else {
5694                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5695                         tdata->plaintext.data);
5696                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5697                                         plaintext_len, buffer);
5698                 debug_hexdump(stdout, "plaintext:", plaintext,
5699                         plaintext_len);
5700         }
5701         memset(buffer, 0, sizeof(buffer));
5702
5703         /* Create KASUMI operation */
5704         retval = create_wireless_algo_auth_cipher_operation(
5705                 tdata->digest.data, tdata->digest.len,
5706                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5707                 NULL, 0,
5708                 (tdata->digest.offset_bytes == 0 ?
5709                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5710                         : tdata->digest.offset_bytes),
5711                 tdata->validCipherLenInBits.len,
5712                 tdata->validCipherOffsetInBits.len,
5713                 tdata->validAuthLenInBits.len,
5714                 0,
5715                 op_mode, 1, verify);
5716
5717         if (retval < 0)
5718                 return retval;
5719
5720         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5721                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5722                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5723         else
5724                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5725                         ut_params->op);
5726
5727         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5728
5729         ut_params->obuf = (op_mode == IN_PLACE ?
5730                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5731
5732         if (verify) {
5733                 if (ut_params->obuf)
5734                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
5735                                         plaintext_len, buffer);
5736                 else
5737                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5738                                         plaintext_len, buffer);
5739
5740                 debug_hexdump(stdout, "plaintext:", plaintext,
5741                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5742                 debug_hexdump(stdout, "plaintext expected:",
5743                         tdata->plaintext.data,
5744                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5745         } else {
5746                 if (ut_params->obuf)
5747                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
5748                                         ciphertext_len, buffer);
5749                 else
5750                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5751                                         ciphertext_len, buffer);
5752
5753                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5754                         ciphertext_len);
5755                 debug_hexdump(stdout, "ciphertext expected:",
5756                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5757
5758                 if (ut_params->obuf)
5759                         digest = rte_pktmbuf_read(ut_params->obuf,
5760                                 (tdata->digest.offset_bytes == 0 ?
5761                                 plaintext_pad_len : tdata->digest.offset_bytes),
5762                                 tdata->digest.len, digest_buffer);
5763                 else
5764                         digest = rte_pktmbuf_read(ut_params->ibuf,
5765                                 (tdata->digest.offset_bytes == 0 ?
5766                                 plaintext_pad_len : tdata->digest.offset_bytes),
5767                                 tdata->digest.len, digest_buffer);
5768
5769                 debug_hexdump(stdout, "digest:", digest,
5770                         tdata->digest.len);
5771                 debug_hexdump(stdout, "digest expected:",
5772                         tdata->digest.data, tdata->digest.len);
5773         }
5774
5775         /* Validate obuf */
5776         if (verify) {
5777                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5778                         plaintext,
5779                         tdata->plaintext.data,
5780                         tdata->plaintext.len >> 3,
5781                         "KASUMI Plaintext data not as expected");
5782         } else {
5783                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5784                         ciphertext,
5785                         tdata->ciphertext.data,
5786                         tdata->validDataLenInBits.len,
5787                         "KASUMI Ciphertext data not as expected");
5788
5789                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5790                         digest,
5791                         tdata->digest.data,
5792                         DIGEST_BYTE_LENGTH_KASUMI_F9,
5793                         "KASUMI Generated auth tag not as expected");
5794         }
5795         return 0;
5796 }
5797
5798 static int
5799 test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
5800 {
5801         struct crypto_testsuite_params *ts_params = &testsuite_params;
5802         struct crypto_unittest_params *ut_params = &unittest_params;
5803
5804         int retval;
5805
5806         uint8_t *plaintext, *ciphertext;
5807         unsigned plaintext_pad_len;
5808         unsigned plaintext_len;
5809         struct rte_cryptodev_info dev_info;
5810
5811         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5812         uint64_t feat_flags = dev_info.feature_flags;
5813
5814         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5815                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5816                 printf("Device doesn't support RAW data-path APIs.\n");
5817                 return TEST_SKIPPED;
5818         }
5819
5820         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5821                 return TEST_SKIPPED;
5822
5823         /* Verify the capabilities */
5824         struct rte_cryptodev_sym_capability_idx cap_idx;
5825         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5826         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5827         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5828                         &cap_idx) == NULL)
5829                 return TEST_SKIPPED;
5830         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5831         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5832         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5833                         &cap_idx) == NULL)
5834                 return TEST_SKIPPED;
5835
5836         /* Create KASUMI session */
5837         retval = create_wireless_algo_cipher_auth_session(
5838                         ts_params->valid_devs[0],
5839                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5840                         RTE_CRYPTO_AUTH_OP_GENERATE,
5841                         RTE_CRYPTO_AUTH_KASUMI_F9,
5842                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5843                         tdata->key.data, tdata->key.len,
5844                         0, tdata->digest.len,
5845                         tdata->cipher_iv.len);
5846         if (retval != 0)
5847                 return retval;
5848
5849         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5850
5851         /* clear mbuf payload */
5852         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5853                         rte_pktmbuf_tailroom(ut_params->ibuf));
5854
5855         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5856         /* Append data which is padded to a multiple of */
5857         /* the algorithms block size */
5858         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5859         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5860                                 plaintext_pad_len);
5861         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5862
5863         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5864
5865         /* Create KASUMI operation */
5866         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
5867                                 tdata->digest.len, NULL, 0,
5868                                 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
5869                                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5870                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
5871                                 tdata->validCipherOffsetInBits.len,
5872                                 tdata->validAuthLenInBits.len,
5873                                 0
5874                                 );
5875         if (retval < 0)
5876                 return retval;
5877
5878         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5879                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5880                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5881         else
5882                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5883                         ut_params->op);
5884         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5885
5886         if (ut_params->op->sym->m_dst)
5887                 ut_params->obuf = ut_params->op->sym->m_dst;
5888         else
5889                 ut_params->obuf = ut_params->op->sym->m_src;
5890
5891         ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
5892                                 tdata->validCipherOffsetInBits.len >> 3);
5893
5894         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5895                         + plaintext_pad_len;
5896
5897         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
5898                                 (tdata->validCipherOffsetInBits.len >> 3);
5899         /* Validate obuf */
5900         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5901                 ciphertext,
5902                 reference_ciphertext,
5903                 tdata->validCipherLenInBits.len,
5904                 "KASUMI Ciphertext data not as expected");
5905
5906         /* Validate obuf */
5907         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5908                 ut_params->digest,
5909                 tdata->digest.data,
5910                 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5911                 "KASUMI Generated auth tag not as expected");
5912         return 0;
5913 }
5914
5915 static int
5916 check_cipher_capability(const struct crypto_testsuite_params *ts_params,
5917                         const enum rte_crypto_cipher_algorithm cipher_algo,
5918                         const uint16_t key_size, const uint16_t iv_size)
5919 {
5920         struct rte_cryptodev_sym_capability_idx cap_idx;
5921         const struct rte_cryptodev_symmetric_capability *cap;
5922
5923         /* Check if device supports the algorithm */
5924         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5925         cap_idx.algo.cipher = cipher_algo;
5926
5927         cap = rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5928                         &cap_idx);
5929
5930         if (cap == NULL)
5931                 return -1;
5932
5933         /* Check if device supports key size and IV size */
5934         if (rte_cryptodev_sym_capability_check_cipher(cap, key_size,
5935                         iv_size) < 0) {
5936                 return -1;
5937         }
5938
5939         return 0;
5940 }
5941
5942 static int
5943 check_auth_capability(const struct crypto_testsuite_params *ts_params,
5944                         const enum rte_crypto_auth_algorithm auth_algo,
5945                         const uint16_t key_size, const uint16_t iv_size,
5946                         const uint16_t tag_size)
5947 {
5948         struct rte_cryptodev_sym_capability_idx cap_idx;
5949         const struct rte_cryptodev_symmetric_capability *cap;
5950
5951         /* Check if device supports the algorithm */
5952         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5953         cap_idx.algo.auth = auth_algo;
5954
5955         cap = rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5956                         &cap_idx);
5957
5958         if (cap == NULL)
5959                 return -1;
5960
5961         /* Check if device supports key size and IV size */
5962         if (rte_cryptodev_sym_capability_check_auth(cap, key_size,
5963                         tag_size, iv_size) < 0) {
5964                 return -1;
5965         }
5966
5967         return 0;
5968 }
5969
5970 static int
5971 test_zuc_encryption(const struct wireless_test_data *tdata)
5972 {
5973         struct crypto_testsuite_params *ts_params = &testsuite_params;
5974         struct crypto_unittest_params *ut_params = &unittest_params;
5975
5976         int retval;
5977         uint8_t *plaintext, *ciphertext;
5978         unsigned plaintext_pad_len;
5979         unsigned plaintext_len;
5980         struct rte_cryptodev_info dev_info;
5981
5982         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5983         uint64_t feat_flags = dev_info.feature_flags;
5984
5985         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5986                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5987                 printf("Device doesn't support RAW data-path APIs.\n");
5988                 return TEST_SKIPPED;
5989         }
5990
5991         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5992                 return TEST_SKIPPED;
5993
5994         /* Check if device supports ZUC EEA3 */
5995         if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
5996                         tdata->key.len, tdata->cipher_iv.len) < 0)
5997                 return TEST_SKIPPED;
5998
5999         /* Create ZUC session */
6000         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
6001                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
6002                                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
6003                                         tdata->key.data, tdata->key.len,
6004                                         tdata->cipher_iv.len);
6005         if (retval != 0)
6006                 return retval;
6007
6008         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6009
6010         /* Clear mbuf payload */
6011         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6012                rte_pktmbuf_tailroom(ut_params->ibuf));
6013
6014         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6015         /* Append data which is padded to a multiple */
6016         /* of the algorithms block size */
6017         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
6018         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6019                                 plaintext_pad_len);
6020         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6021
6022         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
6023
6024         /* Create ZUC operation */
6025         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
6026                                         tdata->cipher_iv.len,
6027                                         tdata->plaintext.len,
6028                                         0);
6029         if (retval < 0)
6030                 return retval;
6031
6032         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6033                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6034                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
6035         else
6036                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6037                                                 ut_params->op);
6038         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6039
6040         ut_params->obuf = ut_params->op->sym->m_dst;
6041         if (ut_params->obuf)
6042                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
6043         else
6044                 ciphertext = plaintext;
6045
6046         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
6047
6048         /* Validate obuf */
6049         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6050                 ciphertext,
6051                 tdata->ciphertext.data,
6052                 tdata->validCipherLenInBits.len,
6053                 "ZUC Ciphertext data not as expected");
6054         return 0;
6055 }
6056
6057 static int
6058 test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
6059 {
6060         struct crypto_testsuite_params *ts_params = &testsuite_params;
6061         struct crypto_unittest_params *ut_params = &unittest_params;
6062
6063         int retval;
6064
6065         unsigned int plaintext_pad_len;
6066         unsigned int plaintext_len;
6067         const uint8_t *ciphertext;
6068         uint8_t ciphertext_buffer[2048];
6069         struct rte_cryptodev_info dev_info;
6070
6071         /* Check if device supports ZUC EEA3 */
6072         if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
6073                         tdata->key.len, tdata->cipher_iv.len) < 0)
6074                 return TEST_SKIPPED;
6075
6076         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
6077                 return TEST_SKIPPED;
6078
6079         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6080
6081         uint64_t feat_flags = dev_info.feature_flags;
6082
6083         if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6084                 printf("Device doesn't support in-place scatter-gather. "
6085                                 "Test Skipped.\n");
6086                 return TEST_SKIPPED;
6087         }
6088
6089         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6090                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6091                 printf("Device doesn't support RAW data-path APIs.\n");
6092                 return TEST_SKIPPED;
6093         }
6094
6095         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6096
6097         /* Append data which is padded to a multiple */
6098         /* of the algorithms block size */
6099         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
6100
6101         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
6102                         plaintext_pad_len, 10, 0);
6103
6104         pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
6105                         tdata->plaintext.data);
6106
6107         /* Create ZUC session */
6108         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
6109                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
6110                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
6111                         tdata->key.data, tdata->key.len,
6112                         tdata->cipher_iv.len);
6113         if (retval < 0)
6114                 return retval;
6115
6116         /* Clear mbuf payload */
6117
6118         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
6119
6120         /* Create ZUC operation */
6121         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
6122                         tdata->cipher_iv.len, tdata->plaintext.len,
6123                         0);
6124         if (retval < 0)
6125                 return retval;
6126
6127         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6128                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6129                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
6130         else
6131                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6132                                                 ut_params->op);
6133         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6134
6135         ut_params->obuf = ut_params->op->sym->m_dst;
6136         if (ut_params->obuf)
6137                 ciphertext = rte_pktmbuf_read(ut_params->obuf,
6138                         0, plaintext_len, ciphertext_buffer);
6139         else
6140                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
6141                         0, plaintext_len, ciphertext_buffer);
6142
6143         /* Validate obuf */
6144         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
6145
6146         /* Validate obuf */
6147         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6148                 ciphertext,
6149                 tdata->ciphertext.data,
6150                 tdata->validCipherLenInBits.len,
6151                 "ZUC Ciphertext data not as expected");
6152
6153         return 0;
6154 }
6155
6156 static int
6157 test_zuc_authentication(const struct wireless_test_data *tdata)
6158 {
6159         struct crypto_testsuite_params *ts_params = &testsuite_params;
6160         struct crypto_unittest_params *ut_params = &unittest_params;
6161
6162         int retval;
6163         unsigned plaintext_pad_len;
6164         unsigned plaintext_len;
6165         uint8_t *plaintext;
6166
6167         struct rte_cryptodev_info dev_info;
6168
6169         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6170         uint64_t feat_flags = dev_info.feature_flags;
6171
6172         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
6173                         (tdata->validAuthLenInBits.len % 8 != 0)) {
6174                 printf("Device doesn't support NON-Byte Aligned Data.\n");
6175                 return TEST_SKIPPED;
6176         }
6177
6178         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6179                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6180                 printf("Device doesn't support RAW data-path APIs.\n");
6181                 return TEST_SKIPPED;
6182         }
6183
6184         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
6185                 return TEST_SKIPPED;
6186
6187         /* Check if device supports ZUC EIA3 */
6188         if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3,
6189                         tdata->key.len, tdata->auth_iv.len,
6190                         tdata->digest.len) < 0)
6191                 return TEST_SKIPPED;
6192
6193         /* Create ZUC session */
6194         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
6195                         tdata->key.data, tdata->key.len,
6196                         tdata->auth_iv.len, tdata->digest.len,
6197                         RTE_CRYPTO_AUTH_OP_GENERATE,
6198                         RTE_CRYPTO_AUTH_ZUC_EIA3);
6199         if (retval != 0)
6200                 return retval;
6201
6202         /* alloc mbuf and set payload */
6203         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6204
6205         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6206         rte_pktmbuf_tailroom(ut_params->ibuf));
6207
6208         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6209         /* Append data which is padded to a multiple of */
6210         /* the algorithms block size */
6211         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
6212         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6213                                 plaintext_pad_len);
6214         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6215
6216         /* Create ZUC operation */
6217         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
6218                         tdata->auth_iv.data, tdata->auth_iv.len,
6219                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
6220                         tdata->validAuthLenInBits.len,
6221                         0);
6222         if (retval < 0)
6223                 return retval;
6224
6225         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6226                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6227                                 ut_params->op, 0, 1, 1, 0);
6228         else
6229                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6230                                 ut_params->op);
6231         ut_params->obuf = ut_params->op->sym->m_src;
6232         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6233         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
6234                         + plaintext_pad_len;
6235
6236         /* Validate obuf */
6237         TEST_ASSERT_BUFFERS_ARE_EQUAL(
6238         ut_params->digest,
6239         tdata->digest.data,
6240         tdata->digest.len,
6241         "ZUC Generated auth tag not as expected");
6242
6243         return 0;
6244 }
6245
6246 static int
6247 test_zuc_auth_cipher(const struct wireless_test_data *tdata,
6248         uint8_t op_mode, uint8_t verify)
6249 {
6250         struct crypto_testsuite_params *ts_params = &testsuite_params;
6251         struct crypto_unittest_params *ut_params = &unittest_params;
6252
6253         int retval;
6254
6255         uint8_t *plaintext = NULL, *ciphertext = NULL;
6256         unsigned int plaintext_pad_len;
6257         unsigned int plaintext_len;
6258         unsigned int ciphertext_pad_len;
6259         unsigned int ciphertext_len;
6260
6261         struct rte_cryptodev_info dev_info;
6262
6263         /* Check if device supports ZUC EEA3 */
6264         if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
6265                         tdata->key.len, tdata->cipher_iv.len) < 0)
6266                 return TEST_SKIPPED;
6267
6268         /* Check if device supports ZUC EIA3 */
6269         if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3,
6270                         tdata->key.len, tdata->auth_iv.len,
6271                         tdata->digest.len) < 0)
6272                 return TEST_SKIPPED;
6273
6274         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6275
6276         uint64_t feat_flags = dev_info.feature_flags;
6277
6278         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6279                 printf("Device doesn't support digest encrypted.\n");
6280                 return TEST_SKIPPED;
6281         }
6282         if (op_mode == IN_PLACE) {
6283                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6284                         printf("Device doesn't support in-place scatter-gather "
6285                                         "in both input and output mbufs.\n");
6286                         return TEST_SKIPPED;
6287                 }
6288
6289                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6290                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6291                         printf("Device doesn't support RAW data-path APIs.\n");
6292                         return TEST_SKIPPED;
6293                 }
6294         } else {
6295                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6296                         return TEST_SKIPPED;
6297                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
6298                         printf("Device doesn't support out-of-place scatter-gather "
6299                                         "in both input and output mbufs.\n");
6300                         return TEST_SKIPPED;
6301                 }
6302         }
6303
6304         /* Create ZUC session */
6305         retval = create_wireless_algo_auth_cipher_session(
6306                         ts_params->valid_devs[0],
6307                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
6308                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
6309                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
6310                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
6311                         RTE_CRYPTO_AUTH_ZUC_EIA3,
6312                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
6313                         tdata->key.data, tdata->key.len,
6314                         tdata->auth_iv.len, tdata->digest.len,
6315                         tdata->cipher_iv.len);
6316
6317         if (retval != 0)
6318                 return retval;
6319
6320         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6321         if (op_mode == OUT_OF_PLACE)
6322                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6323
6324         /* clear mbuf payload */
6325         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6326                 rte_pktmbuf_tailroom(ut_params->ibuf));
6327         if (op_mode == OUT_OF_PLACE)
6328                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
6329                         rte_pktmbuf_tailroom(ut_params->obuf));
6330
6331         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
6332         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6333         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6334         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6335
6336         if (verify) {
6337                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6338                                         ciphertext_pad_len);
6339                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
6340                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6341                         ciphertext_len);
6342         } else {
6343                 /* make sure enough space to cover partial digest verify case */
6344                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6345                                         ciphertext_pad_len);
6346                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6347                 debug_hexdump(stdout, "plaintext:", plaintext,
6348                         plaintext_len);
6349         }
6350
6351         if (op_mode == OUT_OF_PLACE)
6352                 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
6353
6354         /* Create ZUC operation */
6355         retval = create_wireless_algo_auth_cipher_operation(
6356                 tdata->digest.data, tdata->digest.len,
6357                 tdata->cipher_iv.data, tdata->cipher_iv.len,
6358                 tdata->auth_iv.data, tdata->auth_iv.len,
6359                 (tdata->digest.offset_bytes == 0 ?
6360                 (verify ? ciphertext_pad_len : plaintext_pad_len)
6361                         : tdata->digest.offset_bytes),
6362                 tdata->validCipherLenInBits.len,
6363                 tdata->validCipherOffsetInBits.len,
6364                 tdata->validAuthLenInBits.len,
6365                 0,
6366                 op_mode, 0, verify);
6367
6368         if (retval < 0)
6369                 return retval;
6370
6371         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6372                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6373                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
6374         else
6375                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6376                         ut_params->op);
6377
6378         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6379
6380         ut_params->obuf = (op_mode == IN_PLACE ?
6381                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6382
6383
6384         if (verify) {
6385                 if (ut_params->obuf)
6386                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
6387                                                         uint8_t *);
6388                 else
6389                         plaintext = ciphertext;
6390
6391                 debug_hexdump(stdout, "plaintext:", plaintext,
6392                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6393                 debug_hexdump(stdout, "plaintext expected:",
6394                         tdata->plaintext.data,
6395                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6396         } else {
6397                 if (ut_params->obuf)
6398                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
6399                                                         uint8_t *);
6400                 else
6401                         ciphertext = plaintext;
6402
6403                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6404                         ciphertext_len);
6405                 debug_hexdump(stdout, "ciphertext expected:",
6406                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
6407
6408                 ut_params->digest = rte_pktmbuf_mtod(
6409                         ut_params->obuf, uint8_t *) +
6410                         (tdata->digest.offset_bytes == 0 ?
6411                         plaintext_pad_len : tdata->digest.offset_bytes);
6412
6413                 debug_hexdump(stdout, "digest:", ut_params->digest,
6414                         tdata->digest.len);
6415                 debug_hexdump(stdout, "digest expected:",
6416                         tdata->digest.data, tdata->digest.len);
6417         }
6418
6419         /* Validate obuf */
6420         if (verify) {
6421                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6422                         plaintext,
6423                         tdata->plaintext.data,
6424                         tdata->plaintext.len >> 3,
6425                         "ZUC Plaintext data not as expected");
6426         } else {
6427                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6428                         ciphertext,
6429                         tdata->ciphertext.data,
6430                         tdata->ciphertext.len >> 3,
6431                         "ZUC Ciphertext data not as expected");
6432
6433                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6434                         ut_params->digest,
6435                         tdata->digest.data,
6436                         DIGEST_BYTE_LENGTH_KASUMI_F9,
6437                         "ZUC Generated auth tag not as expected");
6438         }
6439         return 0;
6440 }
6441
6442 static int
6443 test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata,
6444         uint8_t op_mode, uint8_t verify)
6445 {
6446         struct crypto_testsuite_params *ts_params = &testsuite_params;
6447         struct crypto_unittest_params *ut_params = &unittest_params;
6448
6449         int retval;
6450
6451         const uint8_t *plaintext = NULL;
6452         const uint8_t *ciphertext = NULL;
6453         const uint8_t *digest = NULL;
6454         unsigned int plaintext_pad_len;
6455         unsigned int plaintext_len;
6456         unsigned int ciphertext_pad_len;
6457         unsigned int ciphertext_len;
6458         uint8_t buffer[10000];
6459         uint8_t digest_buffer[10000];
6460
6461         struct rte_cryptodev_info dev_info;
6462
6463         /* Check if device supports ZUC EEA3 */
6464         if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
6465                         tdata->key.len, tdata->cipher_iv.len) < 0)
6466                 return TEST_SKIPPED;
6467
6468         /* Check if device supports ZUC EIA3 */
6469         if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3,
6470                         tdata->key.len, tdata->auth_iv.len,
6471                         tdata->digest.len) < 0)
6472                 return TEST_SKIPPED;
6473
6474         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6475
6476         uint64_t feat_flags = dev_info.feature_flags;
6477
6478         if (op_mode == IN_PLACE) {
6479                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6480                         printf("Device doesn't support in-place scatter-gather "
6481                                         "in both input and output mbufs.\n");
6482                         return TEST_SKIPPED;
6483                 }
6484
6485                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6486                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6487                         printf("Device doesn't support RAW data-path APIs.\n");
6488                         return TEST_SKIPPED;
6489                 }
6490         } else {
6491                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6492                         return TEST_SKIPPED;
6493                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
6494                         printf("Device doesn't support out-of-place scatter-gather "
6495                                         "in both input and output mbufs.\n");
6496                         return TEST_SKIPPED;
6497                 }
6498                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6499                         printf("Device doesn't support digest encrypted.\n");
6500                         return TEST_SKIPPED;
6501                 }
6502         }
6503
6504         /* Create ZUC session */
6505         retval = create_wireless_algo_auth_cipher_session(
6506                         ts_params->valid_devs[0],
6507                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
6508                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
6509                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
6510                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
6511                         RTE_CRYPTO_AUTH_ZUC_EIA3,
6512                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
6513                         tdata->key.data, tdata->key.len,
6514                         tdata->auth_iv.len, tdata->digest.len,
6515                         tdata->cipher_iv.len);
6516
6517         if (retval != 0)
6518                 return retval;
6519
6520         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
6521         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6522         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6523         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6524
6525         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
6526                         plaintext_pad_len, 15, 0);
6527         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
6528                         "Failed to allocate input buffer in mempool");
6529
6530         if (op_mode == OUT_OF_PLACE) {
6531                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
6532                                 plaintext_pad_len, 15, 0);
6533                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
6534                                 "Failed to allocate output buffer in mempool");
6535         }
6536
6537         if (verify) {
6538                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
6539                         tdata->ciphertext.data);
6540                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6541                                         ciphertext_len, buffer);
6542                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6543                         ciphertext_len);
6544         } else {
6545                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
6546                         tdata->plaintext.data);
6547                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6548                                         plaintext_len, buffer);
6549                 debug_hexdump(stdout, "plaintext:", plaintext,
6550                         plaintext_len);
6551         }
6552         memset(buffer, 0, sizeof(buffer));
6553
6554         /* Create ZUC operation */
6555         retval = create_wireless_algo_auth_cipher_operation(
6556                 tdata->digest.data, tdata->digest.len,
6557                 tdata->cipher_iv.data, tdata->cipher_iv.len,
6558                 NULL, 0,
6559                 (tdata->digest.offset_bytes == 0 ?
6560                 (verify ? ciphertext_pad_len : plaintext_pad_len)
6561                         : tdata->digest.offset_bytes),
6562                 tdata->validCipherLenInBits.len,
6563                 tdata->validCipherOffsetInBits.len,
6564                 tdata->validAuthLenInBits.len,
6565                 0,
6566                 op_mode, 1, verify);
6567
6568         if (retval < 0)
6569                 return retval;
6570
6571         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6572                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6573                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
6574         else
6575                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6576                         ut_params->op);
6577
6578         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6579
6580         ut_params->obuf = (op_mode == IN_PLACE ?
6581                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6582
6583         if (verify) {
6584                 if (ut_params->obuf)
6585                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
6586                                         plaintext_len, buffer);
6587                 else
6588                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6589                                         plaintext_len, buffer);
6590
6591                 debug_hexdump(stdout, "plaintext:", plaintext,
6592                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6593                 debug_hexdump(stdout, "plaintext expected:",
6594                         tdata->plaintext.data,
6595                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6596         } else {
6597                 if (ut_params->obuf)
6598                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
6599                                         ciphertext_len, buffer);
6600                 else
6601                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6602                                         ciphertext_len, buffer);
6603
6604                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6605                         ciphertext_len);
6606                 debug_hexdump(stdout, "ciphertext expected:",
6607                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
6608
6609                 if (ut_params->obuf)
6610                         digest = rte_pktmbuf_read(ut_params->obuf,
6611                                 (tdata->digest.offset_bytes == 0 ?
6612                                 plaintext_pad_len : tdata->digest.offset_bytes),
6613                                 tdata->digest.len, digest_buffer);
6614                 else
6615                         digest = rte_pktmbuf_read(ut_params->ibuf,
6616                                 (tdata->digest.offset_bytes == 0 ?
6617                                 plaintext_pad_len : tdata->digest.offset_bytes),
6618                                 tdata->digest.len, digest_buffer);
6619
6620                 debug_hexdump(stdout, "digest:", digest,
6621                         tdata->digest.len);
6622                 debug_hexdump(stdout, "digest expected:",
6623                         tdata->digest.data, tdata->digest.len);
6624         }
6625
6626         /* Validate obuf */
6627         if (verify) {
6628                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6629                         plaintext,
6630                         tdata->plaintext.data,
6631                         tdata->plaintext.len >> 3,
6632                         "ZUC Plaintext data not as expected");
6633         } else {
6634                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6635                         ciphertext,
6636                         tdata->ciphertext.data,
6637                         tdata->validDataLenInBits.len,
6638                         "ZUC Ciphertext data not as expected");
6639
6640                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6641                         digest,
6642                         tdata->digest.data,
6643                         DIGEST_BYTE_LENGTH_KASUMI_F9,
6644                         "ZUC Generated auth tag not as expected");
6645         }
6646         return 0;
6647 }
6648
6649 static int
6650 test_kasumi_encryption_test_case_1(void)
6651 {
6652         return test_kasumi_encryption(&kasumi_test_case_1);
6653 }
6654
6655 static int
6656 test_kasumi_encryption_test_case_1_sgl(void)
6657 {
6658         return test_kasumi_encryption_sgl(&kasumi_test_case_1);
6659 }
6660
6661 static int
6662 test_kasumi_encryption_test_case_1_oop(void)
6663 {
6664         return test_kasumi_encryption_oop(&kasumi_test_case_1);
6665 }
6666
6667 static int
6668 test_kasumi_encryption_test_case_1_oop_sgl(void)
6669 {
6670         return test_kasumi_encryption_oop_sgl(&kasumi_test_case_1);
6671 }
6672
6673 static int
6674 test_kasumi_encryption_test_case_2(void)
6675 {
6676         return test_kasumi_encryption(&kasumi_test_case_2);
6677 }
6678
6679 static int
6680 test_kasumi_encryption_test_case_3(void)
6681 {
6682         return test_kasumi_encryption(&kasumi_test_case_3);
6683 }
6684
6685 static int
6686 test_kasumi_encryption_test_case_4(void)
6687 {
6688         return test_kasumi_encryption(&kasumi_test_case_4);
6689 }
6690
6691 static int
6692 test_kasumi_encryption_test_case_5(void)
6693 {
6694         return test_kasumi_encryption(&kasumi_test_case_5);
6695 }
6696
6697 static int
6698 test_kasumi_decryption_test_case_1(void)
6699 {
6700         return test_kasumi_decryption(&kasumi_test_case_1);
6701 }
6702
6703 static int
6704 test_kasumi_decryption_test_case_1_oop(void)
6705 {
6706         return test_kasumi_decryption_oop(&kasumi_test_case_1);
6707 }
6708
6709 static int
6710 test_kasumi_decryption_test_case_2(void)
6711 {
6712         return test_kasumi_decryption(&kasumi_test_case_2);
6713 }
6714
6715 static int
6716 test_kasumi_decryption_test_case_3(void)
6717 {
6718         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6719         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6720                 return TEST_SKIPPED;
6721         return test_kasumi_decryption(&kasumi_test_case_3);
6722 }
6723
6724 static int
6725 test_kasumi_decryption_test_case_4(void)
6726 {
6727         return test_kasumi_decryption(&kasumi_test_case_4);
6728 }
6729
6730 static int
6731 test_kasumi_decryption_test_case_5(void)
6732 {
6733         return test_kasumi_decryption(&kasumi_test_case_5);
6734 }
6735 static int
6736 test_snow3g_encryption_test_case_1(void)
6737 {
6738         return test_snow3g_encryption(&snow3g_test_case_1);
6739 }
6740
6741 static int
6742 test_snow3g_encryption_test_case_1_oop(void)
6743 {
6744         return test_snow3g_encryption_oop(&snow3g_test_case_1);
6745 }
6746
6747 static int
6748 test_snow3g_encryption_test_case_1_oop_sgl(void)
6749 {
6750         return test_snow3g_encryption_oop_sgl(&snow3g_test_case_1);
6751 }
6752
6753
6754 static int
6755 test_snow3g_encryption_test_case_1_offset_oop(void)
6756 {
6757         return test_snow3g_encryption_offset_oop(&snow3g_test_case_1);
6758 }
6759
6760 static int
6761 test_snow3g_encryption_test_case_2(void)
6762 {
6763         return test_snow3g_encryption(&snow3g_test_case_2);
6764 }
6765
6766 static int
6767 test_snow3g_encryption_test_case_3(void)
6768 {
6769         return test_snow3g_encryption(&snow3g_test_case_3);
6770 }
6771
6772 static int
6773 test_snow3g_encryption_test_case_4(void)
6774 {
6775         return test_snow3g_encryption(&snow3g_test_case_4);
6776 }
6777
6778 static int
6779 test_snow3g_encryption_test_case_5(void)
6780 {
6781         return test_snow3g_encryption(&snow3g_test_case_5);
6782 }
6783
6784 static int
6785 test_snow3g_decryption_test_case_1(void)
6786 {
6787         return test_snow3g_decryption(&snow3g_test_case_1);
6788 }
6789
6790 static int
6791 test_snow3g_decryption_test_case_1_oop(void)
6792 {
6793         return test_snow3g_decryption_oop(&snow3g_test_case_1);
6794 }
6795
6796 static int
6797 test_snow3g_decryption_test_case_2(void)
6798 {
6799         return test_snow3g_decryption(&snow3g_test_case_2);
6800 }
6801
6802 static int
6803 test_snow3g_decryption_test_case_3(void)
6804 {
6805         return test_snow3g_decryption(&snow3g_test_case_3);
6806 }
6807
6808 static int
6809 test_snow3g_decryption_test_case_4(void)
6810 {
6811         return test_snow3g_decryption(&snow3g_test_case_4);
6812 }
6813
6814 static int
6815 test_snow3g_decryption_test_case_5(void)
6816 {
6817         return test_snow3g_decryption(&snow3g_test_case_5);
6818 }
6819
6820 /*
6821  * Function prepares snow3g_hash_test_data from snow3g_test_data.
6822  * Pattern digest from snow3g_test_data must be allocated as
6823  * 4 last bytes in plaintext.
6824  */
6825 static void
6826 snow3g_hash_test_vector_setup(const struct snow3g_test_data *pattern,
6827                 struct snow3g_hash_test_data *output)
6828 {
6829         if ((pattern != NULL) && (output != NULL)) {
6830                 output->key.len = pattern->key.len;
6831
6832                 memcpy(output->key.data,
6833                 pattern->key.data, pattern->key.len);
6834
6835                 output->auth_iv.len = pattern->auth_iv.len;
6836
6837                 memcpy(output->auth_iv.data,
6838                 pattern->auth_iv.data, pattern->auth_iv.len);
6839
6840                 output->plaintext.len = pattern->plaintext.len;
6841
6842                 memcpy(output->plaintext.data,
6843                 pattern->plaintext.data, pattern->plaintext.len >> 3);
6844
6845                 output->digest.len = pattern->digest.len;
6846
6847                 memcpy(output->digest.data,
6848                 &pattern->plaintext.data[pattern->digest.offset_bytes],
6849                 pattern->digest.len);
6850
6851                 output->validAuthLenInBits.len =
6852                 pattern->validAuthLenInBits.len;
6853         }
6854 }
6855
6856 /*
6857  * Test case verify computed cipher and digest from snow3g_test_case_7 data.
6858  */
6859 static int
6860 test_snow3g_decryption_with_digest_test_case_1(void)
6861 {
6862         struct snow3g_hash_test_data snow3g_hash_data;
6863         struct rte_cryptodev_info dev_info;
6864         struct crypto_testsuite_params *ts_params = &testsuite_params;
6865
6866         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6867         uint64_t feat_flags = dev_info.feature_flags;
6868
6869         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6870                 printf("Device doesn't support encrypted digest operations.\n");
6871                 return TEST_SKIPPED;
6872         }
6873
6874         /*
6875          * Function prepare data for hash verification test case.
6876          * Digest is allocated in 4 last bytes in plaintext, pattern.
6877          */
6878         snow3g_hash_test_vector_setup(&snow3g_test_case_7, &snow3g_hash_data);
6879
6880         return test_snow3g_decryption(&snow3g_test_case_7) &
6881                         test_snow3g_authentication_verify(&snow3g_hash_data);
6882 }
6883
6884 static int
6885 test_snow3g_cipher_auth_test_case_1(void)
6886 {
6887         return test_snow3g_cipher_auth(&snow3g_test_case_3);
6888 }
6889
6890 static int
6891 test_snow3g_auth_cipher_test_case_1(void)
6892 {
6893         return test_snow3g_auth_cipher(
6894                 &snow3g_auth_cipher_test_case_1, IN_PLACE, 0);
6895 }
6896
6897 static int
6898 test_snow3g_auth_cipher_test_case_2(void)
6899 {
6900         return test_snow3g_auth_cipher(
6901                 &snow3g_auth_cipher_test_case_2, IN_PLACE, 0);
6902 }
6903
6904 static int
6905 test_snow3g_auth_cipher_test_case_2_oop(void)
6906 {
6907         return test_snow3g_auth_cipher(
6908                 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
6909 }
6910
6911 static int
6912 test_snow3g_auth_cipher_part_digest_enc(void)
6913 {
6914         return test_snow3g_auth_cipher(
6915                 &snow3g_auth_cipher_partial_digest_encryption,
6916                         IN_PLACE, 0);
6917 }
6918
6919 static int
6920 test_snow3g_auth_cipher_part_digest_enc_oop(void)
6921 {
6922         return test_snow3g_auth_cipher(
6923                 &snow3g_auth_cipher_partial_digest_encryption,
6924                         OUT_OF_PLACE, 0);
6925 }
6926
6927 static int
6928 test_snow3g_auth_cipher_test_case_3_sgl(void)
6929 {
6930         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6931         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6932                 return TEST_SKIPPED;
6933         return test_snow3g_auth_cipher_sgl(
6934                 &snow3g_auth_cipher_test_case_3, IN_PLACE, 0);
6935 }
6936
6937 static int
6938 test_snow3g_auth_cipher_test_case_3_oop_sgl(void)
6939 {
6940         return test_snow3g_auth_cipher_sgl(
6941                 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 0);
6942 }
6943
6944 static int
6945 test_snow3g_auth_cipher_part_digest_enc_sgl(void)
6946 {
6947         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6948         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6949                 return TEST_SKIPPED;
6950         return test_snow3g_auth_cipher_sgl(
6951                 &snow3g_auth_cipher_partial_digest_encryption,
6952                         IN_PLACE, 0);
6953 }
6954
6955 static int
6956 test_snow3g_auth_cipher_part_digest_enc_oop_sgl(void)
6957 {
6958         return test_snow3g_auth_cipher_sgl(
6959                 &snow3g_auth_cipher_partial_digest_encryption,
6960                         OUT_OF_PLACE, 0);
6961 }
6962
6963 static int
6964 test_snow3g_auth_cipher_verify_test_case_1(void)
6965 {
6966         return test_snow3g_auth_cipher(
6967                 &snow3g_auth_cipher_test_case_1, IN_PLACE, 1);
6968 }
6969
6970 static int
6971 test_snow3g_auth_cipher_verify_test_case_2(void)
6972 {
6973         return test_snow3g_auth_cipher(
6974                 &snow3g_auth_cipher_test_case_2, IN_PLACE, 1);
6975 }
6976
6977 static int
6978 test_snow3g_auth_cipher_verify_test_case_2_oop(void)
6979 {
6980         return test_snow3g_auth_cipher(
6981                 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
6982 }
6983
6984 static int
6985 test_snow3g_auth_cipher_verify_part_digest_enc(void)
6986 {
6987         return test_snow3g_auth_cipher(
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(void)
6994 {
6995         return test_snow3g_auth_cipher(
6996                 &snow3g_auth_cipher_partial_digest_encryption,
6997                         OUT_OF_PLACE, 1);
6998 }
6999
7000 static int
7001 test_snow3g_auth_cipher_verify_test_case_3_sgl(void)
7002 {
7003         return test_snow3g_auth_cipher_sgl(
7004                 &snow3g_auth_cipher_test_case_3, IN_PLACE, 1);
7005 }
7006
7007 static int
7008 test_snow3g_auth_cipher_verify_test_case_3_oop_sgl(void)
7009 {
7010         return test_snow3g_auth_cipher_sgl(
7011                 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 1);
7012 }
7013
7014 static int
7015 test_snow3g_auth_cipher_verify_part_digest_enc_sgl(void)
7016 {
7017         return test_snow3g_auth_cipher_sgl(
7018                 &snow3g_auth_cipher_partial_digest_encryption,
7019                         IN_PLACE, 1);
7020 }
7021
7022 static int
7023 test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl(void)
7024 {
7025         return test_snow3g_auth_cipher_sgl(
7026                 &snow3g_auth_cipher_partial_digest_encryption,
7027                         OUT_OF_PLACE, 1);
7028 }
7029
7030 static int
7031 test_snow3g_auth_cipher_with_digest_test_case_1(void)
7032 {
7033         return test_snow3g_auth_cipher(
7034                 &snow3g_test_case_7, IN_PLACE, 0);
7035 }
7036
7037 static int
7038 test_kasumi_auth_cipher_test_case_1(void)
7039 {
7040         return test_kasumi_auth_cipher(
7041                 &kasumi_test_case_3, IN_PLACE, 0);
7042 }
7043
7044 static int
7045 test_kasumi_auth_cipher_test_case_2(void)
7046 {
7047         return test_kasumi_auth_cipher(
7048                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
7049 }
7050
7051 static int
7052 test_kasumi_auth_cipher_test_case_2_oop(void)
7053 {
7054         return test_kasumi_auth_cipher(
7055                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
7056 }
7057
7058 static int
7059 test_kasumi_auth_cipher_test_case_2_sgl(void)
7060 {
7061         return test_kasumi_auth_cipher_sgl(
7062                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
7063 }
7064
7065 static int
7066 test_kasumi_auth_cipher_test_case_2_oop_sgl(void)
7067 {
7068         return test_kasumi_auth_cipher_sgl(
7069                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
7070 }
7071
7072 static int
7073 test_kasumi_auth_cipher_verify_test_case_1(void)
7074 {
7075         return test_kasumi_auth_cipher(
7076                 &kasumi_test_case_3, IN_PLACE, 1);
7077 }
7078
7079 static int
7080 test_kasumi_auth_cipher_verify_test_case_2(void)
7081 {
7082         return test_kasumi_auth_cipher(
7083                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
7084 }
7085
7086 static int
7087 test_kasumi_auth_cipher_verify_test_case_2_oop(void)
7088 {
7089         return test_kasumi_auth_cipher(
7090                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
7091 }
7092
7093 static int
7094 test_kasumi_auth_cipher_verify_test_case_2_sgl(void)
7095 {
7096         return test_kasumi_auth_cipher_sgl(
7097                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
7098 }
7099
7100 static int
7101 test_kasumi_auth_cipher_verify_test_case_2_oop_sgl(void)
7102 {
7103         return test_kasumi_auth_cipher_sgl(
7104                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
7105 }
7106
7107 static int
7108 test_kasumi_cipher_auth_test_case_1(void)
7109 {
7110         return test_kasumi_cipher_auth(&kasumi_test_case_6);
7111 }
7112
7113 static int
7114 test_zuc_encryption_test_case_1(void)
7115 {
7116         return test_zuc_encryption(&zuc_test_case_cipher_193b);
7117 }
7118
7119 static int
7120 test_zuc_encryption_test_case_2(void)
7121 {
7122         return test_zuc_encryption(&zuc_test_case_cipher_800b);
7123 }
7124
7125 static int
7126 test_zuc_encryption_test_case_3(void)
7127 {
7128         return test_zuc_encryption(&zuc_test_case_cipher_1570b);
7129 }
7130
7131 static int
7132 test_zuc_encryption_test_case_4(void)
7133 {
7134         return test_zuc_encryption(&zuc_test_case_cipher_2798b);
7135 }
7136
7137 static int
7138 test_zuc_encryption_test_case_5(void)
7139 {
7140         return test_zuc_encryption(&zuc_test_case_cipher_4019b);
7141 }
7142
7143 static int
7144 test_zuc_encryption_test_case_6_sgl(void)
7145 {
7146         return test_zuc_encryption_sgl(&zuc_test_case_cipher_193b);
7147 }
7148
7149 static int
7150 test_zuc_hash_generate_test_case_1(void)
7151 {
7152         return test_zuc_authentication(&zuc_test_case_auth_1b);
7153 }
7154
7155 static int
7156 test_zuc_hash_generate_test_case_2(void)
7157 {
7158         return test_zuc_authentication(&zuc_test_case_auth_90b);
7159 }
7160
7161 static int
7162 test_zuc_hash_generate_test_case_3(void)
7163 {
7164         return test_zuc_authentication(&zuc_test_case_auth_577b);
7165 }
7166
7167 static int
7168 test_zuc_hash_generate_test_case_4(void)
7169 {
7170         return test_zuc_authentication(&zuc_test_case_auth_2079b);
7171 }
7172
7173 static int
7174 test_zuc_hash_generate_test_case_5(void)
7175 {
7176         return test_zuc_authentication(&zuc_test_auth_5670b);
7177 }
7178
7179 static int
7180 test_zuc_hash_generate_test_case_6(void)
7181 {
7182         return test_zuc_authentication(&zuc_test_case_auth_128b);
7183 }
7184
7185 static int
7186 test_zuc_hash_generate_test_case_7(void)
7187 {
7188         return test_zuc_authentication(&zuc_test_case_auth_2080b);
7189 }
7190
7191 static int
7192 test_zuc_hash_generate_test_case_8(void)
7193 {
7194         return test_zuc_authentication(&zuc_test_case_auth_584b);
7195 }
7196
7197 static int
7198 test_zuc_hash_generate_test_case_9(void)
7199 {
7200         return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_32b);
7201 }
7202
7203 static int
7204 test_zuc_hash_generate_test_case_10(void)
7205 {
7206         return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_64b);
7207 }
7208
7209 static int
7210 test_zuc_hash_generate_test_case_11(void)
7211 {
7212         return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_128b);
7213 }
7214
7215 static int
7216 test_zuc_cipher_auth_test_case_1(void)
7217 {
7218         return test_zuc_cipher_auth(&zuc_test_case_cipher_200b_auth_200b);
7219 }
7220
7221 static int
7222 test_zuc_cipher_auth_test_case_2(void)
7223 {
7224         return test_zuc_cipher_auth(&zuc_test_case_cipher_800b_auth_120b);
7225 }
7226
7227 static int
7228 test_zuc_auth_cipher_test_case_1(void)
7229 {
7230         return test_zuc_auth_cipher(
7231                 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
7232 }
7233
7234 static int
7235 test_zuc_auth_cipher_test_case_1_oop(void)
7236 {
7237         return test_zuc_auth_cipher(
7238                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
7239 }
7240
7241 static int
7242 test_zuc_auth_cipher_test_case_1_sgl(void)
7243 {
7244         return test_zuc_auth_cipher_sgl(
7245                 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
7246 }
7247
7248 static int
7249 test_zuc_auth_cipher_test_case_1_oop_sgl(void)
7250 {
7251         return test_zuc_auth_cipher_sgl(
7252                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
7253 }
7254
7255 static int
7256 test_zuc_auth_cipher_verify_test_case_1(void)
7257 {
7258         return test_zuc_auth_cipher(
7259                 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
7260 }
7261
7262 static int
7263 test_zuc_auth_cipher_verify_test_case_1_oop(void)
7264 {
7265         return test_zuc_auth_cipher(
7266                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
7267 }
7268
7269 static int
7270 test_zuc_auth_cipher_verify_test_case_1_sgl(void)
7271 {
7272         return test_zuc_auth_cipher_sgl(
7273                 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
7274 }
7275
7276 static int
7277 test_zuc_auth_cipher_verify_test_case_1_oop_sgl(void)
7278 {
7279         return test_zuc_auth_cipher_sgl(
7280                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
7281 }
7282
7283 static int
7284 test_zuc256_encryption_test_case_1(void)
7285 {
7286         return test_zuc_encryption(&zuc256_test_case_cipher_1);
7287 }
7288
7289 static int
7290 test_zuc256_encryption_test_case_2(void)
7291 {
7292         return test_zuc_encryption(&zuc256_test_case_cipher_2);
7293 }
7294
7295 static int
7296 test_zuc256_authentication_test_case_1(void)
7297 {
7298         return test_zuc_authentication(&zuc256_test_case_auth_1);
7299 }
7300
7301 static int
7302 test_zuc256_authentication_test_case_2(void)
7303 {
7304         return test_zuc_authentication(&zuc256_test_case_auth_2);
7305 }
7306
7307 static int
7308 test_mixed_check_if_unsupported(const struct mixed_cipher_auth_test_data *tdata)
7309 {
7310         uint8_t dev_id = testsuite_params.valid_devs[0];
7311
7312         struct rte_cryptodev_sym_capability_idx cap_idx;
7313
7314         /* Check if device supports particular cipher algorithm */
7315         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
7316         cap_idx.algo.cipher = tdata->cipher_algo;
7317         if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
7318                 return TEST_SKIPPED;
7319
7320         /* Check if device supports particular hash algorithm */
7321         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
7322         cap_idx.algo.auth = tdata->auth_algo;
7323         if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
7324                 return TEST_SKIPPED;
7325
7326         return 0;
7327 }
7328
7329 static int
7330 test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata,
7331         uint8_t op_mode, uint8_t verify)
7332 {
7333         struct crypto_testsuite_params *ts_params = &testsuite_params;
7334         struct crypto_unittest_params *ut_params = &unittest_params;
7335
7336         int retval;
7337
7338         uint8_t *plaintext = NULL, *ciphertext = NULL;
7339         unsigned int plaintext_pad_len;
7340         unsigned int plaintext_len;
7341         unsigned int ciphertext_pad_len;
7342         unsigned int ciphertext_len;
7343
7344         struct rte_cryptodev_info dev_info;
7345         struct rte_crypto_op *op;
7346
7347         /* Check if device supports particular algorithms separately */
7348         if (test_mixed_check_if_unsupported(tdata))
7349                 return TEST_SKIPPED;
7350         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
7351                 return TEST_SKIPPED;
7352
7353         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
7354
7355         uint64_t feat_flags = dev_info.feature_flags;
7356
7357         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
7358                 printf("Device doesn't support digest encrypted.\n");
7359                 return TEST_SKIPPED;
7360         }
7361
7362         /* Create the session */
7363         if (verify)
7364                 retval = create_wireless_algo_cipher_auth_session(
7365                                 ts_params->valid_devs[0],
7366                                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
7367                                 RTE_CRYPTO_AUTH_OP_VERIFY,
7368                                 tdata->auth_algo,
7369                                 tdata->cipher_algo,
7370                                 tdata->auth_key.data, tdata->auth_key.len,
7371                                 tdata->auth_iv.len, tdata->digest_enc.len,
7372                                 tdata->cipher_iv.len);
7373         else
7374                 retval = create_wireless_algo_auth_cipher_session(
7375                                 ts_params->valid_devs[0],
7376                                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7377                                 RTE_CRYPTO_AUTH_OP_GENERATE,
7378                                 tdata->auth_algo,
7379                                 tdata->cipher_algo,
7380                                 tdata->auth_key.data, tdata->auth_key.len,
7381                                 tdata->auth_iv.len, tdata->digest_enc.len,
7382                                 tdata->cipher_iv.len);
7383         if (retval != 0)
7384                 return retval;
7385
7386         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7387         if (op_mode == OUT_OF_PLACE)
7388                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7389
7390         /* clear mbuf payload */
7391         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7392                 rte_pktmbuf_tailroom(ut_params->ibuf));
7393         if (op_mode == OUT_OF_PLACE) {
7394
7395                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
7396                                 rte_pktmbuf_tailroom(ut_params->obuf));
7397         }
7398
7399         ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
7400         plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
7401         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
7402         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
7403
7404         if (verify) {
7405                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7406                                 ciphertext_pad_len);
7407                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
7408                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7409                                 ciphertext_len);
7410         } else {
7411                 /* make sure enough space to cover partial digest verify case */
7412                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7413                                 ciphertext_pad_len);
7414                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
7415                 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
7416         }
7417
7418         if (op_mode == OUT_OF_PLACE)
7419                 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
7420
7421         /* Create the operation */
7422         retval = create_wireless_algo_auth_cipher_operation(
7423                         tdata->digest_enc.data, tdata->digest_enc.len,
7424                         tdata->cipher_iv.data, tdata->cipher_iv.len,
7425                         tdata->auth_iv.data, tdata->auth_iv.len,
7426                         (tdata->digest_enc.offset == 0 ?
7427                                 plaintext_pad_len
7428                                 : tdata->digest_enc.offset),
7429                         tdata->validCipherLen.len_bits,
7430                         tdata->cipher.offset_bits,
7431                         tdata->validAuthLen.len_bits,
7432                         tdata->auth.offset_bits,
7433                         op_mode, 0, verify);
7434
7435         if (retval < 0)
7436                 return retval;
7437
7438         op = process_crypto_request(ts_params->valid_devs[0], ut_params->op);
7439
7440         /* Check if the op failed because the device doesn't */
7441         /* support this particular combination of algorithms */
7442         if (op == NULL && ut_params->op->status ==
7443                         RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
7444                 printf("Device doesn't support this mixed combination. "
7445                                 "Test Skipped.\n");
7446                 return TEST_SKIPPED;
7447         }
7448         ut_params->op = op;
7449
7450         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
7451
7452         ut_params->obuf = (op_mode == IN_PLACE ?
7453                         ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
7454
7455         if (verify) {
7456                 if (ut_params->obuf)
7457                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
7458                                                         uint8_t *);
7459                 else
7460                         plaintext = ciphertext +
7461                                         (tdata->cipher.offset_bits >> 3);
7462
7463                 debug_hexdump(stdout, "plaintext:", plaintext,
7464                                 tdata->plaintext.len_bits >> 3);
7465                 debug_hexdump(stdout, "plaintext expected:",
7466                                 tdata->plaintext.data,
7467                                 tdata->plaintext.len_bits >> 3);
7468         } else {
7469                 if (ut_params->obuf)
7470                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
7471                                         uint8_t *);
7472                 else
7473                         ciphertext = plaintext;
7474
7475                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7476                                 ciphertext_len);
7477                 debug_hexdump(stdout, "ciphertext expected:",
7478                                 tdata->ciphertext.data,
7479                                 tdata->ciphertext.len_bits >> 3);
7480
7481                 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
7482                                 + (tdata->digest_enc.offset == 0 ?
7483                 plaintext_pad_len : tdata->digest_enc.offset);
7484
7485                 debug_hexdump(stdout, "digest:", ut_params->digest,
7486                                 tdata->digest_enc.len);
7487                 debug_hexdump(stdout, "digest expected:",
7488                                 tdata->digest_enc.data,
7489                                 tdata->digest_enc.len);
7490         }
7491
7492         if (!verify) {
7493                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7494                                 ut_params->digest,
7495                                 tdata->digest_enc.data,
7496                                 tdata->digest_enc.len,
7497                                 "Generated auth tag not as expected");
7498         }
7499
7500         if (tdata->cipher_algo != RTE_CRYPTO_CIPHER_NULL) {
7501                 if (verify) {
7502                         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7503                                         plaintext,
7504                                         tdata->plaintext.data,
7505                                         tdata->plaintext.len_bits >> 3,
7506                                         "Plaintext data not as expected");
7507                 } else {
7508                         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7509                                         ciphertext,
7510                                         tdata->ciphertext.data,
7511                                         tdata->validDataLen.len_bits,
7512                                         "Ciphertext data not as expected");
7513                 }
7514         }
7515
7516         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7517                         "crypto op processing failed");
7518
7519         return 0;
7520 }
7521
7522 static int
7523 test_mixed_auth_cipher_sgl(const struct mixed_cipher_auth_test_data *tdata,
7524         uint8_t op_mode, uint8_t verify)
7525 {
7526         struct crypto_testsuite_params *ts_params = &testsuite_params;
7527         struct crypto_unittest_params *ut_params = &unittest_params;
7528
7529         int retval;
7530
7531         const uint8_t *plaintext = NULL;
7532         const uint8_t *ciphertext = NULL;
7533         const uint8_t *digest = NULL;
7534         unsigned int plaintext_pad_len;
7535         unsigned int plaintext_len;
7536         unsigned int ciphertext_pad_len;
7537         unsigned int ciphertext_len;
7538         uint8_t buffer[10000];
7539         uint8_t digest_buffer[10000];
7540
7541         struct rte_cryptodev_info dev_info;
7542         struct rte_crypto_op *op;
7543
7544         /* Check if device supports particular algorithms */
7545         if (test_mixed_check_if_unsupported(tdata))
7546                 return TEST_SKIPPED;
7547         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
7548                 return TEST_SKIPPED;
7549
7550         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
7551
7552         uint64_t feat_flags = dev_info.feature_flags;
7553
7554         if (op_mode == IN_PLACE) {
7555                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
7556                         printf("Device doesn't support in-place scatter-gather "
7557                                         "in both input and output mbufs.\n");
7558                         return TEST_SKIPPED;
7559                 }
7560         } else {
7561                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
7562                         printf("Device doesn't support out-of-place scatter-gather "
7563                                         "in both input and output mbufs.\n");
7564                         return TEST_SKIPPED;
7565                 }
7566                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
7567                         printf("Device doesn't support digest encrypted.\n");
7568                         return TEST_SKIPPED;
7569                 }
7570         }
7571
7572         /* Create the session */
7573         if (verify)
7574                 retval = create_wireless_algo_cipher_auth_session(
7575                                 ts_params->valid_devs[0],
7576                                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
7577                                 RTE_CRYPTO_AUTH_OP_VERIFY,
7578                                 tdata->auth_algo,
7579                                 tdata->cipher_algo,
7580                                 tdata->auth_key.data, tdata->auth_key.len,
7581                                 tdata->auth_iv.len, tdata->digest_enc.len,
7582                                 tdata->cipher_iv.len);
7583         else
7584                 retval = create_wireless_algo_auth_cipher_session(
7585                                 ts_params->valid_devs[0],
7586                                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7587                                 RTE_CRYPTO_AUTH_OP_GENERATE,
7588                                 tdata->auth_algo,
7589                                 tdata->cipher_algo,
7590                                 tdata->auth_key.data, tdata->auth_key.len,
7591                                 tdata->auth_iv.len, tdata->digest_enc.len,
7592                                 tdata->cipher_iv.len);
7593         if (retval != 0)
7594                 return retval;
7595
7596         ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
7597         plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
7598         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
7599         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
7600
7601         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
7602                         ciphertext_pad_len, 15, 0);
7603         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
7604                         "Failed to allocate input buffer in mempool");
7605
7606         if (op_mode == OUT_OF_PLACE) {
7607                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
7608                                 plaintext_pad_len, 15, 0);
7609                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
7610                                 "Failed to allocate output buffer in mempool");
7611         }
7612
7613         if (verify) {
7614                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
7615                         tdata->ciphertext.data);
7616                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
7617                                         ciphertext_len, buffer);
7618                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7619                         ciphertext_len);
7620         } else {
7621                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
7622                         tdata->plaintext.data);
7623                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
7624                                         plaintext_len, buffer);
7625                 debug_hexdump(stdout, "plaintext:", plaintext,
7626                         plaintext_len);
7627         }
7628         memset(buffer, 0, sizeof(buffer));
7629
7630         /* Create the operation */
7631         retval = create_wireless_algo_auth_cipher_operation(
7632                         tdata->digest_enc.data, tdata->digest_enc.len,
7633                         tdata->cipher_iv.data, tdata->cipher_iv.len,
7634                         tdata->auth_iv.data, tdata->auth_iv.len,
7635                         (tdata->digest_enc.offset == 0 ?
7636                                 plaintext_pad_len
7637                                 : tdata->digest_enc.offset),
7638                         tdata->validCipherLen.len_bits,
7639                         tdata->cipher.offset_bits,
7640                         tdata->validAuthLen.len_bits,
7641                         tdata->auth.offset_bits,
7642                         op_mode, 1, verify);
7643
7644         if (retval < 0)
7645                 return retval;
7646
7647         op = process_crypto_request(ts_params->valid_devs[0], ut_params->op);
7648
7649         /* Check if the op failed because the device doesn't */
7650         /* support this particular combination of algorithms */
7651         if (op == NULL && ut_params->op->status ==
7652                         RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
7653                 printf("Device doesn't support this mixed combination. "
7654                                 "Test Skipped.\n");
7655                 return TEST_SKIPPED;
7656         }
7657         ut_params->op = op;
7658
7659         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
7660
7661         ut_params->obuf = (op_mode == IN_PLACE ?
7662                         ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
7663
7664         if (verify) {
7665                 if (ut_params->obuf)
7666                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
7667                                         plaintext_len, buffer);
7668                 else
7669                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
7670                                         plaintext_len, buffer);
7671
7672                 debug_hexdump(stdout, "plaintext:", plaintext,
7673                                 (tdata->plaintext.len_bits >> 3) -
7674                                 tdata->digest_enc.len);
7675                 debug_hexdump(stdout, "plaintext expected:",
7676                                 tdata->plaintext.data,
7677                                 (tdata->plaintext.len_bits >> 3) -
7678                                 tdata->digest_enc.len);
7679         } else {
7680                 if (ut_params->obuf)
7681                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
7682                                         ciphertext_len, buffer);
7683                 else
7684                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
7685                                         ciphertext_len, buffer);
7686
7687                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7688                         ciphertext_len);
7689                 debug_hexdump(stdout, "ciphertext expected:",
7690                         tdata->ciphertext.data,
7691                         tdata->ciphertext.len_bits >> 3);
7692
7693                 if (ut_params->obuf)
7694                         digest = rte_pktmbuf_read(ut_params->obuf,
7695                                         (tdata->digest_enc.offset == 0 ?
7696                                                 plaintext_pad_len :
7697                                                 tdata->digest_enc.offset),
7698                                         tdata->digest_enc.len, digest_buffer);
7699                 else
7700                         digest = rte_pktmbuf_read(ut_params->ibuf,
7701                                         (tdata->digest_enc.offset == 0 ?
7702                                                 plaintext_pad_len :
7703                                                 tdata->digest_enc.offset),
7704                                         tdata->digest_enc.len, digest_buffer);
7705
7706                 debug_hexdump(stdout, "digest:", digest,
7707                                 tdata->digest_enc.len);
7708                 debug_hexdump(stdout, "digest expected:",
7709                                 tdata->digest_enc.data, tdata->digest_enc.len);
7710         }
7711
7712         if (!verify) {
7713                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7714                                 digest,
7715                                 tdata->digest_enc.data,
7716                                 tdata->digest_enc.len,
7717                                 "Generated auth tag not as expected");
7718         }
7719
7720         if (tdata->cipher_algo != RTE_CRYPTO_CIPHER_NULL) {
7721                 if (verify) {
7722                         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7723                                         plaintext,
7724                                         tdata->plaintext.data,
7725                                         tdata->plaintext.len_bits >> 3,
7726                                         "Plaintext data not as expected");
7727                 } else {
7728                         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7729                                         ciphertext,
7730                                         tdata->ciphertext.data,
7731                                         tdata->validDataLen.len_bits,
7732                                         "Ciphertext data not as expected");
7733                 }
7734         }
7735
7736         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7737                         "crypto op processing failed");
7738
7739         return 0;
7740 }
7741
7742 /** AUTH AES CMAC + CIPHER AES CTR */
7743
7744 static int
7745 test_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7746 {
7747         return test_mixed_auth_cipher(
7748                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7749 }
7750
7751 static int
7752 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7753 {
7754         return test_mixed_auth_cipher(
7755                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7756 }
7757
7758 static int
7759 test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7760 {
7761         return test_mixed_auth_cipher_sgl(
7762                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7763 }
7764
7765 static int
7766 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7767 {
7768         return test_mixed_auth_cipher_sgl(
7769                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7770 }
7771
7772 static int
7773 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7774 {
7775         return test_mixed_auth_cipher(
7776                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7777 }
7778
7779 static int
7780 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7781 {
7782         return test_mixed_auth_cipher(
7783                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7784 }
7785
7786 static int
7787 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7788 {
7789         return test_mixed_auth_cipher_sgl(
7790                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7791 }
7792
7793 static int
7794 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7795 {
7796         return test_mixed_auth_cipher_sgl(
7797                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7798 }
7799
7800 /** MIXED AUTH + CIPHER */
7801
7802 static int
7803 test_auth_zuc_cipher_snow_test_case_1(void)
7804 {
7805         return test_mixed_auth_cipher(
7806                 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7807 }
7808
7809 static int
7810 test_verify_auth_zuc_cipher_snow_test_case_1(void)
7811 {
7812         return test_mixed_auth_cipher(
7813                 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7814 }
7815
7816 static int
7817 test_auth_aes_cmac_cipher_snow_test_case_1(void)
7818 {
7819         return test_mixed_auth_cipher(
7820                 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7821 }
7822
7823 static int
7824 test_verify_auth_aes_cmac_cipher_snow_test_case_1(void)
7825 {
7826         return test_mixed_auth_cipher(
7827                 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7828 }
7829
7830 static int
7831 test_auth_zuc_cipher_aes_ctr_test_case_1(void)
7832 {
7833         return test_mixed_auth_cipher(
7834                 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7835 }
7836
7837 static int
7838 test_verify_auth_zuc_cipher_aes_ctr_test_case_1(void)
7839 {
7840         return test_mixed_auth_cipher(
7841                 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7842 }
7843
7844 static int
7845 test_auth_snow_cipher_aes_ctr_test_case_1(void)
7846 {
7847         return test_mixed_auth_cipher(
7848                 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7849 }
7850
7851 static int
7852 test_verify_auth_snow_cipher_aes_ctr_test_case_1(void)
7853 {
7854         return test_mixed_auth_cipher(
7855                 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7856 }
7857
7858 static int
7859 test_auth_snow_cipher_zuc_test_case_1(void)
7860 {
7861         return test_mixed_auth_cipher(
7862                 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7863 }
7864
7865 static int
7866 test_verify_auth_snow_cipher_zuc_test_case_1(void)
7867 {
7868         return test_mixed_auth_cipher(
7869                 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7870 }
7871
7872 static int
7873 test_auth_aes_cmac_cipher_zuc_test_case_1(void)
7874 {
7875         return test_mixed_auth_cipher(
7876                 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7877 }
7878
7879 static int
7880 test_verify_auth_aes_cmac_cipher_zuc_test_case_1(void)
7881 {
7882         return test_mixed_auth_cipher(
7883                 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7884 }
7885
7886 static int
7887 test_auth_null_cipher_snow_test_case_1(void)
7888 {
7889         return test_mixed_auth_cipher(
7890                 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7891 }
7892
7893 static int
7894 test_verify_auth_null_cipher_snow_test_case_1(void)
7895 {
7896         return test_mixed_auth_cipher(
7897                 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7898 }
7899
7900 static int
7901 test_auth_null_cipher_zuc_test_case_1(void)
7902 {
7903         return test_mixed_auth_cipher(
7904                 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7905 }
7906
7907 static int
7908 test_verify_auth_null_cipher_zuc_test_case_1(void)
7909 {
7910         return test_mixed_auth_cipher(
7911                 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7912 }
7913
7914 static int
7915 test_auth_snow_cipher_null_test_case_1(void)
7916 {
7917         return test_mixed_auth_cipher(
7918                 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7919 }
7920
7921 static int
7922 test_verify_auth_snow_cipher_null_test_case_1(void)
7923 {
7924         return test_mixed_auth_cipher(
7925                 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7926 }
7927
7928 static int
7929 test_auth_zuc_cipher_null_test_case_1(void)
7930 {
7931         return test_mixed_auth_cipher(
7932                 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7933 }
7934
7935 static int
7936 test_verify_auth_zuc_cipher_null_test_case_1(void)
7937 {
7938         return test_mixed_auth_cipher(
7939                 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7940 }
7941
7942 static int
7943 test_auth_null_cipher_aes_ctr_test_case_1(void)
7944 {
7945         return test_mixed_auth_cipher(
7946                 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7947 }
7948
7949 static int
7950 test_verify_auth_null_cipher_aes_ctr_test_case_1(void)
7951 {
7952         return test_mixed_auth_cipher(
7953                 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7954 }
7955
7956 static int
7957 test_auth_aes_cmac_cipher_null_test_case_1(void)
7958 {
7959         return test_mixed_auth_cipher(
7960                 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7961 }
7962
7963 static int
7964 test_verify_auth_aes_cmac_cipher_null_test_case_1(void)
7965 {
7966         return test_mixed_auth_cipher(
7967                 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7968 }
7969
7970 /* ***** AEAD algorithm Tests ***** */
7971
7972 static int
7973 create_aead_session(uint8_t dev_id, enum rte_crypto_aead_algorithm algo,
7974                 enum rte_crypto_aead_operation op,
7975                 const uint8_t *key, const uint8_t key_len,
7976                 const uint16_t aad_len, const uint8_t auth_len,
7977                 uint8_t iv_len)
7978 {
7979         uint8_t aead_key[key_len];
7980         int status;
7981
7982         struct crypto_testsuite_params *ts_params = &testsuite_params;
7983         struct crypto_unittest_params *ut_params = &unittest_params;
7984
7985         memcpy(aead_key, key, key_len);
7986
7987         /* Setup AEAD Parameters */
7988         ut_params->aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD;
7989         ut_params->aead_xform.next = NULL;
7990         ut_params->aead_xform.aead.algo = algo;
7991         ut_params->aead_xform.aead.op = op;
7992         ut_params->aead_xform.aead.key.data = aead_key;
7993         ut_params->aead_xform.aead.key.length = key_len;
7994         ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
7995         ut_params->aead_xform.aead.iv.length = iv_len;
7996         ut_params->aead_xform.aead.digest_length = auth_len;
7997         ut_params->aead_xform.aead.aad_length = aad_len;
7998
7999         debug_hexdump(stdout, "key:", key, key_len);
8000
8001         /* Create Crypto session*/
8002         ut_params->sess = rte_cryptodev_sym_session_create(
8003                         ts_params->session_mpool);
8004         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
8005
8006         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
8007                         &ut_params->aead_xform,
8008                         ts_params->session_priv_mpool);
8009
8010         return status;
8011 }
8012
8013 static int
8014 create_aead_xform(struct rte_crypto_op *op,
8015                 enum rte_crypto_aead_algorithm algo,
8016                 enum rte_crypto_aead_operation aead_op,
8017                 uint8_t *key, const uint8_t key_len,
8018                 const uint8_t aad_len, const uint8_t auth_len,
8019                 uint8_t iv_len)
8020 {
8021         TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 1),
8022                         "failed to allocate space for crypto transform");
8023
8024         struct rte_crypto_sym_op *sym_op = op->sym;
8025
8026         /* Setup AEAD Parameters */
8027         sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_AEAD;
8028         sym_op->xform->next = NULL;
8029         sym_op->xform->aead.algo = algo;
8030         sym_op->xform->aead.op = aead_op;
8031         sym_op->xform->aead.key.data = key;
8032         sym_op->xform->aead.key.length = key_len;
8033         sym_op->xform->aead.iv.offset = IV_OFFSET;
8034         sym_op->xform->aead.iv.length = iv_len;
8035         sym_op->xform->aead.digest_length = auth_len;
8036         sym_op->xform->aead.aad_length = aad_len;
8037
8038         debug_hexdump(stdout, "key:", key, key_len);
8039
8040         return 0;
8041 }
8042
8043 static int
8044 create_aead_operation(enum rte_crypto_aead_operation op,
8045                 const struct aead_test_data *tdata)
8046 {
8047         struct crypto_testsuite_params *ts_params = &testsuite_params;
8048         struct crypto_unittest_params *ut_params = &unittest_params;
8049
8050         uint8_t *plaintext, *ciphertext;
8051         unsigned int aad_pad_len, plaintext_pad_len;
8052
8053         /* Generate Crypto op data structure */
8054         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8055                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8056         TEST_ASSERT_NOT_NULL(ut_params->op,
8057                         "Failed to allocate symmetric crypto operation struct");
8058
8059         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
8060
8061         /* Append aad data */
8062         if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
8063                 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len + 18, 16);
8064                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8065                                 aad_pad_len);
8066                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
8067                                 "no room to append aad");
8068
8069                 sym_op->aead.aad.phys_addr =
8070                                 rte_pktmbuf_iova(ut_params->ibuf);
8071                 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
8072                 memcpy(sym_op->aead.aad.data + 18, tdata->aad.data, tdata->aad.len);
8073                 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
8074                         tdata->aad.len);
8075
8076                 /* Append IV at the end of the crypto operation*/
8077                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
8078                                 uint8_t *, IV_OFFSET);
8079
8080                 /* Copy IV 1 byte after the IV pointer, according to the API */
8081                 rte_memcpy(iv_ptr + 1, tdata->iv.data, tdata->iv.len);
8082                 debug_hexdump(stdout, "iv:", iv_ptr,
8083                         tdata->iv.len);
8084         } else {
8085                 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
8086                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8087                                 aad_pad_len);
8088                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
8089                                 "no room to append aad");
8090
8091                 sym_op->aead.aad.phys_addr =
8092                                 rte_pktmbuf_iova(ut_params->ibuf);
8093                 memcpy(sym_op->aead.aad.data, tdata->aad.data, tdata->aad.len);
8094                 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
8095                         tdata->aad.len);
8096
8097                 /* Append IV at the end of the crypto operation*/
8098                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
8099                                 uint8_t *, IV_OFFSET);
8100
8101                 if (tdata->iv.len == 0) {
8102                         rte_memcpy(iv_ptr, tdata->iv.data, AES_GCM_J0_LENGTH);
8103                         debug_hexdump(stdout, "iv:", iv_ptr,
8104                                 AES_GCM_J0_LENGTH);
8105                 } else {
8106                         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
8107                         debug_hexdump(stdout, "iv:", iv_ptr,
8108                                 tdata->iv.len);
8109                 }
8110         }
8111
8112         /* Append plaintext/ciphertext */
8113         if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
8114                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
8115                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8116                                 plaintext_pad_len);
8117                 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
8118
8119                 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
8120                 debug_hexdump(stdout, "plaintext:", plaintext,
8121                                 tdata->plaintext.len);
8122
8123                 if (ut_params->obuf) {
8124                         ciphertext = (uint8_t *)rte_pktmbuf_append(
8125                                         ut_params->obuf,
8126                                         plaintext_pad_len + aad_pad_len);
8127                         TEST_ASSERT_NOT_NULL(ciphertext,
8128                                         "no room to append ciphertext");
8129
8130                         memset(ciphertext + aad_pad_len, 0,
8131                                         tdata->ciphertext.len);
8132                 }
8133         } else {
8134                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16);
8135                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8136                                 plaintext_pad_len);
8137                 TEST_ASSERT_NOT_NULL(ciphertext,
8138                                 "no room to append ciphertext");
8139
8140                 memcpy(ciphertext, tdata->ciphertext.data,
8141                                 tdata->ciphertext.len);
8142                 debug_hexdump(stdout, "ciphertext:", ciphertext,
8143                                 tdata->ciphertext.len);
8144
8145                 if (ut_params->obuf) {
8146                         plaintext = (uint8_t *)rte_pktmbuf_append(
8147                                         ut_params->obuf,
8148                                         plaintext_pad_len + aad_pad_len);
8149                         TEST_ASSERT_NOT_NULL(plaintext,
8150                                         "no room to append plaintext");
8151
8152                         memset(plaintext + aad_pad_len, 0,
8153                                         tdata->plaintext.len);
8154                 }
8155         }
8156
8157         /* Append digest data */
8158         if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
8159                 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
8160                                 ut_params->obuf ? ut_params->obuf :
8161                                                 ut_params->ibuf,
8162                                                 tdata->auth_tag.len);
8163                 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
8164                                 "no room to append digest");
8165                 memset(sym_op->aead.digest.data, 0, tdata->auth_tag.len);
8166                 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
8167                                 ut_params->obuf ? ut_params->obuf :
8168                                                 ut_params->ibuf,
8169                                                 plaintext_pad_len +
8170                                                 aad_pad_len);
8171         } else {
8172                 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
8173                                 ut_params->ibuf, tdata->auth_tag.len);
8174                 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
8175                                 "no room to append digest");
8176                 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
8177                                 ut_params->ibuf,
8178                                 plaintext_pad_len + aad_pad_len);
8179
8180                 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
8181                         tdata->auth_tag.len);
8182                 debug_hexdump(stdout, "digest:",
8183                         sym_op->aead.digest.data,
8184                         tdata->auth_tag.len);
8185         }
8186
8187         sym_op->aead.data.length = tdata->plaintext.len;
8188         sym_op->aead.data.offset = aad_pad_len;
8189
8190         return 0;
8191 }
8192
8193 static int
8194 test_authenticated_encryption(const struct aead_test_data *tdata)
8195 {
8196         struct crypto_testsuite_params *ts_params = &testsuite_params;
8197         struct crypto_unittest_params *ut_params = &unittest_params;
8198
8199         int retval;
8200         uint8_t *ciphertext, *auth_tag;
8201         uint16_t plaintext_pad_len;
8202         uint32_t i;
8203         struct rte_cryptodev_info dev_info;
8204
8205         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8206         uint64_t feat_flags = dev_info.feature_flags;
8207
8208         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
8209                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
8210                 printf("Device doesn't support RAW data-path APIs.\n");
8211                 return TEST_SKIPPED;
8212         }
8213
8214         /* Verify the capabilities */
8215         struct rte_cryptodev_sym_capability_idx cap_idx;
8216         const struct rte_cryptodev_symmetric_capability *capability;
8217         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
8218         cap_idx.algo.aead = tdata->algo;
8219         capability = rte_cryptodev_sym_capability_get(
8220                         ts_params->valid_devs[0], &cap_idx);
8221         if (capability == NULL)
8222                 return TEST_SKIPPED;
8223         if (rte_cryptodev_sym_capability_check_aead(
8224                         capability, tdata->key.len, tdata->auth_tag.len,
8225                         tdata->aad.len, tdata->iv.len))
8226                 return TEST_SKIPPED;
8227
8228         /* Create AEAD session */
8229         retval = create_aead_session(ts_params->valid_devs[0],
8230                         tdata->algo,
8231                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
8232                         tdata->key.data, tdata->key.len,
8233                         tdata->aad.len, tdata->auth_tag.len,
8234                         tdata->iv.len);
8235         if (retval < 0)
8236                 return retval;
8237
8238         if (tdata->aad.len > MBUF_SIZE) {
8239                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
8240                 /* Populate full size of add data */
8241                 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
8242                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
8243         } else
8244                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8245
8246         /* clear mbuf payload */
8247         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8248                         rte_pktmbuf_tailroom(ut_params->ibuf));
8249
8250         /* Create AEAD operation */
8251         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
8252         if (retval < 0)
8253                 return retval;
8254
8255         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
8256
8257         ut_params->op->sym->m_src = ut_params->ibuf;
8258
8259         /* Process crypto operation */
8260         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
8261                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
8262         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
8263                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
8264                                 ut_params->op, 0, 0, 0, 0);
8265         else
8266                 TEST_ASSERT_NOT_NULL(
8267                         process_crypto_request(ts_params->valid_devs[0],
8268                         ut_params->op), "failed to process sym crypto op");
8269
8270         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8271                         "crypto op processing failed");
8272
8273         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
8274
8275         if (ut_params->op->sym->m_dst) {
8276                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8277                                 uint8_t *);
8278                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
8279                                 uint8_t *, plaintext_pad_len);
8280         } else {
8281                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
8282                                 uint8_t *,
8283                                 ut_params->op->sym->cipher.data.offset);
8284                 auth_tag = ciphertext + plaintext_pad_len;
8285         }
8286
8287         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
8288         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
8289
8290         /* Validate obuf */
8291         TEST_ASSERT_BUFFERS_ARE_EQUAL(
8292                         ciphertext,
8293                         tdata->ciphertext.data,
8294                         tdata->ciphertext.len,
8295                         "Ciphertext data not as expected");
8296
8297         TEST_ASSERT_BUFFERS_ARE_EQUAL(
8298                         auth_tag,
8299                         tdata->auth_tag.data,
8300                         tdata->auth_tag.len,
8301                         "Generated auth tag not as expected");
8302
8303         return 0;
8304
8305 }
8306
8307 #ifdef RTE_LIB_SECURITY
8308 static int
8309 security_proto_supported(enum rte_security_session_action_type action,
8310         enum rte_security_session_protocol proto)
8311 {
8312         struct crypto_testsuite_params *ts_params = &testsuite_params;
8313
8314         const struct rte_security_capability *capabilities;
8315         const struct rte_security_capability *capability;
8316         uint16_t i = 0;
8317
8318         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8319                                 rte_cryptodev_get_sec_ctx(
8320                                 ts_params->valid_devs[0]);
8321
8322
8323         capabilities = rte_security_capabilities_get(ctx);
8324
8325         if (capabilities == NULL)
8326                 return -ENOTSUP;
8327
8328         while ((capability = &capabilities[i++])->action !=
8329                         RTE_SECURITY_ACTION_TYPE_NONE) {
8330                 if (capability->action == action &&
8331                                 capability->protocol == proto)
8332                         return 0;
8333         }
8334
8335         return -ENOTSUP;
8336 }
8337
8338 /* Basic algorithm run function for async inplace mode.
8339  * Creates a session from input parameters and runs one operation
8340  * on input_vec. Checks the output of the crypto operation against
8341  * output_vec.
8342  */
8343 static int test_pdcp_proto(int i, int oop, enum rte_crypto_cipher_operation opc,
8344                            enum rte_crypto_auth_operation opa,
8345                            const uint8_t *input_vec, unsigned int input_vec_len,
8346                            const uint8_t *output_vec,
8347                            unsigned int output_vec_len,
8348                            enum rte_crypto_cipher_algorithm cipher_alg,
8349                            const uint8_t *cipher_key, uint32_t cipher_key_len,
8350                            enum rte_crypto_auth_algorithm auth_alg,
8351                            const uint8_t *auth_key, uint32_t auth_key_len,
8352                            uint8_t bearer, enum rte_security_pdcp_domain domain,
8353                            uint8_t packet_direction, uint8_t sn_size,
8354                            uint32_t hfn, uint32_t hfn_threshold, uint8_t sdap)
8355 {
8356         struct crypto_testsuite_params *ts_params = &testsuite_params;
8357         struct crypto_unittest_params *ut_params = &unittest_params;
8358         uint8_t *plaintext;
8359         int ret = TEST_SUCCESS;
8360         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8361                                 rte_cryptodev_get_sec_ctx(
8362                                 ts_params->valid_devs[0]);
8363
8364         /* Verify the capabilities */
8365         struct rte_security_capability_idx sec_cap_idx;
8366
8367         sec_cap_idx.action = ut_params->type;
8368         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
8369         sec_cap_idx.pdcp.domain = domain;
8370         if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
8371                 return TEST_SKIPPED;
8372
8373         /* Generate test mbuf data */
8374         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8375
8376         /* clear mbuf payload */
8377         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8378                         rte_pktmbuf_tailroom(ut_params->ibuf));
8379
8380         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8381                                                   input_vec_len);
8382         memcpy(plaintext, input_vec, input_vec_len);
8383
8384         /* Out of place support */
8385         if (oop) {
8386                 /*
8387                  * For out-op-place we need to alloc another mbuf
8388                  */
8389                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8390                 rte_pktmbuf_append(ut_params->obuf, output_vec_len);
8391         }
8392
8393         /* Setup Cipher Parameters */
8394         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8395         ut_params->cipher_xform.cipher.algo = cipher_alg;
8396         ut_params->cipher_xform.cipher.op = opc;
8397         ut_params->cipher_xform.cipher.key.data = cipher_key;
8398         ut_params->cipher_xform.cipher.key.length = cipher_key_len;
8399         ut_params->cipher_xform.cipher.iv.length =
8400                                 packet_direction ? 4 : 0;
8401         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
8402
8403         /* Setup HMAC Parameters if ICV header is required */
8404         if (auth_alg != 0) {
8405                 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8406                 ut_params->auth_xform.next = NULL;
8407                 ut_params->auth_xform.auth.algo = auth_alg;
8408                 ut_params->auth_xform.auth.op = opa;
8409                 ut_params->auth_xform.auth.key.data = auth_key;
8410                 ut_params->auth_xform.auth.key.length = auth_key_len;
8411
8412                 ut_params->cipher_xform.next = &ut_params->auth_xform;
8413         } else {
8414                 ut_params->cipher_xform.next = NULL;
8415         }
8416
8417         struct rte_security_session_conf sess_conf = {
8418                 .action_type = ut_params->type,
8419                 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
8420                 {.pdcp = {
8421                         .bearer = bearer,
8422                         .domain = domain,
8423                         .pkt_dir = packet_direction,
8424                         .sn_size = sn_size,
8425                         .hfn = packet_direction ? 0 : hfn,
8426                         /**
8427                          * hfn can be set as pdcp_test_hfn[i]
8428                          * if hfn_ovrd is not set. Here, PDCP
8429                          * packet direction is just used to
8430                          * run half of the cases with session
8431                          * HFN and other half with per packet
8432                          * HFN.
8433                          */
8434                         .hfn_threshold = hfn_threshold,
8435                         .hfn_ovrd = packet_direction ? 1 : 0,
8436                         .sdap_enabled = sdap,
8437                 } },
8438                 .crypto_xform = &ut_params->cipher_xform
8439         };
8440
8441         /* Create security session */
8442         ut_params->sec_session = rte_security_session_create(ctx,
8443                                 &sess_conf, ts_params->session_mpool,
8444                                 ts_params->session_priv_mpool);
8445
8446         if (!ut_params->sec_session) {
8447                 printf("TestCase %s()-%d line %d failed %s: ",
8448                         __func__, i, __LINE__, "Failed to allocate session");
8449                 ret = TEST_FAILED;
8450                 goto on_err;
8451         }
8452
8453         /* Generate crypto op data structure */
8454         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8455                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8456         if (!ut_params->op) {
8457                 printf("TestCase %s()-%d line %d failed %s: ",
8458                         __func__, i, __LINE__,
8459                         "Failed to allocate symmetric crypto operation struct");
8460                 ret = TEST_FAILED;
8461                 goto on_err;
8462         }
8463
8464         uint32_t *per_pkt_hfn = rte_crypto_op_ctod_offset(ut_params->op,
8465                                         uint32_t *, IV_OFFSET);
8466         *per_pkt_hfn = packet_direction ? hfn : 0;
8467
8468         rte_security_attach_session(ut_params->op, ut_params->sec_session);
8469
8470         /* set crypto operation source mbuf */
8471         ut_params->op->sym->m_src = ut_params->ibuf;
8472         if (oop)
8473                 ut_params->op->sym->m_dst = ut_params->obuf;
8474
8475         /* Process crypto operation */
8476         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op)
8477                 == NULL) {
8478                 printf("TestCase %s()-%d line %d failed %s: ",
8479                         __func__, i, __LINE__,
8480                         "failed to process sym crypto op");
8481                 ret = TEST_FAILED;
8482                 goto on_err;
8483         }
8484
8485         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8486                 printf("TestCase %s()-%d line %d failed %s: ",
8487                         __func__, i, __LINE__, "crypto op processing failed");
8488                 ret = TEST_FAILED;
8489                 goto on_err;
8490         }
8491
8492         /* Validate obuf */
8493         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
8494                         uint8_t *);
8495         if (oop) {
8496                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8497                                 uint8_t *);
8498         }
8499
8500         if (memcmp(ciphertext, output_vec, output_vec_len)) {
8501                 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8502                 rte_hexdump(stdout, "encrypted", ciphertext, output_vec_len);
8503                 rte_hexdump(stdout, "reference", output_vec, output_vec_len);
8504                 ret = TEST_FAILED;
8505                 goto on_err;
8506         }
8507
8508 on_err:
8509         rte_crypto_op_free(ut_params->op);
8510         ut_params->op = NULL;
8511
8512         if (ut_params->sec_session)
8513                 rte_security_session_destroy(ctx, ut_params->sec_session);
8514         ut_params->sec_session = NULL;
8515
8516         rte_pktmbuf_free(ut_params->ibuf);
8517         ut_params->ibuf = NULL;
8518         if (oop) {
8519                 rte_pktmbuf_free(ut_params->obuf);
8520                 ut_params->obuf = NULL;
8521         }
8522
8523         return ret;
8524 }
8525
8526 static int
8527 test_pdcp_proto_SGL(int i, int oop,
8528         enum rte_crypto_cipher_operation opc,
8529         enum rte_crypto_auth_operation opa,
8530         uint8_t *input_vec,
8531         unsigned int input_vec_len,
8532         uint8_t *output_vec,
8533         unsigned int output_vec_len,
8534         uint32_t fragsz,
8535         uint32_t fragsz_oop)
8536 {
8537         struct crypto_testsuite_params *ts_params = &testsuite_params;
8538         struct crypto_unittest_params *ut_params = &unittest_params;
8539         uint8_t *plaintext;
8540         struct rte_mbuf *buf, *buf_oop = NULL;
8541         int ret = TEST_SUCCESS;
8542         int to_trn = 0;
8543         int to_trn_tbl[16];
8544         int segs = 1;
8545         unsigned int trn_data = 0;
8546         struct rte_cryptodev_info dev_info;
8547         uint64_t feat_flags;
8548         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8549                                 rte_cryptodev_get_sec_ctx(
8550                                 ts_params->valid_devs[0]);
8551         struct rte_mbuf *temp_mbuf;
8552
8553         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8554         feat_flags = dev_info.feature_flags;
8555
8556         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
8557                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
8558                 printf("Device does not support RAW data-path APIs.\n");
8559                 return -ENOTSUP;
8560         }
8561         /* Verify the capabilities */
8562         struct rte_security_capability_idx sec_cap_idx;
8563
8564         sec_cap_idx.action = ut_params->type;
8565         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
8566         sec_cap_idx.pdcp.domain = pdcp_test_params[i].domain;
8567         if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
8568                 return TEST_SKIPPED;
8569
8570         if (fragsz > input_vec_len)
8571                 fragsz = input_vec_len;
8572
8573         uint16_t plaintext_len = fragsz;
8574         uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
8575
8576         if (fragsz_oop > output_vec_len)
8577                 frag_size_oop = output_vec_len;
8578
8579         int ecx = 0;
8580         if (input_vec_len % fragsz != 0) {
8581                 if (input_vec_len / fragsz + 1 > 16)
8582                         return 1;
8583         } else if (input_vec_len / fragsz > 16)
8584                 return 1;
8585
8586         /* Out of place support */
8587         if (oop) {
8588                 /*
8589                  * For out-op-place we need to alloc another mbuf
8590                  */
8591                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8592                 rte_pktmbuf_append(ut_params->obuf, frag_size_oop);
8593                 buf_oop = ut_params->obuf;
8594         }
8595
8596         /* Generate test mbuf data */
8597         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8598
8599         /* clear mbuf payload */
8600         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8601                         rte_pktmbuf_tailroom(ut_params->ibuf));
8602
8603         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8604                                                   plaintext_len);
8605         memcpy(plaintext, input_vec, plaintext_len);
8606         trn_data += plaintext_len;
8607
8608         buf = ut_params->ibuf;
8609
8610         /*
8611          * Loop until no more fragments
8612          */
8613
8614         while (trn_data < input_vec_len) {
8615                 ++segs;
8616                 to_trn = (input_vec_len - trn_data < fragsz) ?
8617                                 (input_vec_len - trn_data) : fragsz;
8618
8619                 to_trn_tbl[ecx++] = to_trn;
8620
8621                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8622                 buf = buf->next;
8623
8624                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
8625                                 rte_pktmbuf_tailroom(buf));
8626
8627                 /* OOP */
8628                 if (oop && !fragsz_oop) {
8629                         buf_oop->next =
8630                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
8631                         buf_oop = buf_oop->next;
8632                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8633                                         0, rte_pktmbuf_tailroom(buf_oop));
8634                         rte_pktmbuf_append(buf_oop, to_trn);
8635                 }
8636
8637                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
8638                                 to_trn);
8639
8640                 memcpy(plaintext, input_vec + trn_data, to_trn);
8641                 trn_data += to_trn;
8642         }
8643
8644         ut_params->ibuf->nb_segs = segs;
8645
8646         segs = 1;
8647         if (fragsz_oop && oop) {
8648                 to_trn = 0;
8649                 ecx = 0;
8650
8651                 trn_data = frag_size_oop;
8652                 while (trn_data < output_vec_len) {
8653                         ++segs;
8654                         to_trn =
8655                                 (output_vec_len - trn_data <
8656                                                 frag_size_oop) ?
8657                                 (output_vec_len - trn_data) :
8658                                                 frag_size_oop;
8659
8660                         to_trn_tbl[ecx++] = to_trn;
8661
8662                         buf_oop->next =
8663                                 rte_pktmbuf_alloc(ts_params->mbuf_pool);
8664                         buf_oop = buf_oop->next;
8665                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8666                                         0, rte_pktmbuf_tailroom(buf_oop));
8667                         rte_pktmbuf_append(buf_oop, to_trn);
8668
8669                         trn_data += to_trn;
8670                 }
8671                 ut_params->obuf->nb_segs = segs;
8672         }
8673
8674         /* Setup Cipher Parameters */
8675         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8676         ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg;
8677         ut_params->cipher_xform.cipher.op = opc;
8678         ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i];
8679         ut_params->cipher_xform.cipher.key.length =
8680                                         pdcp_test_params[i].cipher_key_len;
8681         ut_params->cipher_xform.cipher.iv.length = 0;
8682
8683         /* Setup HMAC Parameters if ICV header is required */
8684         if (pdcp_test_params[i].auth_alg != 0) {
8685                 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8686                 ut_params->auth_xform.next = NULL;
8687                 ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg;
8688                 ut_params->auth_xform.auth.op = opa;
8689                 ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i];
8690                 ut_params->auth_xform.auth.key.length =
8691                                         pdcp_test_params[i].auth_key_len;
8692
8693                 ut_params->cipher_xform.next = &ut_params->auth_xform;
8694         } else {
8695                 ut_params->cipher_xform.next = NULL;
8696         }
8697
8698         struct rte_security_session_conf sess_conf = {
8699                 .action_type = ut_params->type,
8700                 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
8701                 {.pdcp = {
8702                         .bearer = pdcp_test_bearer[i],
8703                         .domain = pdcp_test_params[i].domain,
8704                         .pkt_dir = pdcp_test_packet_direction[i],
8705                         .sn_size = pdcp_test_data_sn_size[i],
8706                         .hfn = pdcp_test_hfn[i],
8707                         .hfn_threshold = pdcp_test_hfn_threshold[i],
8708                         .hfn_ovrd = 0,
8709                 } },
8710                 .crypto_xform = &ut_params->cipher_xform
8711         };
8712
8713         /* Create security session */
8714         ut_params->sec_session = rte_security_session_create(ctx,
8715                                 &sess_conf, ts_params->session_mpool,
8716                                 ts_params->session_priv_mpool);
8717
8718         if (!ut_params->sec_session) {
8719                 printf("TestCase %s()-%d line %d failed %s: ",
8720                         __func__, i, __LINE__, "Failed to allocate session");
8721                 ret = TEST_FAILED;
8722                 goto on_err;
8723         }
8724
8725         /* Generate crypto op data structure */
8726         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8727                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8728         if (!ut_params->op) {
8729                 printf("TestCase %s()-%d line %d failed %s: ",
8730                         __func__, i, __LINE__,
8731                         "Failed to allocate symmetric crypto operation struct");
8732                 ret = TEST_FAILED;
8733                 goto on_err;
8734         }
8735
8736         rte_security_attach_session(ut_params->op, ut_params->sec_session);
8737
8738         /* set crypto operation source mbuf */
8739         ut_params->op->sym->m_src = ut_params->ibuf;
8740         if (oop)
8741                 ut_params->op->sym->m_dst = ut_params->obuf;
8742
8743         /* Process crypto operation */
8744         temp_mbuf = ut_params->op->sym->m_src;
8745         if (global_api_test_type == CRYPTODEV_RAW_API_TEST) {
8746                 /* filling lengths */
8747                 while (temp_mbuf) {
8748                         ut_params->op->sym->cipher.data.length
8749                                 += temp_mbuf->pkt_len;
8750                         ut_params->op->sym->auth.data.length
8751                                 += temp_mbuf->pkt_len;
8752                         temp_mbuf = temp_mbuf->next;
8753                 }
8754                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
8755                         ut_params->op, 1, 1, 0, 0);
8756         } else {
8757                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
8758                                                         ut_params->op);
8759         }
8760         if (ut_params->op == NULL) {
8761                 printf("TestCase %s()-%d line %d failed %s: ",
8762                         __func__, i, __LINE__,
8763                         "failed to process sym crypto op");
8764                 ret = TEST_FAILED;
8765                 goto on_err;
8766         }
8767
8768         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8769                 printf("TestCase %s()-%d line %d failed %s: ",
8770                         __func__, i, __LINE__, "crypto op processing failed");
8771                 ret = TEST_FAILED;
8772                 goto on_err;
8773         }
8774
8775         /* Validate obuf */
8776         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
8777                         uint8_t *);
8778         if (oop) {
8779                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8780                                 uint8_t *);
8781         }
8782         if (fragsz_oop)
8783                 fragsz = frag_size_oop;
8784         if (memcmp(ciphertext, output_vec, fragsz)) {
8785                 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8786                 rte_hexdump(stdout, "encrypted", ciphertext, fragsz);
8787                 rte_hexdump(stdout, "reference", output_vec, fragsz);
8788                 ret = TEST_FAILED;
8789                 goto on_err;
8790         }
8791
8792         buf = ut_params->op->sym->m_src->next;
8793         if (oop)
8794                 buf = ut_params->op->sym->m_dst->next;
8795
8796         unsigned int off = fragsz;
8797
8798         ecx = 0;
8799         while (buf) {
8800                 ciphertext = rte_pktmbuf_mtod(buf,
8801                                 uint8_t *);
8802                 if (memcmp(ciphertext, output_vec + off, to_trn_tbl[ecx])) {
8803                         printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8804                         rte_hexdump(stdout, "encrypted", ciphertext, to_trn_tbl[ecx]);
8805                         rte_hexdump(stdout, "reference", output_vec + off,
8806                                         to_trn_tbl[ecx]);
8807                         ret = TEST_FAILED;
8808                         goto on_err;
8809                 }
8810                 off += to_trn_tbl[ecx++];
8811                 buf = buf->next;
8812         }
8813 on_err:
8814         rte_crypto_op_free(ut_params->op);
8815         ut_params->op = NULL;
8816
8817         if (ut_params->sec_session)
8818                 rte_security_session_destroy(ctx, ut_params->sec_session);
8819         ut_params->sec_session = NULL;
8820
8821         rte_pktmbuf_free(ut_params->ibuf);
8822         ut_params->ibuf = NULL;
8823         if (oop) {
8824                 rte_pktmbuf_free(ut_params->obuf);
8825                 ut_params->obuf = NULL;
8826         }
8827
8828         return ret;
8829 }
8830
8831 int
8832 test_pdcp_proto_cplane_encap(int i)
8833 {
8834         return test_pdcp_proto(
8835                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8836                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8837                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8838                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8839                 pdcp_test_params[i].cipher_key_len,
8840                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8841                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8842                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8843                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8844                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8845 }
8846
8847 int
8848 test_pdcp_proto_uplane_encap(int i)
8849 {
8850         return test_pdcp_proto(
8851                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8852                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8853                 pdcp_test_data_out[i], pdcp_test_data_in_len[i],
8854                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8855                 pdcp_test_params[i].cipher_key_len,
8856                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8857                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8858                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8859                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8860                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8861 }
8862
8863 int
8864 test_pdcp_proto_uplane_encap_with_int(int i)
8865 {
8866         return test_pdcp_proto(
8867                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8868                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8869                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8870                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8871                 pdcp_test_params[i].cipher_key_len,
8872                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8873                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8874                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8875                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8876                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8877 }
8878
8879 int
8880 test_pdcp_proto_cplane_decap(int i)
8881 {
8882         return test_pdcp_proto(
8883                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8884                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8885                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8886                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8887                 pdcp_test_params[i].cipher_key_len,
8888                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8889                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8890                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8891                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8892                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8893 }
8894
8895 int
8896 test_pdcp_proto_uplane_decap(int i)
8897 {
8898         return test_pdcp_proto(
8899                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8900                 pdcp_test_data_out[i], pdcp_test_data_in_len[i],
8901                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8902                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8903                 pdcp_test_params[i].cipher_key_len,
8904                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8905                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8906                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8907                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8908                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8909 }
8910
8911 int
8912 test_pdcp_proto_uplane_decap_with_int(int i)
8913 {
8914         return test_pdcp_proto(
8915                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8916                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8917                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8918                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8919                 pdcp_test_params[i].cipher_key_len,
8920                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8921                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8922                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8923                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8924                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8925 }
8926
8927 static int
8928 test_PDCP_PROTO_SGL_in_place_32B(void)
8929 {
8930         /* i can be used for running any PDCP case
8931          * In this case it is uplane 12-bit AES-SNOW DL encap
8932          */
8933         int i = PDCP_UPLANE_12BIT_OFFSET + AES_ENC + SNOW_AUTH + DOWNLINK;
8934         return test_pdcp_proto_SGL(i, IN_PLACE,
8935                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8936                         RTE_CRYPTO_AUTH_OP_GENERATE,
8937                         pdcp_test_data_in[i],
8938                         pdcp_test_data_in_len[i],
8939                         pdcp_test_data_out[i],
8940                         pdcp_test_data_in_len[i]+4,
8941                         32, 0);
8942 }
8943 static int
8944 test_PDCP_PROTO_SGL_oop_32B_128B(void)
8945 {
8946         /* i can be used for running any PDCP case
8947          * In this case it is uplane 18-bit NULL-NULL DL encap
8948          */
8949         int i = PDCP_UPLANE_18BIT_OFFSET + NULL_ENC + NULL_AUTH + DOWNLINK;
8950         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8951                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8952                         RTE_CRYPTO_AUTH_OP_GENERATE,
8953                         pdcp_test_data_in[i],
8954                         pdcp_test_data_in_len[i],
8955                         pdcp_test_data_out[i],
8956                         pdcp_test_data_in_len[i]+4,
8957                         32, 128);
8958 }
8959 static int
8960 test_PDCP_PROTO_SGL_oop_32B_40B(void)
8961 {
8962         /* i can be used for running any PDCP case
8963          * In this case it is uplane 18-bit AES DL encap
8964          */
8965         int i = PDCP_UPLANE_OFFSET + AES_ENC + EIGHTEEN_BIT_SEQ_NUM_OFFSET
8966                         + DOWNLINK;
8967         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8968                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8969                         RTE_CRYPTO_AUTH_OP_GENERATE,
8970                         pdcp_test_data_in[i],
8971                         pdcp_test_data_in_len[i],
8972                         pdcp_test_data_out[i],
8973                         pdcp_test_data_in_len[i],
8974                         32, 40);
8975 }
8976 static int
8977 test_PDCP_PROTO_SGL_oop_128B_32B(void)
8978 {
8979         /* i can be used for running any PDCP case
8980          * In this case it is cplane 12-bit AES-ZUC DL encap
8981          */
8982         int i = PDCP_CPLANE_LONG_SN_OFFSET + AES_ENC + ZUC_AUTH + DOWNLINK;
8983         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8984                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8985                         RTE_CRYPTO_AUTH_OP_GENERATE,
8986                         pdcp_test_data_in[i],
8987                         pdcp_test_data_in_len[i],
8988                         pdcp_test_data_out[i],
8989                         pdcp_test_data_in_len[i]+4,
8990                         128, 32);
8991 }
8992
8993 static int
8994 test_PDCP_SDAP_PROTO_encap_all(void)
8995 {
8996         int i = 0, size = 0;
8997         int err, all_err = TEST_SUCCESS;
8998         const struct pdcp_sdap_test *cur_test;
8999
9000         size = RTE_DIM(list_pdcp_sdap_tests);
9001
9002         for (i = 0; i < size; i++) {
9003                 cur_test = &list_pdcp_sdap_tests[i];
9004                 err = test_pdcp_proto(
9005                         i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT,
9006                         RTE_CRYPTO_AUTH_OP_GENERATE, cur_test->data_in,
9007                         cur_test->in_len, cur_test->data_out,
9008                         cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
9009                         cur_test->param.cipher_alg, cur_test->cipher_key,
9010                         cur_test->param.cipher_key_len,
9011                         cur_test->param.auth_alg,
9012                         cur_test->auth_key, cur_test->param.auth_key_len,
9013                         cur_test->bearer, cur_test->param.domain,
9014                         cur_test->packet_direction, cur_test->sn_size,
9015                         cur_test->hfn,
9016                         cur_test->hfn_threshold, SDAP_ENABLED);
9017                 if (err) {
9018                         printf("\t%d) %s: Encapsulation failed\n",
9019                                         cur_test->test_idx,
9020                                         cur_test->param.name);
9021                         err = TEST_FAILED;
9022                 } else {
9023                         printf("\t%d) %s: Encap PASS\n", cur_test->test_idx,
9024                                         cur_test->param.name);
9025                         err = TEST_SUCCESS;
9026                 }
9027                 all_err += err;
9028         }
9029
9030         printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
9031
9032         return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
9033 }
9034
9035 static int
9036 test_PDCP_PROTO_short_mac(void)
9037 {
9038         int i = 0, size = 0;
9039         int err, all_err = TEST_SUCCESS;
9040         const struct pdcp_short_mac_test *cur_test;
9041
9042         size = RTE_DIM(list_pdcp_smac_tests);
9043
9044         for (i = 0; i < size; i++) {
9045                 cur_test = &list_pdcp_smac_tests[i];
9046                 err = test_pdcp_proto(
9047                         i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT,
9048                         RTE_CRYPTO_AUTH_OP_GENERATE, cur_test->data_in,
9049                         cur_test->in_len, cur_test->data_out,
9050                         cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
9051                         RTE_CRYPTO_CIPHER_NULL, NULL,
9052                         0, cur_test->param.auth_alg,
9053                         cur_test->auth_key, cur_test->param.auth_key_len,
9054                         0, cur_test->param.domain, 0, 0,
9055                         0, 0, 0);
9056                 if (err) {
9057                         printf("\t%d) %s: Short MAC test failed\n",
9058                                         cur_test->test_idx,
9059                                         cur_test->param.name);
9060                         err = TEST_FAILED;
9061                 } else {
9062                         printf("\t%d) %s: Short MAC test PASS\n",
9063                                         cur_test->test_idx,
9064                                         cur_test->param.name);
9065                         rte_hexdump(stdout, "MAC I",
9066                                     cur_test->data_out + cur_test->in_len + 2,
9067                                     2);
9068                         err = TEST_SUCCESS;
9069                 }
9070                 all_err += err;
9071         }
9072
9073         printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
9074
9075         return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
9076
9077 }
9078
9079 static int
9080 test_PDCP_SDAP_PROTO_decap_all(void)
9081 {
9082         int i = 0, size = 0;
9083         int err, all_err = TEST_SUCCESS;
9084         const struct pdcp_sdap_test *cur_test;
9085
9086         size = RTE_DIM(list_pdcp_sdap_tests);
9087
9088         for (i = 0; i < size; i++) {
9089                 cur_test = &list_pdcp_sdap_tests[i];
9090                 err = test_pdcp_proto(
9091                         i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT,
9092                         RTE_CRYPTO_AUTH_OP_VERIFY,
9093                         cur_test->data_out,
9094                         cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
9095                         cur_test->data_in, cur_test->in_len,
9096                         cur_test->param.cipher_alg,
9097                         cur_test->cipher_key, cur_test->param.cipher_key_len,
9098                         cur_test->param.auth_alg, cur_test->auth_key,
9099                         cur_test->param.auth_key_len, cur_test->bearer,
9100                         cur_test->param.domain, cur_test->packet_direction,
9101                         cur_test->sn_size, cur_test->hfn,
9102                         cur_test->hfn_threshold, SDAP_ENABLED);
9103                 if (err) {
9104                         printf("\t%d) %s: Decapsulation failed\n",
9105                                         cur_test->test_idx,
9106                                         cur_test->param.name);
9107                         err = TEST_FAILED;
9108                 } else {
9109                         printf("\t%d) %s: Decap PASS\n", cur_test->test_idx,
9110                                         cur_test->param.name);
9111                         err = TEST_SUCCESS;
9112                 }
9113                 all_err += err;
9114         }
9115
9116         printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
9117
9118         return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
9119 }
9120
9121 static int
9122 test_ipsec_proto_process(const struct ipsec_test_data td[],
9123                          struct ipsec_test_data res_d[],
9124                          int nb_td,
9125                          bool silent,
9126                          const struct ipsec_test_flags *flags)
9127 {
9128         uint16_t v6_src[8] = {0x2607, 0xf8b0, 0x400c, 0x0c03, 0x0000, 0x0000,
9129                                 0x0000, 0x001a};
9130         uint16_t v6_dst[8] = {0x2001, 0x0470, 0xe5bf, 0xdead, 0x4957, 0x2174,
9131                                 0xe82c, 0x4887};
9132         struct crypto_testsuite_params *ts_params = &testsuite_params;
9133         struct crypto_unittest_params *ut_params = &unittest_params;
9134         struct rte_security_capability_idx sec_cap_idx;
9135         const struct rte_security_capability *sec_cap;
9136         struct rte_security_ipsec_xform ipsec_xform;
9137         uint8_t dev_id = ts_params->valid_devs[0];
9138         enum rte_security_ipsec_sa_direction dir;
9139         struct ipsec_test_data *res_d_tmp = NULL;
9140         uint32_t src = RTE_IPV4(192, 168, 1, 0);
9141         uint32_t dst = RTE_IPV4(192, 168, 1, 1);
9142         int salt_len, i, ret = TEST_SUCCESS;
9143         struct rte_security_ctx *ctx;
9144         uint8_t *input_text;
9145         uint32_t verify;
9146
9147         ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
9148         gbl_action_type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
9149
9150         /* Use first test data to create session */
9151
9152         /* Copy IPsec xform */
9153         memcpy(&ipsec_xform, &td[0].ipsec_xform, sizeof(ipsec_xform));
9154
9155         dir = ipsec_xform.direction;
9156         verify = flags->tunnel_hdr_verify;
9157
9158         if ((dir == RTE_SECURITY_IPSEC_SA_DIR_INGRESS) && verify) {
9159                 if (verify == RTE_SECURITY_IPSEC_TUNNEL_VERIFY_SRC_DST_ADDR)
9160                         src += 1;
9161                 else if (verify == RTE_SECURITY_IPSEC_TUNNEL_VERIFY_DST_ADDR)
9162                         dst += 1;
9163         }
9164
9165         if (td->ipsec_xform.mode == RTE_SECURITY_IPSEC_SA_MODE_TUNNEL) {
9166                 if (td->ipsec_xform.tunnel.type ==
9167                                 RTE_SECURITY_IPSEC_TUNNEL_IPV4) {
9168                         memcpy(&ipsec_xform.tunnel.ipv4.src_ip, &src,
9169                                sizeof(src));
9170                         memcpy(&ipsec_xform.tunnel.ipv4.dst_ip, &dst,
9171                                sizeof(dst));
9172                 } else {
9173                         memcpy(&ipsec_xform.tunnel.ipv6.src_addr, &v6_src,
9174                                sizeof(v6_src));
9175                         memcpy(&ipsec_xform.tunnel.ipv6.dst_addr, &v6_dst,
9176                                sizeof(v6_dst));
9177                 }
9178         }
9179
9180         ctx = rte_cryptodev_get_sec_ctx(dev_id);
9181
9182         sec_cap_idx.action = ut_params->type;
9183         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_IPSEC;
9184         sec_cap_idx.ipsec.proto = ipsec_xform.proto;
9185         sec_cap_idx.ipsec.mode = ipsec_xform.mode;
9186         sec_cap_idx.ipsec.direction = ipsec_xform.direction;
9187
9188         if (flags->udp_encap)
9189                 ipsec_xform.options.udp_encap = 1;
9190
9191         sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
9192         if (sec_cap == NULL)
9193                 return TEST_SKIPPED;
9194
9195         /* Copy cipher session parameters */
9196         if (td[0].aead) {
9197                 memcpy(&ut_params->aead_xform, &td[0].xform.aead,
9198                        sizeof(ut_params->aead_xform));
9199                 ut_params->aead_xform.aead.key.data = td[0].key.data;
9200                 ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
9201
9202                 /* Verify crypto capabilities */
9203                 if (test_ipsec_crypto_caps_aead_verify(
9204                                 sec_cap,
9205                                 &ut_params->aead_xform) != 0) {
9206                         if (!silent)
9207                                 RTE_LOG(INFO, USER1,
9208                                         "Crypto capabilities not supported\n");
9209                         return TEST_SKIPPED;
9210                 }
9211         } else {
9212                 memcpy(&ut_params->cipher_xform, &td[0].xform.chain.cipher,
9213                        sizeof(ut_params->cipher_xform));
9214                 memcpy(&ut_params->auth_xform, &td[0].xform.chain.auth,
9215                        sizeof(ut_params->auth_xform));
9216                 ut_params->cipher_xform.cipher.key.data = td[0].key.data;
9217                 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
9218                 ut_params->auth_xform.auth.key.data = td[0].auth_key.data;
9219
9220                 /* Verify crypto capabilities */
9221
9222                 if (test_ipsec_crypto_caps_cipher_verify(
9223                                 sec_cap,
9224                                 &ut_params->cipher_xform) != 0) {
9225                         if (!silent)
9226                                 RTE_LOG(INFO, USER1,
9227                                         "Cipher crypto capabilities not supported\n");
9228                         return TEST_SKIPPED;
9229                 }
9230
9231                 if (test_ipsec_crypto_caps_auth_verify(
9232                                 sec_cap,
9233                                 &ut_params->auth_xform) != 0) {
9234                         if (!silent)
9235                                 RTE_LOG(INFO, USER1,
9236                                         "Auth crypto capabilities not supported\n");
9237                         return TEST_SKIPPED;
9238                 }
9239         }
9240
9241         if (test_ipsec_sec_caps_verify(&ipsec_xform, sec_cap, silent) != 0)
9242                 return TEST_SKIPPED;
9243
9244         struct rte_security_session_conf sess_conf = {
9245                 .action_type = ut_params->type,
9246                 .protocol = RTE_SECURITY_PROTOCOL_IPSEC,
9247         };
9248
9249         if (td[0].aead) {
9250                 salt_len = RTE_MIN(sizeof(ipsec_xform.salt), td[0].salt.len);
9251                 memcpy(&ipsec_xform.salt, td[0].salt.data, salt_len);
9252                 sess_conf.ipsec = ipsec_xform;
9253                 sess_conf.crypto_xform = &ut_params->aead_xform;
9254         } else {
9255                 sess_conf.ipsec = ipsec_xform;
9256                 if (dir == RTE_SECURITY_IPSEC_SA_DIR_EGRESS) {
9257                         sess_conf.crypto_xform = &ut_params->cipher_xform;
9258                         ut_params->cipher_xform.next = &ut_params->auth_xform;
9259                 } else {
9260                         sess_conf.crypto_xform = &ut_params->auth_xform;
9261                         ut_params->auth_xform.next = &ut_params->cipher_xform;
9262                 }
9263         }
9264
9265         /* Create security session */
9266         ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
9267                                         ts_params->session_mpool,
9268                                         ts_params->session_priv_mpool);
9269
9270         if (ut_params->sec_session == NULL)
9271                 return TEST_SKIPPED;
9272
9273         for (i = 0; i < nb_td; i++) {
9274                 /* Setup source mbuf payload */
9275                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9276                 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9277                                 rte_pktmbuf_tailroom(ut_params->ibuf));
9278
9279                 input_text = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9280                                 td[i].input_text.len);
9281
9282                 memcpy(input_text, td[i].input_text.data,
9283                        td[i].input_text.len);
9284
9285                 /* Generate crypto op data structure */
9286                 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9287                                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9288                 if (!ut_params->op) {
9289                         printf("TestCase %s line %d: %s\n",
9290                                 __func__, __LINE__,
9291                                 "failed to allocate crypto op");
9292                         ret = TEST_FAILED;
9293                         goto crypto_op_free;
9294                 }
9295
9296                 /* Attach session to operation */
9297                 rte_security_attach_session(ut_params->op,
9298                                             ut_params->sec_session);
9299
9300                 /* Set crypto operation mbufs */
9301                 ut_params->op->sym->m_src = ut_params->ibuf;
9302                 ut_params->op->sym->m_dst = NULL;
9303
9304                 /* Copy IV in crypto operation when IV generation is disabled */
9305                 if (dir == RTE_SECURITY_IPSEC_SA_DIR_EGRESS &&
9306                     ipsec_xform.options.iv_gen_disable == 1) {
9307                         uint8_t *iv = rte_crypto_op_ctod_offset(ut_params->op,
9308                                                                 uint8_t *,
9309                                                                 IV_OFFSET);
9310                         int len;
9311
9312                         if (td[i].aead)
9313                                 len = td[i].xform.aead.aead.iv.length;
9314                         else
9315                                 len = td[i].xform.chain.cipher.cipher.iv.length;
9316
9317                         memcpy(iv, td[i].iv.data, len);
9318                 }
9319
9320                 /* Process crypto operation */
9321                 process_crypto_request(dev_id, ut_params->op);
9322
9323                 ret = test_ipsec_status_check(ut_params->op, flags, dir, i + 1);
9324                 if (ret != TEST_SUCCESS)
9325                         goto crypto_op_free;
9326
9327                 if (res_d != NULL)
9328                         res_d_tmp = &res_d[i];
9329
9330                 ret = test_ipsec_post_process(ut_params->ibuf, &td[i],
9331                                               res_d_tmp, silent, flags);
9332                 if (ret != TEST_SUCCESS)
9333                         goto crypto_op_free;
9334
9335                 ret = test_ipsec_stats_verify(ctx, ut_params->sec_session,
9336                                               flags, dir);
9337                 if (ret != TEST_SUCCESS)
9338                         goto crypto_op_free;
9339
9340                 rte_crypto_op_free(ut_params->op);
9341                 ut_params->op = NULL;
9342
9343                 rte_pktmbuf_free(ut_params->ibuf);
9344                 ut_params->ibuf = NULL;
9345         }
9346
9347 crypto_op_free:
9348         rte_crypto_op_free(ut_params->op);
9349         ut_params->op = NULL;
9350
9351         rte_pktmbuf_free(ut_params->ibuf);
9352         ut_params->ibuf = NULL;
9353
9354         if (ut_params->sec_session)
9355                 rte_security_session_destroy(ctx, ut_params->sec_session);
9356         ut_params->sec_session = NULL;
9357
9358         return ret;
9359 }
9360
9361 static int
9362 test_ipsec_proto_known_vec(const void *test_data)
9363 {
9364         struct ipsec_test_data td_outb;
9365         struct ipsec_test_flags flags;
9366
9367         memset(&flags, 0, sizeof(flags));
9368
9369         memcpy(&td_outb, test_data, sizeof(td_outb));
9370
9371         if (td_outb.aead ||
9372             td_outb.xform.chain.cipher.cipher.algo != RTE_CRYPTO_CIPHER_NULL) {
9373                 /* Disable IV gen to be able to test with known vectors */
9374                 td_outb.ipsec_xform.options.iv_gen_disable = 1;
9375         }
9376
9377         return test_ipsec_proto_process(&td_outb, NULL, 1, false, &flags);
9378 }
9379
9380 static int
9381 test_ipsec_proto_known_vec_inb(const void *test_data)
9382 {
9383         const struct ipsec_test_data *td = test_data;
9384         struct ipsec_test_flags flags;
9385         struct ipsec_test_data td_inb;
9386
9387         memset(&flags, 0, sizeof(flags));
9388
9389         if (td->ipsec_xform.direction == RTE_SECURITY_IPSEC_SA_DIR_EGRESS)
9390                 test_ipsec_td_in_from_out(td, &td_inb);
9391         else
9392                 memcpy(&td_inb, td, sizeof(td_inb));
9393
9394         return test_ipsec_proto_process(&td_inb, NULL, 1, false, &flags);
9395 }
9396
9397 static int
9398 test_ipsec_proto_known_vec_fragmented(const void *test_data)
9399 {
9400         struct ipsec_test_data td_outb;
9401         struct ipsec_test_flags flags;
9402
9403         memset(&flags, 0, sizeof(flags));
9404         flags.fragment = true;
9405
9406         memcpy(&td_outb, test_data, sizeof(td_outb));
9407
9408         /* Disable IV gen to be able to test with known vectors */
9409         td_outb.ipsec_xform.options.iv_gen_disable = 1;
9410
9411         return test_ipsec_proto_process(&td_outb, NULL, 1, false, &flags);
9412 }
9413
9414 static int
9415 test_ipsec_proto_all(const struct ipsec_test_flags *flags)
9416 {
9417         struct ipsec_test_data td_outb[IPSEC_TEST_PACKETS_MAX];
9418         struct ipsec_test_data td_inb[IPSEC_TEST_PACKETS_MAX];
9419         unsigned int i, nb_pkts = 1, pass_cnt = 0;
9420         int ret;
9421
9422         if (flags->iv_gen ||
9423             flags->sa_expiry_pkts_soft ||
9424             flags->sa_expiry_pkts_hard)
9425                 nb_pkts = IPSEC_TEST_PACKETS_MAX;
9426
9427         for (i = 0; i < RTE_DIM(alg_list); i++) {
9428                 test_ipsec_td_prepare(alg_list[i].param1,
9429                                       alg_list[i].param2,
9430                                       flags,
9431                                       td_outb,
9432                                       nb_pkts);
9433
9434                 if (!td_outb->aead) {
9435                         enum rte_crypto_cipher_algorithm cipher_alg;
9436                         enum rte_crypto_auth_algorithm auth_alg;
9437
9438                         cipher_alg = td_outb->xform.chain.cipher.cipher.algo;
9439                         auth_alg = td_outb->xform.chain.auth.auth.algo;
9440
9441                         /* ICV is not applicable for NULL auth */
9442                         if (flags->icv_corrupt &&
9443                             auth_alg == RTE_CRYPTO_AUTH_NULL)
9444                                 continue;
9445
9446                         /* IV is not applicable for NULL cipher */
9447                         if (flags->iv_gen &&
9448                             cipher_alg == RTE_CRYPTO_CIPHER_NULL)
9449                                 continue;
9450                 }
9451
9452                 ret = test_ipsec_proto_process(td_outb, td_inb, nb_pkts, true,
9453                                                flags);
9454                 if (ret == TEST_SKIPPED)
9455                         continue;
9456
9457                 if (ret == TEST_FAILED)
9458                         return TEST_FAILED;
9459
9460                 test_ipsec_td_update(td_inb, td_outb, nb_pkts, flags);
9461
9462                 ret = test_ipsec_proto_process(td_inb, NULL, nb_pkts, true,
9463                                                flags);
9464                 if (ret == TEST_SKIPPED)
9465                         continue;
9466
9467                 if (ret == TEST_FAILED)
9468                         return TEST_FAILED;
9469
9470                 if (flags->display_alg)
9471                         test_ipsec_display_alg(alg_list[i].param1,
9472                                                alg_list[i].param2);
9473
9474                 pass_cnt++;
9475         }
9476
9477         if (pass_cnt > 0)
9478                 return TEST_SUCCESS;
9479         else
9480                 return TEST_SKIPPED;
9481 }
9482
9483 static int
9484 test_ipsec_proto_display_list(const void *data __rte_unused)
9485 {
9486         struct ipsec_test_flags flags;
9487
9488         memset(&flags, 0, sizeof(flags));
9489
9490         flags.display_alg = true;
9491
9492         return test_ipsec_proto_all(&flags);
9493 }
9494
9495 static int
9496 test_ipsec_proto_iv_gen(const void *data __rte_unused)
9497 {
9498         struct ipsec_test_flags flags;
9499
9500         memset(&flags, 0, sizeof(flags));
9501
9502         flags.iv_gen = true;
9503
9504         return test_ipsec_proto_all(&flags);
9505 }
9506
9507 static int
9508 test_ipsec_proto_sa_exp_pkts_soft(const void *data __rte_unused)
9509 {
9510         struct ipsec_test_flags flags;
9511
9512         memset(&flags, 0, sizeof(flags));
9513
9514         flags.sa_expiry_pkts_soft = true;
9515
9516         return test_ipsec_proto_all(&flags);
9517 }
9518
9519 static int
9520 test_ipsec_proto_sa_exp_pkts_hard(const void *data __rte_unused)
9521 {
9522         struct ipsec_test_flags flags;
9523
9524         memset(&flags, 0, sizeof(flags));
9525
9526         flags.sa_expiry_pkts_hard = true;
9527
9528         return test_ipsec_proto_all(&flags);
9529 }
9530
9531 static int
9532 test_ipsec_proto_err_icv_corrupt(const void *data __rte_unused)
9533 {
9534         struct ipsec_test_flags flags;
9535
9536         memset(&flags, 0, sizeof(flags));
9537
9538         flags.icv_corrupt = true;
9539
9540         return test_ipsec_proto_all(&flags);
9541 }
9542
9543 static int
9544 test_ipsec_proto_udp_encap(const void *data __rte_unused)
9545 {
9546         struct ipsec_test_flags flags;
9547
9548         memset(&flags, 0, sizeof(flags));
9549
9550         flags.udp_encap = true;
9551
9552         return test_ipsec_proto_all(&flags);
9553 }
9554
9555 static int
9556 test_ipsec_proto_tunnel_src_dst_addr_verify(const void *data __rte_unused)
9557 {
9558         struct ipsec_test_flags flags;
9559
9560         memset(&flags, 0, sizeof(flags));
9561
9562         flags.tunnel_hdr_verify = RTE_SECURITY_IPSEC_TUNNEL_VERIFY_SRC_DST_ADDR;
9563
9564         return test_ipsec_proto_all(&flags);
9565 }
9566
9567 static int
9568 test_ipsec_proto_tunnel_dst_addr_verify(const void *data __rte_unused)
9569 {
9570         struct ipsec_test_flags flags;
9571
9572         memset(&flags, 0, sizeof(flags));
9573
9574         flags.tunnel_hdr_verify = RTE_SECURITY_IPSEC_TUNNEL_VERIFY_DST_ADDR;
9575
9576         return test_ipsec_proto_all(&flags);
9577 }
9578
9579 static int
9580 test_ipsec_proto_udp_ports_verify(const void *data __rte_unused)
9581 {
9582         struct ipsec_test_flags flags;
9583
9584         memset(&flags, 0, sizeof(flags));
9585
9586         flags.udp_encap = true;
9587         flags.udp_ports_verify = true;
9588
9589         return test_ipsec_proto_all(&flags);
9590 }
9591
9592 static int
9593 test_ipsec_proto_inner_ip_csum(const void *data __rte_unused)
9594 {
9595         struct ipsec_test_flags flags;
9596
9597         memset(&flags, 0, sizeof(flags));
9598
9599         flags.ip_csum = true;
9600
9601         return test_ipsec_proto_all(&flags);
9602 }
9603
9604 static int
9605 test_ipsec_proto_inner_l4_csum(const void *data __rte_unused)
9606 {
9607         struct ipsec_test_flags flags;
9608
9609         memset(&flags, 0, sizeof(flags));
9610
9611         flags.l4_csum = true;
9612
9613         return test_ipsec_proto_all(&flags);
9614 }
9615
9616 static int
9617 test_ipsec_proto_tunnel_v4_in_v4(const void *data __rte_unused)
9618 {
9619         struct ipsec_test_flags flags;
9620
9621         memset(&flags, 0, sizeof(flags));
9622
9623         flags.ipv6 = false;
9624         flags.tunnel_ipv6 = false;
9625
9626         return test_ipsec_proto_all(&flags);
9627 }
9628
9629 static int
9630 test_ipsec_proto_tunnel_v6_in_v6(const void *data __rte_unused)
9631 {
9632         struct ipsec_test_flags flags;
9633
9634         memset(&flags, 0, sizeof(flags));
9635
9636         flags.ipv6 = true;
9637         flags.tunnel_ipv6 = true;
9638
9639         return test_ipsec_proto_all(&flags);
9640 }
9641
9642 static int
9643 test_ipsec_proto_tunnel_v4_in_v6(const void *data __rte_unused)
9644 {
9645         struct ipsec_test_flags flags;
9646
9647         memset(&flags, 0, sizeof(flags));
9648
9649         flags.ipv6 = false;
9650         flags.tunnel_ipv6 = true;
9651
9652         return test_ipsec_proto_all(&flags);
9653 }
9654
9655 static int
9656 test_ipsec_proto_tunnel_v6_in_v4(const void *data __rte_unused)
9657 {
9658         struct ipsec_test_flags flags;
9659
9660         memset(&flags, 0, sizeof(flags));
9661
9662         flags.ipv6 = true;
9663         flags.tunnel_ipv6 = false;
9664
9665         return test_ipsec_proto_all(&flags);
9666 }
9667
9668 static int
9669 test_ipsec_proto_transport_v4(const void *data __rte_unused)
9670 {
9671         struct ipsec_test_flags flags;
9672
9673         memset(&flags, 0, sizeof(flags));
9674
9675         flags.ipv6 = false;
9676         flags.transport = true;
9677
9678         return test_ipsec_proto_all(&flags);
9679 }
9680
9681 static int
9682 test_ipsec_proto_stats(const void *data __rte_unused)
9683 {
9684         struct ipsec_test_flags flags;
9685
9686         memset(&flags, 0, sizeof(flags));
9687
9688         flags.stats_success = true;
9689
9690         return test_ipsec_proto_all(&flags);
9691 }
9692
9693 static int
9694 test_ipsec_proto_pkt_fragment(const void *data __rte_unused)
9695 {
9696         struct ipsec_test_flags flags;
9697
9698         memset(&flags, 0, sizeof(flags));
9699
9700         flags.fragment = true;
9701
9702         return test_ipsec_proto_all(&flags);
9703 }
9704
9705 static int
9706 test_PDCP_PROTO_all(void)
9707 {
9708         struct crypto_testsuite_params *ts_params = &testsuite_params;
9709         struct crypto_unittest_params *ut_params = &unittest_params;
9710         struct rte_cryptodev_info dev_info;
9711         int status;
9712
9713         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
9714         uint64_t feat_flags = dev_info.feature_flags;
9715
9716         if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY))
9717                 return TEST_SKIPPED;
9718
9719         /* Set action type */
9720         ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
9721                 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
9722                 gbl_action_type;
9723
9724         if (security_proto_supported(ut_params->type,
9725                         RTE_SECURITY_PROTOCOL_PDCP) < 0)
9726                 return TEST_SKIPPED;
9727
9728         status = test_PDCP_PROTO_cplane_encap_all();
9729         status += test_PDCP_PROTO_cplane_decap_all();
9730         status += test_PDCP_PROTO_uplane_encap_all();
9731         status += test_PDCP_PROTO_uplane_decap_all();
9732         status += test_PDCP_PROTO_SGL_in_place_32B();
9733         status += test_PDCP_PROTO_SGL_oop_32B_128B();
9734         status += test_PDCP_PROTO_SGL_oop_32B_40B();
9735         status += test_PDCP_PROTO_SGL_oop_128B_32B();
9736         status += test_PDCP_SDAP_PROTO_encap_all();
9737         status += test_PDCP_SDAP_PROTO_decap_all();
9738         status += test_PDCP_PROTO_short_mac();
9739
9740         if (status)
9741                 return TEST_FAILED;
9742         else
9743                 return TEST_SUCCESS;
9744 }
9745
9746 static int
9747 test_docsis_proto_uplink(const void *data)
9748 {
9749         const struct docsis_test_data *d_td = data;
9750         struct crypto_testsuite_params *ts_params = &testsuite_params;
9751         struct crypto_unittest_params *ut_params = &unittest_params;
9752         uint8_t *plaintext = NULL;
9753         uint8_t *ciphertext = NULL;
9754         uint8_t *iv_ptr;
9755         int32_t cipher_len, crc_len;
9756         uint32_t crc_data_len;
9757         int ret = TEST_SUCCESS;
9758
9759         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
9760                                         rte_cryptodev_get_sec_ctx(
9761                                                 ts_params->valid_devs[0]);
9762
9763         /* Verify the capabilities */
9764         struct rte_security_capability_idx sec_cap_idx;
9765         const struct rte_security_capability *sec_cap;
9766         const struct rte_cryptodev_capabilities *crypto_cap;
9767         const struct rte_cryptodev_symmetric_capability *sym_cap;
9768         int j = 0;
9769
9770         /* Set action type */
9771         ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
9772                 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
9773                 gbl_action_type;
9774
9775         if (security_proto_supported(ut_params->type,
9776                         RTE_SECURITY_PROTOCOL_DOCSIS) < 0)
9777                 return TEST_SKIPPED;
9778
9779         sec_cap_idx.action = ut_params->type;
9780         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
9781         sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_UPLINK;
9782
9783         sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
9784         if (sec_cap == NULL)
9785                 return TEST_SKIPPED;
9786
9787         while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
9788                         RTE_CRYPTO_OP_TYPE_UNDEFINED) {
9789                 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
9790                                 crypto_cap->sym.xform_type ==
9791                                         RTE_CRYPTO_SYM_XFORM_CIPHER &&
9792                                 crypto_cap->sym.cipher.algo ==
9793                                         RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
9794                         sym_cap = &crypto_cap->sym;
9795                         if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
9796                                                 d_td->key.len,
9797                                                 d_td->iv.len) == 0)
9798                                 break;
9799                 }
9800         }
9801
9802         if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
9803                 return TEST_SKIPPED;
9804
9805         /* Setup source mbuf payload */
9806         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9807         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9808                         rte_pktmbuf_tailroom(ut_params->ibuf));
9809
9810         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9811                         d_td->ciphertext.len);
9812
9813         memcpy(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len);
9814
9815         /* Setup cipher session parameters */
9816         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
9817         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
9818         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
9819         ut_params->cipher_xform.cipher.key.data = d_td->key.data;
9820         ut_params->cipher_xform.cipher.key.length = d_td->key.len;
9821         ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
9822         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
9823         ut_params->cipher_xform.next = NULL;
9824
9825         /* Setup DOCSIS session parameters */
9826         ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_UPLINK;
9827
9828         struct rte_security_session_conf sess_conf = {
9829                 .action_type = ut_params->type,
9830                 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
9831                 .docsis = ut_params->docsis_xform,
9832                 .crypto_xform = &ut_params->cipher_xform,
9833         };
9834
9835         /* Create security session */
9836         ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
9837                                         ts_params->session_mpool,
9838                                         ts_params->session_priv_mpool);
9839
9840         if (!ut_params->sec_session) {
9841                 printf("Test function %s line %u: failed to allocate session\n",
9842                         __func__, __LINE__);
9843                 ret = TEST_FAILED;
9844                 goto on_err;
9845         }
9846
9847         /* Generate crypto op data structure */
9848         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9849                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9850         if (!ut_params->op) {
9851                 printf("Test function %s line %u: failed to allocate symmetric "
9852                         "crypto operation\n", __func__, __LINE__);
9853                 ret = TEST_FAILED;
9854                 goto on_err;
9855         }
9856
9857         /* Setup CRC operation parameters */
9858         crc_len = d_td->ciphertext.no_crc == false ?
9859                         (d_td->ciphertext.len -
9860                                 d_td->ciphertext.crc_offset -
9861                                 RTE_ETHER_CRC_LEN) :
9862                         0;
9863         crc_len = crc_len > 0 ? crc_len : 0;
9864         crc_data_len = crc_len == 0 ? 0 : RTE_ETHER_CRC_LEN;
9865         ut_params->op->sym->auth.data.length = crc_len;
9866         ut_params->op->sym->auth.data.offset = d_td->ciphertext.crc_offset;
9867
9868         /* Setup cipher operation parameters */
9869         cipher_len = d_td->ciphertext.no_cipher == false ?
9870                         (d_td->ciphertext.len -
9871                                 d_td->ciphertext.cipher_offset) :
9872                         0;
9873         cipher_len = cipher_len > 0 ? cipher_len : 0;
9874         ut_params->op->sym->cipher.data.length = cipher_len;
9875         ut_params->op->sym->cipher.data.offset = d_td->ciphertext.cipher_offset;
9876
9877         /* Setup cipher IV */
9878         iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
9879         rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
9880
9881         /* Attach session to operation */
9882         rte_security_attach_session(ut_params->op, ut_params->sec_session);
9883
9884         /* Set crypto operation mbufs */
9885         ut_params->op->sym->m_src = ut_params->ibuf;
9886         ut_params->op->sym->m_dst = NULL;
9887
9888         /* Process crypto operation */
9889         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
9890                         NULL) {
9891                 printf("Test function %s line %u: failed to process security "
9892                         "crypto op\n", __func__, __LINE__);
9893                 ret = TEST_FAILED;
9894                 goto on_err;
9895         }
9896
9897         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
9898                 printf("Test function %s line %u: failed to process crypto op\n",
9899                         __func__, __LINE__);
9900                 ret = TEST_FAILED;
9901                 goto on_err;
9902         }
9903
9904         /* Validate plaintext */
9905         plaintext = ciphertext;
9906
9907         if (memcmp(plaintext, d_td->plaintext.data,
9908                         d_td->plaintext.len - crc_data_len)) {
9909                 printf("Test function %s line %u: plaintext not as expected\n",
9910                         __func__, __LINE__);
9911                 rte_hexdump(stdout, "expected", d_td->plaintext.data,
9912                                 d_td->plaintext.len);
9913                 rte_hexdump(stdout, "actual", plaintext, d_td->plaintext.len);
9914                 ret = TEST_FAILED;
9915                 goto on_err;
9916         }
9917
9918 on_err:
9919         rte_crypto_op_free(ut_params->op);
9920         ut_params->op = NULL;
9921
9922         if (ut_params->sec_session)
9923                 rte_security_session_destroy(ctx, ut_params->sec_session);
9924         ut_params->sec_session = NULL;
9925
9926         rte_pktmbuf_free(ut_params->ibuf);
9927         ut_params->ibuf = NULL;
9928
9929         return ret;
9930 }
9931
9932 static int
9933 test_docsis_proto_downlink(const void *data)
9934 {
9935         const struct docsis_test_data *d_td = data;
9936         struct crypto_testsuite_params *ts_params = &testsuite_params;
9937         struct crypto_unittest_params *ut_params = &unittest_params;
9938         uint8_t *plaintext = NULL;
9939         uint8_t *ciphertext = NULL;
9940         uint8_t *iv_ptr;
9941         int32_t cipher_len, crc_len;
9942         int ret = TEST_SUCCESS;
9943
9944         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
9945                                         rte_cryptodev_get_sec_ctx(
9946                                                 ts_params->valid_devs[0]);
9947
9948         /* Verify the capabilities */
9949         struct rte_security_capability_idx sec_cap_idx;
9950         const struct rte_security_capability *sec_cap;
9951         const struct rte_cryptodev_capabilities *crypto_cap;
9952         const struct rte_cryptodev_symmetric_capability *sym_cap;
9953         int j = 0;
9954
9955         /* Set action type */
9956         ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
9957                 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
9958                 gbl_action_type;
9959
9960         if (security_proto_supported(ut_params->type,
9961                         RTE_SECURITY_PROTOCOL_DOCSIS) < 0)
9962                 return TEST_SKIPPED;
9963
9964         sec_cap_idx.action = ut_params->type;
9965         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
9966         sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
9967
9968         sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
9969         if (sec_cap == NULL)
9970                 return TEST_SKIPPED;
9971
9972         while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
9973                         RTE_CRYPTO_OP_TYPE_UNDEFINED) {
9974                 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
9975                                 crypto_cap->sym.xform_type ==
9976                                         RTE_CRYPTO_SYM_XFORM_CIPHER &&
9977                                 crypto_cap->sym.cipher.algo ==
9978                                         RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
9979                         sym_cap = &crypto_cap->sym;
9980                         if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
9981                                                 d_td->key.len,
9982                                                 d_td->iv.len) == 0)
9983                                 break;
9984                 }
9985         }
9986
9987         if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
9988                 return TEST_SKIPPED;
9989
9990         /* Setup source mbuf payload */
9991         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9992         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9993                         rte_pktmbuf_tailroom(ut_params->ibuf));
9994
9995         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9996                         d_td->plaintext.len);
9997
9998         memcpy(plaintext, d_td->plaintext.data, d_td->plaintext.len);
9999
10000         /* Setup cipher session parameters */
10001         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10002         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
10003         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
10004         ut_params->cipher_xform.cipher.key.data = d_td->key.data;
10005         ut_params->cipher_xform.cipher.key.length = d_td->key.len;
10006         ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
10007         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
10008         ut_params->cipher_xform.next = NULL;
10009
10010         /* Setup DOCSIS session parameters */
10011         ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
10012
10013         struct rte_security_session_conf sess_conf = {
10014                 .action_type = ut_params->type,
10015                 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
10016                 .docsis = ut_params->docsis_xform,
10017                 .crypto_xform = &ut_params->cipher_xform,
10018         };
10019
10020         /* Create security session */
10021         ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
10022                                         ts_params->session_mpool,
10023                                         ts_params->session_priv_mpool);
10024
10025         if (!ut_params->sec_session) {
10026                 printf("Test function %s line %u: failed to allocate session\n",
10027                         __func__, __LINE__);
10028                 ret = TEST_FAILED;
10029                 goto on_err;
10030         }
10031
10032         /* Generate crypto op data structure */
10033         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10034                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10035         if (!ut_params->op) {
10036                 printf("Test function %s line %u: failed to allocate symmetric "
10037                         "crypto operation\n", __func__, __LINE__);
10038                 ret = TEST_FAILED;
10039                 goto on_err;
10040         }
10041
10042         /* Setup CRC operation parameters */
10043         crc_len = d_td->plaintext.no_crc == false ?
10044                         (d_td->plaintext.len -
10045                                 d_td->plaintext.crc_offset -
10046                                 RTE_ETHER_CRC_LEN) :
10047                         0;
10048         crc_len = crc_len > 0 ? crc_len : 0;
10049         ut_params->op->sym->auth.data.length = crc_len;
10050         ut_params->op->sym->auth.data.offset = d_td->plaintext.crc_offset;
10051
10052         /* Setup cipher operation parameters */
10053         cipher_len = d_td->plaintext.no_cipher == false ?
10054                         (d_td->plaintext.len -
10055                                 d_td->plaintext.cipher_offset) :
10056                         0;
10057         cipher_len = cipher_len > 0 ? cipher_len : 0;
10058         ut_params->op->sym->cipher.data.length = cipher_len;
10059         ut_params->op->sym->cipher.data.offset = d_td->plaintext.cipher_offset;
10060
10061         /* Setup cipher IV */
10062         iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
10063         rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
10064
10065         /* Attach session to operation */
10066         rte_security_attach_session(ut_params->op, ut_params->sec_session);
10067
10068         /* Set crypto operation mbufs */
10069         ut_params->op->sym->m_src = ut_params->ibuf;
10070         ut_params->op->sym->m_dst = NULL;
10071
10072         /* Process crypto operation */
10073         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
10074                         NULL) {
10075                 printf("Test function %s line %u: failed to process crypto op\n",
10076                         __func__, __LINE__);
10077                 ret = TEST_FAILED;
10078                 goto on_err;
10079         }
10080
10081         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
10082                 printf("Test function %s line %u: crypto op processing failed\n",
10083                         __func__, __LINE__);
10084                 ret = TEST_FAILED;
10085                 goto on_err;
10086         }
10087
10088         /* Validate ciphertext */
10089         ciphertext = plaintext;
10090
10091         if (memcmp(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len)) {
10092                 printf("Test function %s line %u: plaintext not as expected\n",
10093                         __func__, __LINE__);
10094                 rte_hexdump(stdout, "expected", d_td->ciphertext.data,
10095                                 d_td->ciphertext.len);
10096                 rte_hexdump(stdout, "actual", ciphertext, d_td->ciphertext.len);
10097                 ret = TEST_FAILED;
10098                 goto on_err;
10099         }
10100
10101 on_err:
10102         rte_crypto_op_free(ut_params->op);
10103         ut_params->op = NULL;
10104
10105         if (ut_params->sec_session)
10106                 rte_security_session_destroy(ctx, ut_params->sec_session);
10107         ut_params->sec_session = NULL;
10108
10109         rte_pktmbuf_free(ut_params->ibuf);
10110         ut_params->ibuf = NULL;
10111
10112         return ret;
10113 }
10114 #endif
10115
10116 static int
10117 test_AES_GCM_authenticated_encryption_test_case_1(void)
10118 {
10119         return test_authenticated_encryption(&gcm_test_case_1);
10120 }
10121
10122 static int
10123 test_AES_GCM_authenticated_encryption_test_case_2(void)
10124 {
10125         return test_authenticated_encryption(&gcm_test_case_2);
10126 }
10127
10128 static int
10129 test_AES_GCM_authenticated_encryption_test_case_3(void)
10130 {
10131         return test_authenticated_encryption(&gcm_test_case_3);
10132 }
10133
10134 static int
10135 test_AES_GCM_authenticated_encryption_test_case_4(void)
10136 {
10137         return test_authenticated_encryption(&gcm_test_case_4);
10138 }
10139
10140 static int
10141 test_AES_GCM_authenticated_encryption_test_case_5(void)
10142 {
10143         return test_authenticated_encryption(&gcm_test_case_5);
10144 }
10145
10146 static int
10147 test_AES_GCM_authenticated_encryption_test_case_6(void)
10148 {
10149         return test_authenticated_encryption(&gcm_test_case_6);
10150 }
10151
10152 static int
10153 test_AES_GCM_authenticated_encryption_test_case_7(void)
10154 {
10155         return test_authenticated_encryption(&gcm_test_case_7);
10156 }
10157
10158 static int
10159 test_AES_GCM_authenticated_encryption_test_case_8(void)
10160 {
10161         return test_authenticated_encryption(&gcm_test_case_8);
10162 }
10163
10164 static int
10165 test_AES_GCM_J0_authenticated_encryption_test_case_1(void)
10166 {
10167         return test_authenticated_encryption(&gcm_J0_test_case_1);
10168 }
10169
10170 static int
10171 test_AES_GCM_auth_encryption_test_case_192_1(void)
10172 {
10173         return test_authenticated_encryption(&gcm_test_case_192_1);
10174 }
10175
10176 static int
10177 test_AES_GCM_auth_encryption_test_case_192_2(void)
10178 {
10179         return test_authenticated_encryption(&gcm_test_case_192_2);
10180 }
10181
10182 static int
10183 test_AES_GCM_auth_encryption_test_case_192_3(void)
10184 {
10185         return test_authenticated_encryption(&gcm_test_case_192_3);
10186 }
10187
10188 static int
10189 test_AES_GCM_auth_encryption_test_case_192_4(void)
10190 {
10191         return test_authenticated_encryption(&gcm_test_case_192_4);
10192 }
10193
10194 static int
10195 test_AES_GCM_auth_encryption_test_case_192_5(void)
10196 {
10197         return test_authenticated_encryption(&gcm_test_case_192_5);
10198 }
10199
10200 static int
10201 test_AES_GCM_auth_encryption_test_case_192_6(void)
10202 {
10203         return test_authenticated_encryption(&gcm_test_case_192_6);
10204 }
10205
10206 static int
10207 test_AES_GCM_auth_encryption_test_case_192_7(void)
10208 {
10209         return test_authenticated_encryption(&gcm_test_case_192_7);
10210 }
10211
10212 static int
10213 test_AES_GCM_auth_encryption_test_case_256_1(void)
10214 {
10215         return test_authenticated_encryption(&gcm_test_case_256_1);
10216 }
10217
10218 static int
10219 test_AES_GCM_auth_encryption_test_case_256_2(void)
10220 {
10221         return test_authenticated_encryption(&gcm_test_case_256_2);
10222 }
10223
10224 static int
10225 test_AES_GCM_auth_encryption_test_case_256_3(void)
10226 {
10227         return test_authenticated_encryption(&gcm_test_case_256_3);
10228 }
10229
10230 static int
10231 test_AES_GCM_auth_encryption_test_case_256_4(void)
10232 {
10233         return test_authenticated_encryption(&gcm_test_case_256_4);
10234 }
10235
10236 static int
10237 test_AES_GCM_auth_encryption_test_case_256_5(void)
10238 {
10239         return test_authenticated_encryption(&gcm_test_case_256_5);
10240 }
10241
10242 static int
10243 test_AES_GCM_auth_encryption_test_case_256_6(void)
10244 {
10245         return test_authenticated_encryption(&gcm_test_case_256_6);
10246 }
10247
10248 static int
10249 test_AES_GCM_auth_encryption_test_case_256_7(void)
10250 {
10251         return test_authenticated_encryption(&gcm_test_case_256_7);
10252 }
10253
10254 static int
10255 test_AES_GCM_auth_encryption_test_case_aad_1(void)
10256 {
10257         return test_authenticated_encryption(&gcm_test_case_aad_1);
10258 }
10259
10260 static int
10261 test_AES_GCM_auth_encryption_test_case_aad_2(void)
10262 {
10263         return test_authenticated_encryption(&gcm_test_case_aad_2);
10264 }
10265
10266 static int
10267 test_AES_GCM_auth_encryption_fail_iv_corrupt(void)
10268 {
10269         struct aead_test_data tdata;
10270         int res;
10271
10272         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10273         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10274         tdata.iv.data[0] += 1;
10275         res = test_authenticated_encryption(&tdata);
10276         if (res == TEST_SKIPPED)
10277                 return res;
10278         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10279         return TEST_SUCCESS;
10280 }
10281
10282 static int
10283 test_AES_GCM_auth_encryption_fail_in_data_corrupt(void)
10284 {
10285         struct aead_test_data tdata;
10286         int res;
10287
10288         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10289         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10290         tdata.plaintext.data[0] += 1;
10291         res = test_authenticated_encryption(&tdata);
10292         if (res == TEST_SKIPPED)
10293                 return res;
10294         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10295         return TEST_SUCCESS;
10296 }
10297
10298 static int
10299 test_AES_GCM_auth_encryption_fail_out_data_corrupt(void)
10300 {
10301         struct aead_test_data tdata;
10302         int res;
10303
10304         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10305         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10306         tdata.ciphertext.data[0] += 1;
10307         res = test_authenticated_encryption(&tdata);
10308         if (res == TEST_SKIPPED)
10309                 return res;
10310         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10311         return TEST_SUCCESS;
10312 }
10313
10314 static int
10315 test_AES_GCM_auth_encryption_fail_aad_len_corrupt(void)
10316 {
10317         struct aead_test_data tdata;
10318         int res;
10319
10320         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10321         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10322         tdata.aad.len += 1;
10323         res = test_authenticated_encryption(&tdata);
10324         if (res == TEST_SKIPPED)
10325                 return res;
10326         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10327         return TEST_SUCCESS;
10328 }
10329
10330 static int
10331 test_AES_GCM_auth_encryption_fail_aad_corrupt(void)
10332 {
10333         struct aead_test_data tdata;
10334         uint8_t aad[gcm_test_case_7.aad.len];
10335         int res;
10336
10337         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10338         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10339         memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
10340         aad[0] += 1;
10341         tdata.aad.data = aad;
10342         res = test_authenticated_encryption(&tdata);
10343         if (res == TEST_SKIPPED)
10344                 return res;
10345         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10346         return TEST_SUCCESS;
10347 }
10348
10349 static int
10350 test_AES_GCM_auth_encryption_fail_tag_corrupt(void)
10351 {
10352         struct aead_test_data tdata;
10353         int res;
10354
10355         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10356         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10357         tdata.auth_tag.data[0] += 1;
10358         res = test_authenticated_encryption(&tdata);
10359         if (res == TEST_SKIPPED)
10360                 return res;
10361         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10362         return TEST_SUCCESS;
10363 }
10364
10365 static int
10366 test_authenticated_decryption(const struct aead_test_data *tdata)
10367 {
10368         struct crypto_testsuite_params *ts_params = &testsuite_params;
10369         struct crypto_unittest_params *ut_params = &unittest_params;
10370
10371         int retval;
10372         uint8_t *plaintext;
10373         uint32_t i;
10374         struct rte_cryptodev_info dev_info;
10375
10376         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10377         uint64_t feat_flags = dev_info.feature_flags;
10378
10379         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10380                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10381                 printf("Device doesn't support RAW data-path APIs.\n");
10382                 return TEST_SKIPPED;
10383         }
10384
10385         /* Verify the capabilities */
10386         struct rte_cryptodev_sym_capability_idx cap_idx;
10387         const struct rte_cryptodev_symmetric_capability *capability;
10388         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10389         cap_idx.algo.aead = tdata->algo;
10390         capability = rte_cryptodev_sym_capability_get(
10391                         ts_params->valid_devs[0], &cap_idx);
10392         if (capability == NULL)
10393                 return TEST_SKIPPED;
10394         if (rte_cryptodev_sym_capability_check_aead(
10395                         capability, tdata->key.len, tdata->auth_tag.len,
10396                         tdata->aad.len, tdata->iv.len))
10397                 return TEST_SKIPPED;
10398
10399         /* Create AEAD session */
10400         retval = create_aead_session(ts_params->valid_devs[0],
10401                         tdata->algo,
10402                         RTE_CRYPTO_AEAD_OP_DECRYPT,
10403                         tdata->key.data, tdata->key.len,
10404                         tdata->aad.len, tdata->auth_tag.len,
10405                         tdata->iv.len);
10406         if (retval < 0)
10407                 return retval;
10408
10409         /* alloc mbuf and set payload */
10410         if (tdata->aad.len > MBUF_SIZE) {
10411                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
10412                 /* Populate full size of add data */
10413                 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
10414                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
10415         } else
10416                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10417
10418         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10419                         rte_pktmbuf_tailroom(ut_params->ibuf));
10420
10421         /* Create AEAD operation */
10422         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
10423         if (retval < 0)
10424                 return retval;
10425
10426         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10427
10428         ut_params->op->sym->m_src = ut_params->ibuf;
10429
10430         /* Process crypto operation */
10431         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10432                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
10433         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10434                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10435                                 ut_params->op, 0, 0, 0, 0);
10436         else
10437                 TEST_ASSERT_NOT_NULL(
10438                         process_crypto_request(ts_params->valid_devs[0],
10439                         ut_params->op), "failed to process sym crypto op");
10440
10441         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10442                         "crypto op processing failed");
10443
10444         if (ut_params->op->sym->m_dst)
10445                 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
10446                                 uint8_t *);
10447         else
10448                 plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
10449                                 uint8_t *,
10450                                 ut_params->op->sym->cipher.data.offset);
10451
10452         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
10453
10454         /* Validate obuf */
10455         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10456                         plaintext,
10457                         tdata->plaintext.data,
10458                         tdata->plaintext.len,
10459                         "Plaintext data not as expected");
10460
10461         TEST_ASSERT_EQUAL(ut_params->op->status,
10462                         RTE_CRYPTO_OP_STATUS_SUCCESS,
10463                         "Authentication failed");
10464
10465         return 0;
10466 }
10467
10468 static int
10469 test_AES_GCM_authenticated_decryption_test_case_1(void)
10470 {
10471         return test_authenticated_decryption(&gcm_test_case_1);
10472 }
10473
10474 static int
10475 test_AES_GCM_authenticated_decryption_test_case_2(void)
10476 {
10477         return test_authenticated_decryption(&gcm_test_case_2);
10478 }
10479
10480 static int
10481 test_AES_GCM_authenticated_decryption_test_case_3(void)
10482 {
10483         return test_authenticated_decryption(&gcm_test_case_3);
10484 }
10485
10486 static int
10487 test_AES_GCM_authenticated_decryption_test_case_4(void)
10488 {
10489         return test_authenticated_decryption(&gcm_test_case_4);
10490 }
10491
10492 static int
10493 test_AES_GCM_authenticated_decryption_test_case_5(void)
10494 {
10495         return test_authenticated_decryption(&gcm_test_case_5);
10496 }
10497
10498 static int
10499 test_AES_GCM_authenticated_decryption_test_case_6(void)
10500 {
10501         return test_authenticated_decryption(&gcm_test_case_6);
10502 }
10503
10504 static int
10505 test_AES_GCM_authenticated_decryption_test_case_7(void)
10506 {
10507         return test_authenticated_decryption(&gcm_test_case_7);
10508 }
10509
10510 static int
10511 test_AES_GCM_authenticated_decryption_test_case_8(void)
10512 {
10513         return test_authenticated_decryption(&gcm_test_case_8);
10514 }
10515
10516 static int
10517 test_AES_GCM_J0_authenticated_decryption_test_case_1(void)
10518 {
10519         return test_authenticated_decryption(&gcm_J0_test_case_1);
10520 }
10521
10522 static int
10523 test_AES_GCM_auth_decryption_test_case_192_1(void)
10524 {
10525         return test_authenticated_decryption(&gcm_test_case_192_1);
10526 }
10527
10528 static int
10529 test_AES_GCM_auth_decryption_test_case_192_2(void)
10530 {
10531         return test_authenticated_decryption(&gcm_test_case_192_2);
10532 }
10533
10534 static int
10535 test_AES_GCM_auth_decryption_test_case_192_3(void)
10536 {
10537         return test_authenticated_decryption(&gcm_test_case_192_3);
10538 }
10539
10540 static int
10541 test_AES_GCM_auth_decryption_test_case_192_4(void)
10542 {
10543         return test_authenticated_decryption(&gcm_test_case_192_4);
10544 }
10545
10546 static int
10547 test_AES_GCM_auth_decryption_test_case_192_5(void)
10548 {
10549         return test_authenticated_decryption(&gcm_test_case_192_5);
10550 }
10551
10552 static int
10553 test_AES_GCM_auth_decryption_test_case_192_6(void)
10554 {
10555         return test_authenticated_decryption(&gcm_test_case_192_6);
10556 }
10557
10558 static int
10559 test_AES_GCM_auth_decryption_test_case_192_7(void)
10560 {
10561         return test_authenticated_decryption(&gcm_test_case_192_7);
10562 }
10563
10564 static int
10565 test_AES_GCM_auth_decryption_test_case_256_1(void)
10566 {
10567         return test_authenticated_decryption(&gcm_test_case_256_1);
10568 }
10569
10570 static int
10571 test_AES_GCM_auth_decryption_test_case_256_2(void)
10572 {
10573         return test_authenticated_decryption(&gcm_test_case_256_2);
10574 }
10575
10576 static int
10577 test_AES_GCM_auth_decryption_test_case_256_3(void)
10578 {
10579         return test_authenticated_decryption(&gcm_test_case_256_3);
10580 }
10581
10582 static int
10583 test_AES_GCM_auth_decryption_test_case_256_4(void)
10584 {
10585         return test_authenticated_decryption(&gcm_test_case_256_4);
10586 }
10587
10588 static int
10589 test_AES_GCM_auth_decryption_test_case_256_5(void)
10590 {
10591         return test_authenticated_decryption(&gcm_test_case_256_5);
10592 }
10593
10594 static int
10595 test_AES_GCM_auth_decryption_test_case_256_6(void)
10596 {
10597         return test_authenticated_decryption(&gcm_test_case_256_6);
10598 }
10599
10600 static int
10601 test_AES_GCM_auth_decryption_test_case_256_7(void)
10602 {
10603         return test_authenticated_decryption(&gcm_test_case_256_7);
10604 }
10605
10606 static int
10607 test_AES_GCM_auth_decryption_test_case_aad_1(void)
10608 {
10609         return test_authenticated_decryption(&gcm_test_case_aad_1);
10610 }
10611
10612 static int
10613 test_AES_GCM_auth_decryption_test_case_aad_2(void)
10614 {
10615         return test_authenticated_decryption(&gcm_test_case_aad_2);
10616 }
10617
10618 static int
10619 test_AES_GCM_auth_decryption_fail_iv_corrupt(void)
10620 {
10621         struct aead_test_data tdata;
10622         int res;
10623
10624         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10625         tdata.iv.data[0] += 1;
10626         res = test_authenticated_decryption(&tdata);
10627         if (res == TEST_SKIPPED)
10628                 return res;
10629         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10630         return TEST_SUCCESS;
10631 }
10632
10633 static int
10634 test_AES_GCM_auth_decryption_fail_in_data_corrupt(void)
10635 {
10636         struct aead_test_data tdata;
10637         int res;
10638
10639         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10640         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10641         tdata.plaintext.data[0] += 1;
10642         res = test_authenticated_decryption(&tdata);
10643         if (res == TEST_SKIPPED)
10644                 return res;
10645         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10646         return TEST_SUCCESS;
10647 }
10648
10649 static int
10650 test_AES_GCM_auth_decryption_fail_out_data_corrupt(void)
10651 {
10652         struct aead_test_data tdata;
10653         int res;
10654
10655         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10656         tdata.ciphertext.data[0] += 1;
10657         res = test_authenticated_decryption(&tdata);
10658         if (res == TEST_SKIPPED)
10659                 return res;
10660         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10661         return TEST_SUCCESS;
10662 }
10663
10664 static int
10665 test_AES_GCM_auth_decryption_fail_aad_len_corrupt(void)
10666 {
10667         struct aead_test_data tdata;
10668         int res;
10669
10670         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10671         tdata.aad.len += 1;
10672         res = test_authenticated_decryption(&tdata);
10673         if (res == TEST_SKIPPED)
10674                 return res;
10675         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10676         return TEST_SUCCESS;
10677 }
10678
10679 static int
10680 test_AES_GCM_auth_decryption_fail_aad_corrupt(void)
10681 {
10682         struct aead_test_data tdata;
10683         uint8_t aad[gcm_test_case_7.aad.len];
10684         int res;
10685
10686         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10687         memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
10688         aad[0] += 1;
10689         tdata.aad.data = aad;
10690         res = test_authenticated_decryption(&tdata);
10691         if (res == TEST_SKIPPED)
10692                 return res;
10693         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10694         return TEST_SUCCESS;
10695 }
10696
10697 static int
10698 test_AES_GCM_auth_decryption_fail_tag_corrupt(void)
10699 {
10700         struct aead_test_data tdata;
10701         int res;
10702
10703         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10704         tdata.auth_tag.data[0] += 1;
10705         res = test_authenticated_decryption(&tdata);
10706         if (res == TEST_SKIPPED)
10707                 return res;
10708         TEST_ASSERT_EQUAL(res, TEST_FAILED, "authentication not failed");
10709         return TEST_SUCCESS;
10710 }
10711
10712 static int
10713 test_authenticated_encryption_oop(const struct aead_test_data *tdata)
10714 {
10715         struct crypto_testsuite_params *ts_params = &testsuite_params;
10716         struct crypto_unittest_params *ut_params = &unittest_params;
10717
10718         int retval;
10719         uint8_t *ciphertext, *auth_tag;
10720         uint16_t plaintext_pad_len;
10721         struct rte_cryptodev_info dev_info;
10722
10723         /* Verify the capabilities */
10724         struct rte_cryptodev_sym_capability_idx cap_idx;
10725         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10726         cap_idx.algo.aead = tdata->algo;
10727         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10728                         &cap_idx) == NULL)
10729                 return TEST_SKIPPED;
10730
10731         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10732         uint64_t feat_flags = dev_info.feature_flags;
10733
10734         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10735                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP)))
10736                 return TEST_SKIPPED;
10737
10738         /* not supported with CPU crypto */
10739         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10740                 return TEST_SKIPPED;
10741
10742         /* Create AEAD session */
10743         retval = create_aead_session(ts_params->valid_devs[0],
10744                         tdata->algo,
10745                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
10746                         tdata->key.data, tdata->key.len,
10747                         tdata->aad.len, tdata->auth_tag.len,
10748                         tdata->iv.len);
10749         if (retval < 0)
10750                 return retval;
10751
10752         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10753         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10754
10755         /* clear mbuf payload */
10756         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10757                         rte_pktmbuf_tailroom(ut_params->ibuf));
10758         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
10759                         rte_pktmbuf_tailroom(ut_params->obuf));
10760
10761         /* Create AEAD operation */
10762         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
10763         if (retval < 0)
10764                 return retval;
10765
10766         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10767
10768         ut_params->op->sym->m_src = ut_params->ibuf;
10769         ut_params->op->sym->m_dst = ut_params->obuf;
10770
10771         /* Process crypto operation */
10772         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10773                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10774                         ut_params->op, 0, 0, 0, 0);
10775         else
10776                 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
10777                         ut_params->op), "failed to process sym crypto op");
10778
10779         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10780                         "crypto op processing failed");
10781
10782         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
10783
10784         ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
10785                         ut_params->op->sym->cipher.data.offset);
10786         auth_tag = ciphertext + plaintext_pad_len;
10787
10788         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
10789         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
10790
10791         /* Validate obuf */
10792         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10793                         ciphertext,
10794                         tdata->ciphertext.data,
10795                         tdata->ciphertext.len,
10796                         "Ciphertext data not as expected");
10797
10798         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10799                         auth_tag,
10800                         tdata->auth_tag.data,
10801                         tdata->auth_tag.len,
10802                         "Generated auth tag not as expected");
10803
10804         return 0;
10805
10806 }
10807
10808 static int
10809 test_AES_GCM_authenticated_encryption_oop_test_case_1(void)
10810 {
10811         return test_authenticated_encryption_oop(&gcm_test_case_5);
10812 }
10813
10814 static int
10815 test_authenticated_decryption_oop(const struct aead_test_data *tdata)
10816 {
10817         struct crypto_testsuite_params *ts_params = &testsuite_params;
10818         struct crypto_unittest_params *ut_params = &unittest_params;
10819
10820         int retval;
10821         uint8_t *plaintext;
10822         struct rte_cryptodev_info dev_info;
10823
10824         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10825         uint64_t feat_flags = dev_info.feature_flags;
10826
10827         /* Verify the capabilities */
10828         struct rte_cryptodev_sym_capability_idx cap_idx;
10829         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10830         cap_idx.algo.aead = tdata->algo;
10831         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10832                         &cap_idx) == NULL)
10833                 return TEST_SKIPPED;
10834
10835         /* not supported with CPU crypto and raw data-path APIs*/
10836         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO ||
10837                         global_api_test_type == CRYPTODEV_RAW_API_TEST)
10838                 return TEST_SKIPPED;
10839
10840         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10841                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10842                 printf("Device does not support RAW data-path APIs.\n");
10843                 return TEST_SKIPPED;
10844         }
10845
10846         /* Create AEAD session */
10847         retval = create_aead_session(ts_params->valid_devs[0],
10848                         tdata->algo,
10849                         RTE_CRYPTO_AEAD_OP_DECRYPT,
10850                         tdata->key.data, tdata->key.len,
10851                         tdata->aad.len, tdata->auth_tag.len,
10852                         tdata->iv.len);
10853         if (retval < 0)
10854                 return retval;
10855
10856         /* alloc mbuf and set payload */
10857         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10858         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10859
10860         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10861                         rte_pktmbuf_tailroom(ut_params->ibuf));
10862         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
10863                         rte_pktmbuf_tailroom(ut_params->obuf));
10864
10865         /* Create AEAD operation */
10866         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
10867         if (retval < 0)
10868                 return retval;
10869
10870         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10871
10872         ut_params->op->sym->m_src = ut_params->ibuf;
10873         ut_params->op->sym->m_dst = ut_params->obuf;
10874
10875         /* Process crypto operation */
10876         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10877                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10878                                 ut_params->op, 0, 0, 0, 0);
10879         else
10880                 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
10881                         ut_params->op), "failed to process sym crypto op");
10882
10883         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10884                         "crypto op processing failed");
10885
10886         plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
10887                         ut_params->op->sym->cipher.data.offset);
10888
10889         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
10890
10891         /* Validate obuf */
10892         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10893                         plaintext,
10894                         tdata->plaintext.data,
10895                         tdata->plaintext.len,
10896                         "Plaintext data not as expected");
10897
10898         TEST_ASSERT_EQUAL(ut_params->op->status,
10899                         RTE_CRYPTO_OP_STATUS_SUCCESS,
10900                         "Authentication failed");
10901         return 0;
10902 }
10903
10904 static int
10905 test_AES_GCM_authenticated_decryption_oop_test_case_1(void)
10906 {
10907         return test_authenticated_decryption_oop(&gcm_test_case_5);
10908 }
10909
10910 static int
10911 test_authenticated_encryption_sessionless(
10912                 const struct aead_test_data *tdata)
10913 {
10914         struct crypto_testsuite_params *ts_params = &testsuite_params;
10915         struct crypto_unittest_params *ut_params = &unittest_params;
10916
10917         int retval;
10918         uint8_t *ciphertext, *auth_tag;
10919         uint16_t plaintext_pad_len;
10920         uint8_t key[tdata->key.len + 1];
10921         struct rte_cryptodev_info dev_info;
10922
10923         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10924         uint64_t feat_flags = dev_info.feature_flags;
10925
10926         if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
10927                 printf("Device doesn't support Sessionless ops.\n");
10928                 return TEST_SKIPPED;
10929         }
10930
10931         /* not supported with CPU crypto */
10932         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10933                 return TEST_SKIPPED;
10934
10935         /* Verify the capabilities */
10936         struct rte_cryptodev_sym_capability_idx cap_idx;
10937         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10938         cap_idx.algo.aead = tdata->algo;
10939         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10940                         &cap_idx) == NULL)
10941                 return TEST_SKIPPED;
10942
10943         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10944
10945         /* clear mbuf payload */
10946         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10947                         rte_pktmbuf_tailroom(ut_params->ibuf));
10948
10949         /* Create AEAD operation */
10950         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
10951         if (retval < 0)
10952                 return retval;
10953
10954         /* Create GCM xform */
10955         memcpy(key, tdata->key.data, tdata->key.len);
10956         retval = create_aead_xform(ut_params->op,
10957                         tdata->algo,
10958                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
10959                         key, tdata->key.len,
10960                         tdata->aad.len, tdata->auth_tag.len,
10961                         tdata->iv.len);
10962         if (retval < 0)
10963                 return retval;
10964
10965         ut_params->op->sym->m_src = ut_params->ibuf;
10966
10967         TEST_ASSERT_EQUAL(ut_params->op->sess_type,
10968                         RTE_CRYPTO_OP_SESSIONLESS,
10969                         "crypto op session type not sessionless");
10970
10971         /* Process crypto operation */
10972         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
10973                         ut_params->op), "failed to process sym crypto op");
10974
10975         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
10976
10977         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10978                         "crypto op status not success");
10979
10980         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
10981
10982         ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
10983                         ut_params->op->sym->cipher.data.offset);
10984         auth_tag = ciphertext + plaintext_pad_len;
10985
10986         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
10987         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
10988
10989         /* Validate obuf */
10990         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10991                         ciphertext,
10992                         tdata->ciphertext.data,
10993                         tdata->ciphertext.len,
10994                         "Ciphertext data not as expected");
10995
10996         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10997                         auth_tag,
10998                         tdata->auth_tag.data,
10999                         tdata->auth_tag.len,
11000                         "Generated auth tag not as expected");
11001
11002         return 0;
11003
11004 }
11005
11006 static int
11007 test_AES_GCM_authenticated_encryption_sessionless_test_case_1(void)
11008 {
11009         return test_authenticated_encryption_sessionless(
11010                         &gcm_test_case_5);
11011 }
11012
11013 static int
11014 test_authenticated_decryption_sessionless(
11015                 const struct aead_test_data *tdata)
11016 {
11017         struct crypto_testsuite_params *ts_params = &testsuite_params;
11018         struct crypto_unittest_params *ut_params = &unittest_params;
11019
11020         int retval;
11021         uint8_t *plaintext;
11022         uint8_t key[tdata->key.len + 1];
11023         struct rte_cryptodev_info dev_info;
11024
11025         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11026         uint64_t feat_flags = dev_info.feature_flags;
11027
11028         if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
11029                 printf("Device doesn't support Sessionless ops.\n");
11030                 return TEST_SKIPPED;
11031         }
11032
11033         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11034                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11035                 printf("Device doesn't support RAW data-path APIs.\n");
11036                 return TEST_SKIPPED;
11037         }
11038
11039         /* not supported with CPU crypto */
11040         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11041                 return TEST_SKIPPED;
11042
11043         /* Verify the capabilities */
11044         struct rte_cryptodev_sym_capability_idx cap_idx;
11045         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
11046         cap_idx.algo.aead = tdata->algo;
11047         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11048                         &cap_idx) == NULL)
11049                 return TEST_SKIPPED;
11050
11051         /* alloc mbuf and set payload */
11052         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11053
11054         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11055                         rte_pktmbuf_tailroom(ut_params->ibuf));
11056
11057         /* Create AEAD operation */
11058         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
11059         if (retval < 0)
11060                 return retval;
11061
11062         /* Create AEAD xform */
11063         memcpy(key, tdata->key.data, tdata->key.len);
11064         retval = create_aead_xform(ut_params->op,
11065                         tdata->algo,
11066                         RTE_CRYPTO_AEAD_OP_DECRYPT,
11067                         key, tdata->key.len,
11068                         tdata->aad.len, tdata->auth_tag.len,
11069                         tdata->iv.len);
11070         if (retval < 0)
11071                 return retval;
11072
11073         ut_params->op->sym->m_src = ut_params->ibuf;
11074
11075         TEST_ASSERT_EQUAL(ut_params->op->sess_type,
11076                         RTE_CRYPTO_OP_SESSIONLESS,
11077                         "crypto op session type not sessionless");
11078
11079         /* Process crypto operation */
11080         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11081                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11082                                 ut_params->op, 0, 0, 0, 0);
11083         else
11084                 TEST_ASSERT_NOT_NULL(process_crypto_request(
11085                         ts_params->valid_devs[0], ut_params->op),
11086                                 "failed to process sym crypto op");
11087
11088         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
11089
11090         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11091                         "crypto op status not success");
11092
11093         plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
11094                         ut_params->op->sym->cipher.data.offset);
11095
11096         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
11097
11098         /* Validate obuf */
11099         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11100                         plaintext,
11101                         tdata->plaintext.data,
11102                         tdata->plaintext.len,
11103                         "Plaintext data not as expected");
11104
11105         TEST_ASSERT_EQUAL(ut_params->op->status,
11106                         RTE_CRYPTO_OP_STATUS_SUCCESS,
11107                         "Authentication failed");
11108         return 0;
11109 }
11110
11111 static int
11112 test_AES_GCM_authenticated_decryption_sessionless_test_case_1(void)
11113 {
11114         return test_authenticated_decryption_sessionless(
11115                         &gcm_test_case_5);
11116 }
11117
11118 static int
11119 test_AES_CCM_authenticated_encryption_test_case_128_1(void)
11120 {
11121         return test_authenticated_encryption(&ccm_test_case_128_1);
11122 }
11123
11124 static int
11125 test_AES_CCM_authenticated_encryption_test_case_128_2(void)
11126 {
11127         return test_authenticated_encryption(&ccm_test_case_128_2);
11128 }
11129
11130 static int
11131 test_AES_CCM_authenticated_encryption_test_case_128_3(void)
11132 {
11133         return test_authenticated_encryption(&ccm_test_case_128_3);
11134 }
11135
11136 static int
11137 test_AES_CCM_authenticated_decryption_test_case_128_1(void)
11138 {
11139         return test_authenticated_decryption(&ccm_test_case_128_1);
11140 }
11141
11142 static int
11143 test_AES_CCM_authenticated_decryption_test_case_128_2(void)
11144 {
11145         return test_authenticated_decryption(&ccm_test_case_128_2);
11146 }
11147
11148 static int
11149 test_AES_CCM_authenticated_decryption_test_case_128_3(void)
11150 {
11151         return test_authenticated_decryption(&ccm_test_case_128_3);
11152 }
11153
11154 static int
11155 test_AES_CCM_authenticated_encryption_test_case_192_1(void)
11156 {
11157         return test_authenticated_encryption(&ccm_test_case_192_1);
11158 }
11159
11160 static int
11161 test_AES_CCM_authenticated_encryption_test_case_192_2(void)
11162 {
11163         return test_authenticated_encryption(&ccm_test_case_192_2);
11164 }
11165
11166 static int
11167 test_AES_CCM_authenticated_encryption_test_case_192_3(void)
11168 {
11169         return test_authenticated_encryption(&ccm_test_case_192_3);
11170 }
11171
11172 static int
11173 test_AES_CCM_authenticated_decryption_test_case_192_1(void)
11174 {
11175         return test_authenticated_decryption(&ccm_test_case_192_1);
11176 }
11177
11178 static int
11179 test_AES_CCM_authenticated_decryption_test_case_192_2(void)
11180 {
11181         return test_authenticated_decryption(&ccm_test_case_192_2);
11182 }
11183
11184 static int
11185 test_AES_CCM_authenticated_decryption_test_case_192_3(void)
11186 {
11187         return test_authenticated_decryption(&ccm_test_case_192_3);
11188 }
11189
11190 static int
11191 test_AES_CCM_authenticated_encryption_test_case_256_1(void)
11192 {
11193         return test_authenticated_encryption(&ccm_test_case_256_1);
11194 }
11195
11196 static int
11197 test_AES_CCM_authenticated_encryption_test_case_256_2(void)
11198 {
11199         return test_authenticated_encryption(&ccm_test_case_256_2);
11200 }
11201
11202 static int
11203 test_AES_CCM_authenticated_encryption_test_case_256_3(void)
11204 {
11205         return test_authenticated_encryption(&ccm_test_case_256_3);
11206 }
11207
11208 static int
11209 test_AES_CCM_authenticated_decryption_test_case_256_1(void)
11210 {
11211         return test_authenticated_decryption(&ccm_test_case_256_1);
11212 }
11213
11214 static int
11215 test_AES_CCM_authenticated_decryption_test_case_256_2(void)
11216 {
11217         return test_authenticated_decryption(&ccm_test_case_256_2);
11218 }
11219
11220 static int
11221 test_AES_CCM_authenticated_decryption_test_case_256_3(void)
11222 {
11223         return test_authenticated_decryption(&ccm_test_case_256_3);
11224 }
11225
11226 static int
11227 test_stats(void)
11228 {
11229         struct crypto_testsuite_params *ts_params = &testsuite_params;
11230         struct rte_cryptodev_stats stats;
11231
11232         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11233                 return TEST_SKIPPED;
11234
11235         /* Verify the capabilities */
11236         struct rte_cryptodev_sym_capability_idx cap_idx;
11237         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11238         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
11239         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11240                         &cap_idx) == NULL)
11241                 return TEST_SKIPPED;
11242         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11243         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
11244         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11245                         &cap_idx) == NULL)
11246                 return TEST_SKIPPED;
11247
11248         if (rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
11249                         == -ENOTSUP)
11250                 return TEST_SKIPPED;
11251
11252         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
11253         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
11254                         &stats) == -ENODEV),
11255                 "rte_cryptodev_stats_get invalid dev failed");
11256         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
11257                 "rte_cryptodev_stats_get invalid Param failed");
11258
11259         /* Test expected values */
11260         test_AES_CBC_HMAC_SHA1_encrypt_digest();
11261         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
11262                         &stats),
11263                 "rte_cryptodev_stats_get failed");
11264         TEST_ASSERT((stats.enqueued_count == 1),
11265                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11266         TEST_ASSERT((stats.dequeued_count == 1),
11267                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11268         TEST_ASSERT((stats.enqueue_err_count == 0),
11269                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11270         TEST_ASSERT((stats.dequeue_err_count == 0),
11271                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11272
11273         /* invalid device but should ignore and not reset device stats*/
11274         rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
11275         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
11276                         &stats),
11277                 "rte_cryptodev_stats_get failed");
11278         TEST_ASSERT((stats.enqueued_count == 1),
11279                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11280
11281         /* check that a valid reset clears stats */
11282         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
11283         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
11284                         &stats),
11285                                           "rte_cryptodev_stats_get failed");
11286         TEST_ASSERT((stats.enqueued_count == 0),
11287                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11288         TEST_ASSERT((stats.dequeued_count == 0),
11289                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11290
11291         return TEST_SUCCESS;
11292 }
11293
11294 static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
11295                                    struct crypto_unittest_params *ut_params,
11296                                    enum rte_crypto_auth_operation op,
11297                                    const struct HMAC_MD5_vector *test_case)
11298 {
11299         uint8_t key[64];
11300         int status;
11301
11302         memcpy(key, test_case->key.data, test_case->key.len);
11303
11304         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11305         ut_params->auth_xform.next = NULL;
11306         ut_params->auth_xform.auth.op = op;
11307
11308         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC;
11309
11310         ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN;
11311         ut_params->auth_xform.auth.key.length = test_case->key.len;
11312         ut_params->auth_xform.auth.key.data = key;
11313
11314         ut_params->sess = rte_cryptodev_sym_session_create(
11315                         ts_params->session_mpool);
11316         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
11317         if (ut_params->sess == NULL)
11318                 return TEST_FAILED;
11319
11320         status = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11321                         ut_params->sess, &ut_params->auth_xform,
11322                         ts_params->session_priv_mpool);
11323         if (status == -ENOTSUP)
11324                 return TEST_SKIPPED;
11325
11326         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11327
11328         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11329                         rte_pktmbuf_tailroom(ut_params->ibuf));
11330
11331         return 0;
11332 }
11333
11334 static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
11335                               const struct HMAC_MD5_vector *test_case,
11336                               uint8_t **plaintext)
11337 {
11338         uint16_t plaintext_pad_len;
11339
11340         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
11341
11342         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
11343                                 16);
11344
11345         *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11346                         plaintext_pad_len);
11347         memcpy(*plaintext, test_case->plaintext.data,
11348                         test_case->plaintext.len);
11349
11350         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
11351                         ut_params->ibuf, MD5_DIGEST_LEN);
11352         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
11353                         "no room to append digest");
11354         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
11355                         ut_params->ibuf, plaintext_pad_len);
11356
11357         if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
11358                 rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data,
11359                            test_case->auth_tag.len);
11360         }
11361
11362         sym_op->auth.data.offset = 0;
11363         sym_op->auth.data.length = test_case->plaintext.len;
11364
11365         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11366         ut_params->op->sym->m_src = ut_params->ibuf;
11367
11368         return 0;
11369 }
11370
11371 static int
11372 test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
11373 {
11374         uint16_t plaintext_pad_len;
11375         uint8_t *plaintext, *auth_tag;
11376
11377         struct crypto_testsuite_params *ts_params = &testsuite_params;
11378         struct crypto_unittest_params *ut_params = &unittest_params;
11379         struct rte_cryptodev_info dev_info;
11380
11381         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11382         uint64_t feat_flags = dev_info.feature_flags;
11383
11384         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11385                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11386                 printf("Device doesn't support RAW data-path APIs.\n");
11387                 return TEST_SKIPPED;
11388         }
11389
11390         /* Verify the capabilities */
11391         struct rte_cryptodev_sym_capability_idx cap_idx;
11392         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11393         cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
11394         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11395                         &cap_idx) == NULL)
11396                 return TEST_SKIPPED;
11397
11398         if (MD5_HMAC_create_session(ts_params, ut_params,
11399                         RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
11400                 return TEST_FAILED;
11401
11402         /* Generate Crypto op data structure */
11403         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11404                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11405         TEST_ASSERT_NOT_NULL(ut_params->op,
11406                         "Failed to allocate symmetric crypto operation struct");
11407
11408         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
11409                                 16);
11410
11411         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
11412                 return TEST_FAILED;
11413
11414         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11415                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11416                         ut_params->op);
11417         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11418                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11419                                 ut_params->op, 0, 1, 0, 0);
11420         else
11421                 TEST_ASSERT_NOT_NULL(
11422                         process_crypto_request(ts_params->valid_devs[0],
11423                                 ut_params->op),
11424                                 "failed to process sym crypto op");
11425
11426         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11427                         "crypto op processing failed");
11428
11429         if (ut_params->op->sym->m_dst) {
11430                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
11431                                 uint8_t *, plaintext_pad_len);
11432         } else {
11433                 auth_tag = plaintext + plaintext_pad_len;
11434         }
11435
11436         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11437                         auth_tag,
11438                         test_case->auth_tag.data,
11439                         test_case->auth_tag.len,
11440                         "HMAC_MD5 generated tag not as expected");
11441
11442         return TEST_SUCCESS;
11443 }
11444
11445 static int
11446 test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
11447 {
11448         uint8_t *plaintext;
11449
11450         struct crypto_testsuite_params *ts_params = &testsuite_params;
11451         struct crypto_unittest_params *ut_params = &unittest_params;
11452         struct rte_cryptodev_info dev_info;
11453
11454         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11455         uint64_t feat_flags = dev_info.feature_flags;
11456
11457         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11458                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11459                 printf("Device doesn't support RAW data-path APIs.\n");
11460                 return TEST_SKIPPED;
11461         }
11462
11463         /* Verify the capabilities */
11464         struct rte_cryptodev_sym_capability_idx cap_idx;
11465         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11466         cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
11467         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11468                         &cap_idx) == NULL)
11469                 return TEST_SKIPPED;
11470
11471         if (MD5_HMAC_create_session(ts_params, ut_params,
11472                         RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
11473                 return TEST_FAILED;
11474         }
11475
11476         /* Generate Crypto op data structure */
11477         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11478                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11479         TEST_ASSERT_NOT_NULL(ut_params->op,
11480                         "Failed to allocate symmetric crypto operation struct");
11481
11482         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
11483                 return TEST_FAILED;
11484
11485         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11486                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11487                         ut_params->op);
11488         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11489                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11490                                 ut_params->op, 0, 1, 0, 0);
11491         else
11492                 TEST_ASSERT_NOT_NULL(
11493                         process_crypto_request(ts_params->valid_devs[0],
11494                                 ut_params->op),
11495                                 "failed to process sym crypto op");
11496
11497         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11498                         "HMAC_MD5 crypto op processing failed");
11499
11500         return TEST_SUCCESS;
11501 }
11502
11503 static int
11504 test_MD5_HMAC_generate_case_1(void)
11505 {
11506         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1);
11507 }
11508
11509 static int
11510 test_MD5_HMAC_verify_case_1(void)
11511 {
11512         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1);
11513 }
11514
11515 static int
11516 test_MD5_HMAC_generate_case_2(void)
11517 {
11518         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2);
11519 }
11520
11521 static int
11522 test_MD5_HMAC_verify_case_2(void)
11523 {
11524         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2);
11525 }
11526
11527 static int
11528 test_multi_session(void)
11529 {
11530         struct crypto_testsuite_params *ts_params = &testsuite_params;
11531         struct crypto_unittest_params *ut_params = &unittest_params;
11532
11533         struct rte_cryptodev_info dev_info;
11534         struct rte_cryptodev_sym_session **sessions;
11535
11536         uint16_t i;
11537         int status;
11538
11539         /* Verify the capabilities */
11540         struct rte_cryptodev_sym_capability_idx cap_idx;
11541         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11542         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
11543         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11544                         &cap_idx) == NULL)
11545                 return TEST_SKIPPED;
11546         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11547         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
11548         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11549                         &cap_idx) == NULL)
11550                 return TEST_SKIPPED;
11551
11552         test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
11553                         aes_cbc_key, hmac_sha512_key);
11554
11555
11556         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11557
11558         sessions = rte_malloc(NULL,
11559                         sizeof(struct rte_cryptodev_sym_session *) *
11560                         (MAX_NB_SESSIONS + 1), 0);
11561
11562         /* Create multiple crypto sessions*/
11563         for (i = 0; i < MAX_NB_SESSIONS; i++) {
11564
11565                 sessions[i] = rte_cryptodev_sym_session_create(
11566                                 ts_params->session_mpool);
11567                 TEST_ASSERT_NOT_NULL(sessions[i],
11568                                 "Session creation failed at session number %u",
11569                                 i);
11570
11571                 status = rte_cryptodev_sym_session_init(
11572                                 ts_params->valid_devs[0],
11573                                 sessions[i], &ut_params->auth_xform,
11574                                 ts_params->session_priv_mpool);
11575                 if (status == -ENOTSUP)
11576                         return TEST_SKIPPED;
11577
11578                 /* Attempt to send a request on each session */
11579                 TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform(
11580                         sessions[i],
11581                         ut_params,
11582                         ts_params,
11583                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
11584                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
11585                         aes_cbc_iv),
11586                         "Failed to perform decrypt on request number %u.", i);
11587                 /* free crypto operation structure */
11588                 if (ut_params->op)
11589                         rte_crypto_op_free(ut_params->op);
11590
11591                 /*
11592                  * free mbuf - both obuf and ibuf are usually the same,
11593                  * so check if they point at the same address is necessary,
11594                  * to avoid freeing the mbuf twice.
11595                  */
11596                 if (ut_params->obuf) {
11597                         rte_pktmbuf_free(ut_params->obuf);
11598                         if (ut_params->ibuf == ut_params->obuf)
11599                                 ut_params->ibuf = 0;
11600                         ut_params->obuf = 0;
11601                 }
11602                 if (ut_params->ibuf) {
11603                         rte_pktmbuf_free(ut_params->ibuf);
11604                         ut_params->ibuf = 0;
11605                 }
11606         }
11607
11608         sessions[i] = NULL;
11609         /* Next session create should fail */
11610         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11611                         sessions[i], &ut_params->auth_xform,
11612                         ts_params->session_priv_mpool);
11613         TEST_ASSERT_NULL(sessions[i],
11614                         "Session creation succeeded unexpectedly!");
11615
11616         for (i = 0; i < MAX_NB_SESSIONS; i++) {
11617                 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
11618                                 sessions[i]);
11619                 rte_cryptodev_sym_session_free(sessions[i]);
11620         }
11621
11622         rte_free(sessions);
11623
11624         return TEST_SUCCESS;
11625 }
11626
11627 struct multi_session_params {
11628         struct crypto_unittest_params ut_params;
11629         uint8_t *cipher_key;
11630         uint8_t *hmac_key;
11631         const uint8_t *cipher;
11632         const uint8_t *digest;
11633         uint8_t *iv;
11634 };
11635
11636 #define MB_SESSION_NUMBER 3
11637
11638 static int
11639 test_multi_session_random_usage(void)
11640 {
11641         struct crypto_testsuite_params *ts_params = &testsuite_params;
11642         struct rte_cryptodev_info dev_info;
11643         struct rte_cryptodev_sym_session **sessions;
11644         uint32_t i, j;
11645         struct multi_session_params ut_paramz[] = {
11646
11647                 {
11648                         .cipher_key = ms_aes_cbc_key0,
11649                         .hmac_key = ms_hmac_key0,
11650                         .cipher = ms_aes_cbc_cipher0,
11651                         .digest = ms_hmac_digest0,
11652                         .iv = ms_aes_cbc_iv0
11653                 },
11654                 {
11655                         .cipher_key = ms_aes_cbc_key1,
11656                         .hmac_key = ms_hmac_key1,
11657                         .cipher = ms_aes_cbc_cipher1,
11658                         .digest = ms_hmac_digest1,
11659                         .iv = ms_aes_cbc_iv1
11660                 },
11661                 {
11662                         .cipher_key = ms_aes_cbc_key2,
11663                         .hmac_key = ms_hmac_key2,
11664                         .cipher = ms_aes_cbc_cipher2,
11665                         .digest = ms_hmac_digest2,
11666                         .iv = ms_aes_cbc_iv2
11667                 },
11668
11669         };
11670         int status;
11671
11672         /* Verify the capabilities */
11673         struct rte_cryptodev_sym_capability_idx cap_idx;
11674         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11675         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
11676         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11677                         &cap_idx) == NULL)
11678                 return TEST_SKIPPED;
11679         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11680         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
11681         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11682                         &cap_idx) == NULL)
11683                 return TEST_SKIPPED;
11684
11685         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11686
11687         sessions = rte_malloc(NULL,
11688                         (sizeof(struct rte_cryptodev_sym_session *)
11689                                         * MAX_NB_SESSIONS) + 1, 0);
11690
11691         for (i = 0; i < MB_SESSION_NUMBER; i++) {
11692                 sessions[i] = rte_cryptodev_sym_session_create(
11693                                 ts_params->session_mpool);
11694                 TEST_ASSERT_NOT_NULL(sessions[i],
11695                                 "Session creation failed at session number %u",
11696                                 i);
11697
11698                 rte_memcpy(&ut_paramz[i].ut_params, &unittest_params,
11699                                 sizeof(struct crypto_unittest_params));
11700
11701                 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
11702                                 &ut_paramz[i].ut_params,
11703                                 ut_paramz[i].cipher_key, ut_paramz[i].hmac_key);
11704
11705                 /* Create multiple crypto sessions*/
11706                 status = rte_cryptodev_sym_session_init(
11707                                 ts_params->valid_devs[0],
11708                                 sessions[i],
11709                                 &ut_paramz[i].ut_params.auth_xform,
11710                                 ts_params->session_priv_mpool);
11711
11712                 if (status == -ENOTSUP)
11713                         return TEST_SKIPPED;
11714
11715                 TEST_ASSERT_EQUAL(status, 0, "Session init failed");
11716         }
11717
11718         srand(time(NULL));
11719         for (i = 0; i < 40000; i++) {
11720
11721                 j = rand() % MB_SESSION_NUMBER;
11722
11723                 TEST_ASSERT_SUCCESS(
11724                         test_AES_CBC_HMAC_SHA512_decrypt_perform(
11725                                         sessions[j],
11726                                         &ut_paramz[j].ut_params,
11727                                         ts_params, ut_paramz[j].cipher,
11728                                         ut_paramz[j].digest,
11729                                         ut_paramz[j].iv),
11730                         "Failed to perform decrypt on request number %u.", i);
11731
11732                 if (ut_paramz[j].ut_params.op)
11733                         rte_crypto_op_free(ut_paramz[j].ut_params.op);
11734
11735                 /*
11736                  * free mbuf - both obuf and ibuf are usually the same,
11737                  * so check if they point at the same address is necessary,
11738                  * to avoid freeing the mbuf twice.
11739                  */
11740                 if (ut_paramz[j].ut_params.obuf) {
11741                         rte_pktmbuf_free(ut_paramz[j].ut_params.obuf);
11742                         if (ut_paramz[j].ut_params.ibuf
11743                                         == ut_paramz[j].ut_params.obuf)
11744                                 ut_paramz[j].ut_params.ibuf = 0;
11745                         ut_paramz[j].ut_params.obuf = 0;
11746                 }
11747                 if (ut_paramz[j].ut_params.ibuf) {
11748                         rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf);
11749                         ut_paramz[j].ut_params.ibuf = 0;
11750                 }
11751         }
11752
11753         for (i = 0; i < MB_SESSION_NUMBER; i++) {
11754                 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
11755                                 sessions[i]);
11756                 rte_cryptodev_sym_session_free(sessions[i]);
11757         }
11758
11759         rte_free(sessions);
11760
11761         return TEST_SUCCESS;
11762 }
11763
11764 uint8_t orig_data[] = {0xab, 0xab, 0xab, 0xab,
11765                         0xab, 0xab, 0xab, 0xab,
11766                         0xab, 0xab, 0xab, 0xab,
11767                         0xab, 0xab, 0xab, 0xab};
11768
11769 static int
11770 test_null_invalid_operation(void)
11771 {
11772         struct crypto_testsuite_params *ts_params = &testsuite_params;
11773         struct crypto_unittest_params *ut_params = &unittest_params;
11774         int ret;
11775
11776         /* This test is for NULL PMD only */
11777         if (gbl_driver_id != rte_cryptodev_driver_id_get(
11778                         RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
11779                 return TEST_SKIPPED;
11780
11781         /* Setup Cipher Parameters */
11782         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11783         ut_params->cipher_xform.next = NULL;
11784
11785         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
11786         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
11787
11788         ut_params->sess = rte_cryptodev_sym_session_create(
11789                         ts_params->session_mpool);
11790
11791         /* Create Crypto session*/
11792         ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11793                         ut_params->sess, &ut_params->cipher_xform,
11794                         ts_params->session_priv_mpool);
11795         TEST_ASSERT(ret < 0,
11796                         "Session creation succeeded unexpectedly");
11797
11798
11799         /* Setup HMAC Parameters */
11800         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11801         ut_params->auth_xform.next = NULL;
11802
11803         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
11804         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
11805
11806         ut_params->sess = rte_cryptodev_sym_session_create(
11807                         ts_params->session_mpool);
11808
11809         /* Create Crypto session*/
11810         ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11811                         ut_params->sess, &ut_params->auth_xform,
11812                         ts_params->session_priv_mpool);
11813         TEST_ASSERT(ret < 0,
11814                         "Session creation succeeded unexpectedly");
11815
11816         return TEST_SUCCESS;
11817 }
11818
11819
11820 #define NULL_BURST_LENGTH (32)
11821
11822 static int
11823 test_null_burst_operation(void)
11824 {
11825         struct crypto_testsuite_params *ts_params = &testsuite_params;
11826         struct crypto_unittest_params *ut_params = &unittest_params;
11827         int status;
11828
11829         unsigned i, burst_len = NULL_BURST_LENGTH;
11830
11831         struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
11832         struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
11833
11834         /* This test is for NULL PMD only */
11835         if (gbl_driver_id != rte_cryptodev_driver_id_get(
11836                         RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
11837                 return TEST_SKIPPED;
11838
11839         /* Setup Cipher Parameters */
11840         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11841         ut_params->cipher_xform.next = &ut_params->auth_xform;
11842
11843         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
11844         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
11845
11846         /* Setup HMAC Parameters */
11847         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11848         ut_params->auth_xform.next = NULL;
11849
11850         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
11851         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
11852
11853         ut_params->sess = rte_cryptodev_sym_session_create(
11854                         ts_params->session_mpool);
11855         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
11856
11857         /* Create Crypto session*/
11858         status = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11859                         ut_params->sess, &ut_params->cipher_xform,
11860                         ts_params->session_priv_mpool);
11861
11862         if (status == -ENOTSUP)
11863                 return TEST_SKIPPED;
11864
11865         TEST_ASSERT_EQUAL(status, 0, "Session init failed");
11866
11867         TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
11868                         RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
11869                         burst_len, "failed to generate burst of crypto ops");
11870
11871         /* Generate an operation for each mbuf in burst */
11872         for (i = 0; i < burst_len; i++) {
11873                 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11874
11875                 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
11876
11877                 unsigned *data = (unsigned *)rte_pktmbuf_append(m,
11878                                 sizeof(unsigned));
11879                 *data = i;
11880
11881                 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
11882
11883                 burst[i]->sym->m_src = m;
11884         }
11885
11886         /* Process crypto operation */
11887         TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
11888                         0, burst, burst_len),
11889                         burst_len,
11890                         "Error enqueuing burst");
11891
11892         TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
11893                         0, burst_dequeued, burst_len),
11894                         burst_len,
11895                         "Error dequeuing burst");
11896
11897
11898         for (i = 0; i < burst_len; i++) {
11899                 TEST_ASSERT_EQUAL(
11900                         *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
11901                         *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
11902                                         uint32_t *),
11903                         "data not as expected");
11904
11905                 rte_pktmbuf_free(burst[i]->sym->m_src);
11906                 rte_crypto_op_free(burst[i]);
11907         }
11908
11909         return TEST_SUCCESS;
11910 }
11911
11912 static uint16_t
11913 test_enq_callback(uint16_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops,
11914                   uint16_t nb_ops, void *user_param)
11915 {
11916         RTE_SET_USED(dev_id);
11917         RTE_SET_USED(qp_id);
11918         RTE_SET_USED(ops);
11919         RTE_SET_USED(user_param);
11920
11921         printf("crypto enqueue callback called\n");
11922         return nb_ops;
11923 }
11924
11925 static uint16_t
11926 test_deq_callback(uint16_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops,
11927                   uint16_t nb_ops, void *user_param)
11928 {
11929         RTE_SET_USED(dev_id);
11930         RTE_SET_USED(qp_id);
11931         RTE_SET_USED(ops);
11932         RTE_SET_USED(user_param);
11933
11934         printf("crypto dequeue callback called\n");
11935         return nb_ops;
11936 }
11937
11938 /*
11939  * Thread using enqueue/dequeue callback with RCU.
11940  */
11941 static int
11942 test_enqdeq_callback_thread(void *arg)
11943 {
11944         RTE_SET_USED(arg);
11945         /* DP thread calls rte_cryptodev_enqueue_burst()/
11946          * rte_cryptodev_dequeue_burst() and invokes callback.
11947          */
11948         test_null_burst_operation();
11949         return 0;
11950 }
11951
11952 static int
11953 test_enq_callback_setup(void)
11954 {
11955         struct crypto_testsuite_params *ts_params = &testsuite_params;
11956         struct rte_cryptodev_info dev_info;
11957         struct rte_cryptodev_qp_conf qp_conf = {
11958                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
11959         };
11960
11961         struct rte_cryptodev_cb *cb;
11962         uint16_t qp_id = 0;
11963
11964         /* Stop the device in case it's started so it can be configured */
11965         rte_cryptodev_stop(ts_params->valid_devs[0]);
11966
11967         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11968
11969         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
11970                         &ts_params->conf),
11971                         "Failed to configure cryptodev %u",
11972                         ts_params->valid_devs[0]);
11973
11974         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
11975         qp_conf.mp_session = ts_params->session_mpool;
11976         qp_conf.mp_session_private = ts_params->session_priv_mpool;
11977
11978         TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
11979                         ts_params->valid_devs[0], qp_id, &qp_conf,
11980                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
11981                         "Failed test for "
11982                         "rte_cryptodev_queue_pair_setup: num_inflights "
11983                         "%u on qp %u on cryptodev %u",
11984                         qp_conf.nb_descriptors, qp_id,
11985                         ts_params->valid_devs[0]);
11986
11987         /* Test with invalid crypto device */
11988         cb = rte_cryptodev_add_enq_callback(RTE_CRYPTO_MAX_DEVS,
11989                         qp_id, test_enq_callback, NULL);
11990         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11991                         "cryptodev %u did not fail",
11992                         qp_id, RTE_CRYPTO_MAX_DEVS);
11993
11994         /* Test with invalid queue pair */
11995         cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
11996                         dev_info.max_nb_queue_pairs + 1,
11997                         test_enq_callback, NULL);
11998         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11999                         "cryptodev %u did not fail",
12000                         dev_info.max_nb_queue_pairs + 1,
12001                         ts_params->valid_devs[0]);
12002
12003         /* Test with NULL callback */
12004         cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
12005                         qp_id, NULL, NULL);
12006         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12007                         "cryptodev %u did not fail",
12008                         qp_id, ts_params->valid_devs[0]);
12009
12010         /* Test with valid configuration */
12011         cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
12012                         qp_id, test_enq_callback, NULL);
12013         TEST_ASSERT_NOT_NULL(cb, "Failed test to add callback on "
12014                         "qp %u on cryptodev %u",
12015                         qp_id, ts_params->valid_devs[0]);
12016
12017         rte_cryptodev_start(ts_params->valid_devs[0]);
12018
12019         /* Launch a thread */
12020         rte_eal_remote_launch(test_enqdeq_callback_thread, NULL,
12021                                 rte_get_next_lcore(-1, 1, 0));
12022
12023         /* Wait until reader exited. */
12024         rte_eal_mp_wait_lcore();
12025
12026         /* Test with invalid crypto device */
12027         TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
12028                         RTE_CRYPTO_MAX_DEVS, qp_id, cb),
12029                         "Expected call to fail as crypto device is invalid");
12030
12031         /* Test with invalid queue pair */
12032         TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
12033                         ts_params->valid_devs[0],
12034                         dev_info.max_nb_queue_pairs + 1, cb),
12035                         "Expected call to fail as queue pair is invalid");
12036
12037         /* Test with NULL callback */
12038         TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
12039                         ts_params->valid_devs[0], qp_id, NULL),
12040                         "Expected call to fail as callback is NULL");
12041
12042         /* Test with valid configuration */
12043         TEST_ASSERT_SUCCESS(rte_cryptodev_remove_enq_callback(
12044                         ts_params->valid_devs[0], qp_id, cb),
12045                         "Failed test to remove callback on "
12046                         "qp %u on cryptodev %u",
12047                         qp_id, ts_params->valid_devs[0]);
12048
12049         return TEST_SUCCESS;
12050 }
12051
12052 static int
12053 test_deq_callback_setup(void)
12054 {
12055         struct crypto_testsuite_params *ts_params = &testsuite_params;
12056         struct rte_cryptodev_info dev_info;
12057         struct rte_cryptodev_qp_conf qp_conf = {
12058                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
12059         };
12060
12061         struct rte_cryptodev_cb *cb;
12062         uint16_t qp_id = 0;
12063
12064         /* Stop the device in case it's started so it can be configured */
12065         rte_cryptodev_stop(ts_params->valid_devs[0]);
12066
12067         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12068
12069         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
12070                         &ts_params->conf),
12071                         "Failed to configure cryptodev %u",
12072                         ts_params->valid_devs[0]);
12073
12074         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
12075         qp_conf.mp_session = ts_params->session_mpool;
12076         qp_conf.mp_session_private = ts_params->session_priv_mpool;
12077
12078         TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
12079                         ts_params->valid_devs[0], qp_id, &qp_conf,
12080                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
12081                         "Failed test for "
12082                         "rte_cryptodev_queue_pair_setup: num_inflights "
12083                         "%u on qp %u on cryptodev %u",
12084                         qp_conf.nb_descriptors, qp_id,
12085                         ts_params->valid_devs[0]);
12086
12087         /* Test with invalid crypto device */
12088         cb = rte_cryptodev_add_deq_callback(RTE_CRYPTO_MAX_DEVS,
12089                         qp_id, test_deq_callback, NULL);
12090         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12091                         "cryptodev %u did not fail",
12092                         qp_id, RTE_CRYPTO_MAX_DEVS);
12093
12094         /* Test with invalid queue pair */
12095         cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
12096                         dev_info.max_nb_queue_pairs + 1,
12097                         test_deq_callback, NULL);
12098         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12099                         "cryptodev %u did not fail",
12100                         dev_info.max_nb_queue_pairs + 1,
12101                         ts_params->valid_devs[0]);
12102
12103         /* Test with NULL callback */
12104         cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
12105                         qp_id, NULL, NULL);
12106         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12107                         "cryptodev %u did not fail",
12108                         qp_id, ts_params->valid_devs[0]);
12109
12110         /* Test with valid configuration */
12111         cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
12112                         qp_id, test_deq_callback, NULL);
12113         TEST_ASSERT_NOT_NULL(cb, "Failed test to add callback on "
12114                         "qp %u on cryptodev %u",
12115                         qp_id, ts_params->valid_devs[0]);
12116
12117         rte_cryptodev_start(ts_params->valid_devs[0]);
12118
12119         /* Launch a thread */
12120         rte_eal_remote_launch(test_enqdeq_callback_thread, NULL,
12121                                 rte_get_next_lcore(-1, 1, 0));
12122
12123         /* Wait until reader exited. */
12124         rte_eal_mp_wait_lcore();
12125
12126         /* Test with invalid crypto device */
12127         TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
12128                         RTE_CRYPTO_MAX_DEVS, qp_id, cb),
12129                         "Expected call to fail as crypto device is invalid");
12130
12131         /* Test with invalid queue pair */
12132         TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
12133                         ts_params->valid_devs[0],
12134                         dev_info.max_nb_queue_pairs + 1, cb),
12135                         "Expected call to fail as queue pair is invalid");
12136
12137         /* Test with NULL callback */
12138         TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
12139                         ts_params->valid_devs[0], qp_id, NULL),
12140                         "Expected call to fail as callback is NULL");
12141
12142         /* Test with valid configuration */
12143         TEST_ASSERT_SUCCESS(rte_cryptodev_remove_deq_callback(
12144                         ts_params->valid_devs[0], qp_id, cb),
12145                         "Failed test to remove callback on "
12146                         "qp %u on cryptodev %u",
12147                         qp_id, ts_params->valid_devs[0]);
12148
12149         return TEST_SUCCESS;
12150 }
12151
12152 static void
12153 generate_gmac_large_plaintext(uint8_t *data)
12154 {
12155         uint16_t i;
12156
12157         for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32)
12158                 memcpy(&data[i], &data[0], 32);
12159 }
12160
12161 static int
12162 create_gmac_operation(enum rte_crypto_auth_operation op,
12163                 const struct gmac_test_data *tdata)
12164 {
12165         struct crypto_testsuite_params *ts_params = &testsuite_params;
12166         struct crypto_unittest_params *ut_params = &unittest_params;
12167         struct rte_crypto_sym_op *sym_op;
12168
12169         uint32_t plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
12170
12171         /* Generate Crypto op data structure */
12172         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12173                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12174         TEST_ASSERT_NOT_NULL(ut_params->op,
12175                         "Failed to allocate symmetric crypto operation struct");
12176
12177         sym_op = ut_params->op->sym;
12178
12179         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
12180                         ut_params->ibuf, tdata->gmac_tag.len);
12181         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
12182                         "no room to append digest");
12183
12184         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
12185                         ut_params->ibuf, plaintext_pad_len);
12186
12187         if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
12188                 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
12189                                 tdata->gmac_tag.len);
12190                 debug_hexdump(stdout, "digest:",
12191                                 sym_op->auth.digest.data,
12192                                 tdata->gmac_tag.len);
12193         }
12194
12195         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
12196                         uint8_t *, IV_OFFSET);
12197
12198         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
12199
12200         debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
12201
12202         sym_op->cipher.data.length = 0;
12203         sym_op->cipher.data.offset = 0;
12204
12205         sym_op->auth.data.offset = 0;
12206         sym_op->auth.data.length = tdata->plaintext.len;
12207
12208         return 0;
12209 }
12210
12211 static int
12212 create_gmac_operation_sgl(enum rte_crypto_auth_operation op,
12213                 const struct gmac_test_data *tdata,
12214                 void *digest_mem, uint64_t digest_phys)
12215 {
12216         struct crypto_testsuite_params *ts_params = &testsuite_params;
12217         struct crypto_unittest_params *ut_params = &unittest_params;
12218         struct rte_crypto_sym_op *sym_op;
12219
12220         /* Generate Crypto op data structure */
12221         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12222                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12223         TEST_ASSERT_NOT_NULL(ut_params->op,
12224                         "Failed to allocate symmetric crypto operation struct");
12225
12226         sym_op = ut_params->op->sym;
12227
12228         sym_op->auth.digest.data = digest_mem;
12229         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
12230                         "no room to append digest");
12231
12232         sym_op->auth.digest.phys_addr = digest_phys;
12233
12234         if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
12235                 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
12236                                 tdata->gmac_tag.len);
12237                 debug_hexdump(stdout, "digest:",
12238                                 sym_op->auth.digest.data,
12239                                 tdata->gmac_tag.len);
12240         }
12241
12242         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
12243                         uint8_t *, IV_OFFSET);
12244
12245         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
12246
12247         debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
12248
12249         sym_op->cipher.data.length = 0;
12250         sym_op->cipher.data.offset = 0;
12251
12252         sym_op->auth.data.offset = 0;
12253         sym_op->auth.data.length = tdata->plaintext.len;
12254
12255         return 0;
12256 }
12257
12258 static int create_gmac_session(uint8_t dev_id,
12259                 const struct gmac_test_data *tdata,
12260                 enum rte_crypto_auth_operation auth_op)
12261 {
12262         uint8_t auth_key[tdata->key.len];
12263         int status;
12264
12265         struct crypto_testsuite_params *ts_params = &testsuite_params;
12266         struct crypto_unittest_params *ut_params = &unittest_params;
12267
12268         memcpy(auth_key, tdata->key.data, tdata->key.len);
12269
12270         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12271         ut_params->auth_xform.next = NULL;
12272
12273         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
12274         ut_params->auth_xform.auth.op = auth_op;
12275         ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
12276         ut_params->auth_xform.auth.key.length = tdata->key.len;
12277         ut_params->auth_xform.auth.key.data = auth_key;
12278         ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
12279         ut_params->auth_xform.auth.iv.length = tdata->iv.len;
12280
12281
12282         ut_params->sess = rte_cryptodev_sym_session_create(
12283                         ts_params->session_mpool);
12284         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12285
12286         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
12287                         &ut_params->auth_xform,
12288                         ts_params->session_priv_mpool);
12289
12290         return status;
12291 }
12292
12293 static int
12294 test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
12295 {
12296         struct crypto_testsuite_params *ts_params = &testsuite_params;
12297         struct crypto_unittest_params *ut_params = &unittest_params;
12298         struct rte_cryptodev_info dev_info;
12299
12300         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12301         uint64_t feat_flags = dev_info.feature_flags;
12302
12303         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12304                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12305                 printf("Device doesn't support RAW data-path APIs.\n");
12306                 return TEST_SKIPPED;
12307         }
12308
12309         int retval;
12310
12311         uint8_t *auth_tag, *plaintext;
12312         uint16_t plaintext_pad_len;
12313
12314         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
12315                               "No GMAC length in the source data");
12316
12317         /* Verify the capabilities */
12318         struct rte_cryptodev_sym_capability_idx cap_idx;
12319         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12320         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
12321         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12322                         &cap_idx) == NULL)
12323                 return TEST_SKIPPED;
12324
12325         retval = create_gmac_session(ts_params->valid_devs[0],
12326                         tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
12327
12328         if (retval == -ENOTSUP)
12329                 return TEST_SKIPPED;
12330         if (retval < 0)
12331                 return retval;
12332
12333         if (tdata->plaintext.len > MBUF_SIZE)
12334                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
12335         else
12336                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12337         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12338                         "Failed to allocate input buffer in mempool");
12339
12340         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12341                         rte_pktmbuf_tailroom(ut_params->ibuf));
12342
12343         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
12344         /*
12345          * Runtime generate the large plain text instead of use hard code
12346          * plain text vector. It is done to avoid create huge source file
12347          * with the test vector.
12348          */
12349         if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
12350                 generate_gmac_large_plaintext(tdata->plaintext.data);
12351
12352         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12353                                 plaintext_pad_len);
12354         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12355
12356         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
12357         debug_hexdump(stdout, "plaintext:", plaintext,
12358                         tdata->plaintext.len);
12359
12360         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
12361                         tdata);
12362
12363         if (retval < 0)
12364                 return retval;
12365
12366         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12367
12368         ut_params->op->sym->m_src = ut_params->ibuf;
12369
12370         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12371                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12372                         ut_params->op);
12373         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12374                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12375                                 ut_params->op, 0, 1, 0, 0);
12376         else
12377                 TEST_ASSERT_NOT_NULL(
12378                         process_crypto_request(ts_params->valid_devs[0],
12379                         ut_params->op), "failed to process sym crypto op");
12380
12381         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12382                         "crypto op processing failed");
12383
12384         if (ut_params->op->sym->m_dst) {
12385                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
12386                                 uint8_t *, plaintext_pad_len);
12387         } else {
12388                 auth_tag = plaintext + plaintext_pad_len;
12389         }
12390
12391         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
12392
12393         TEST_ASSERT_BUFFERS_ARE_EQUAL(
12394                         auth_tag,
12395                         tdata->gmac_tag.data,
12396                         tdata->gmac_tag.len,
12397                         "GMAC Generated auth tag not as expected");
12398
12399         return 0;
12400 }
12401
12402 static int
12403 test_AES_GMAC_authentication_test_case_1(void)
12404 {
12405         return test_AES_GMAC_authentication(&gmac_test_case_1);
12406 }
12407
12408 static int
12409 test_AES_GMAC_authentication_test_case_2(void)
12410 {
12411         return test_AES_GMAC_authentication(&gmac_test_case_2);
12412 }
12413
12414 static int
12415 test_AES_GMAC_authentication_test_case_3(void)
12416 {
12417         return test_AES_GMAC_authentication(&gmac_test_case_3);
12418 }
12419
12420 static int
12421 test_AES_GMAC_authentication_test_case_4(void)
12422 {
12423         return test_AES_GMAC_authentication(&gmac_test_case_4);
12424 }
12425
12426 static int
12427 test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
12428 {
12429         struct crypto_testsuite_params *ts_params = &testsuite_params;
12430         struct crypto_unittest_params *ut_params = &unittest_params;
12431         int retval;
12432         uint32_t plaintext_pad_len;
12433         uint8_t *plaintext;
12434         struct rte_cryptodev_info dev_info;
12435
12436         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12437         uint64_t feat_flags = dev_info.feature_flags;
12438
12439         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12440                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12441                 printf("Device doesn't support RAW data-path APIs.\n");
12442                 return TEST_SKIPPED;
12443         }
12444
12445         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
12446                               "No GMAC length in the source data");
12447
12448         /* Verify the capabilities */
12449         struct rte_cryptodev_sym_capability_idx cap_idx;
12450         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12451         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
12452         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12453                         &cap_idx) == NULL)
12454                 return TEST_SKIPPED;
12455
12456         retval = create_gmac_session(ts_params->valid_devs[0],
12457                         tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
12458
12459         if (retval == -ENOTSUP)
12460                 return TEST_SKIPPED;
12461         if (retval < 0)
12462                 return retval;
12463
12464         if (tdata->plaintext.len > MBUF_SIZE)
12465                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
12466         else
12467                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12468         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12469                         "Failed to allocate input buffer in mempool");
12470
12471         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12472                         rte_pktmbuf_tailroom(ut_params->ibuf));
12473
12474         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
12475
12476         /*
12477          * Runtime generate the large plain text instead of use hard code
12478          * plain text vector. It is done to avoid create huge source file
12479          * with the test vector.
12480          */
12481         if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
12482                 generate_gmac_large_plaintext(tdata->plaintext.data);
12483
12484         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12485                                 plaintext_pad_len);
12486         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12487
12488         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
12489         debug_hexdump(stdout, "plaintext:", plaintext,
12490                         tdata->plaintext.len);
12491
12492         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
12493                         tdata);
12494
12495         if (retval < 0)
12496                 return retval;
12497
12498         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12499
12500         ut_params->op->sym->m_src = ut_params->ibuf;
12501
12502         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12503                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12504                         ut_params->op);
12505         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12506                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12507                                 ut_params->op, 0, 1, 0, 0);
12508         else
12509                 TEST_ASSERT_NOT_NULL(
12510                         process_crypto_request(ts_params->valid_devs[0],
12511                         ut_params->op), "failed to process sym crypto op");
12512
12513         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12514                         "crypto op processing failed");
12515
12516         return 0;
12517
12518 }
12519
12520 static int
12521 test_AES_GMAC_authentication_verify_test_case_1(void)
12522 {
12523         return test_AES_GMAC_authentication_verify(&gmac_test_case_1);
12524 }
12525
12526 static int
12527 test_AES_GMAC_authentication_verify_test_case_2(void)
12528 {
12529         return test_AES_GMAC_authentication_verify(&gmac_test_case_2);
12530 }
12531
12532 static int
12533 test_AES_GMAC_authentication_verify_test_case_3(void)
12534 {
12535         return test_AES_GMAC_authentication_verify(&gmac_test_case_3);
12536 }
12537
12538 static int
12539 test_AES_GMAC_authentication_verify_test_case_4(void)
12540 {
12541         return test_AES_GMAC_authentication_verify(&gmac_test_case_4);
12542 }
12543
12544 static int
12545 test_AES_GMAC_authentication_SGL(const struct gmac_test_data *tdata,
12546                                 uint32_t fragsz)
12547 {
12548         struct crypto_testsuite_params *ts_params = &testsuite_params;
12549         struct crypto_unittest_params *ut_params = &unittest_params;
12550         struct rte_cryptodev_info dev_info;
12551         uint64_t feature_flags;
12552         unsigned int trn_data = 0;
12553         void *digest_mem = NULL;
12554         uint32_t segs = 1;
12555         unsigned int to_trn = 0;
12556         struct rte_mbuf *buf = NULL;
12557         uint8_t *auth_tag, *plaintext;
12558         int retval;
12559
12560         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
12561                               "No GMAC length in the source data");
12562
12563         /* Verify the capabilities */
12564         struct rte_cryptodev_sym_capability_idx cap_idx;
12565         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12566         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
12567         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12568                         &cap_idx) == NULL)
12569                 return TEST_SKIPPED;
12570
12571         /* Check for any input SGL support */
12572         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12573         feature_flags = dev_info.feature_flags;
12574
12575         if ((!(feature_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) ||
12576                         (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT)) ||
12577                         (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)))
12578                 return TEST_SKIPPED;
12579
12580         if (fragsz > tdata->plaintext.len)
12581                 fragsz = tdata->plaintext.len;
12582
12583         uint16_t plaintext_len = fragsz;
12584
12585         retval = create_gmac_session(ts_params->valid_devs[0],
12586                         tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
12587
12588         if (retval == -ENOTSUP)
12589                 return TEST_SKIPPED;
12590         if (retval < 0)
12591                 return retval;
12592
12593         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12594         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12595                         "Failed to allocate input buffer in mempool");
12596
12597         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12598                         rte_pktmbuf_tailroom(ut_params->ibuf));
12599
12600         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12601                                 plaintext_len);
12602         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12603
12604         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
12605
12606         trn_data += plaintext_len;
12607
12608         buf = ut_params->ibuf;
12609
12610         /*
12611          * Loop until no more fragments
12612          */
12613
12614         while (trn_data < tdata->plaintext.len) {
12615                 ++segs;
12616                 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
12617                                 (tdata->plaintext.len - trn_data) : fragsz;
12618
12619                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12620                 buf = buf->next;
12621
12622                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
12623                                 rte_pktmbuf_tailroom(buf));
12624
12625                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
12626                                 to_trn);
12627
12628                 memcpy(plaintext, tdata->plaintext.data + trn_data,
12629                                 to_trn);
12630                 trn_data += to_trn;
12631                 if (trn_data  == tdata->plaintext.len)
12632                         digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
12633                                         tdata->gmac_tag.len);
12634         }
12635         ut_params->ibuf->nb_segs = segs;
12636
12637         /*
12638          * Place digest at the end of the last buffer
12639          */
12640         uint64_t digest_phys = rte_pktmbuf_iova(buf) + to_trn;
12641
12642         if (!digest_mem) {
12643                 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12644                                 + tdata->gmac_tag.len);
12645                 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
12646                                 tdata->plaintext.len);
12647         }
12648
12649         retval = create_gmac_operation_sgl(RTE_CRYPTO_AUTH_OP_GENERATE,
12650                         tdata, digest_mem, digest_phys);
12651
12652         if (retval < 0)
12653                 return retval;
12654
12655         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12656
12657         ut_params->op->sym->m_src = ut_params->ibuf;
12658
12659         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12660                 return TEST_SKIPPED;
12661
12662         TEST_ASSERT_NOT_NULL(
12663                 process_crypto_request(ts_params->valid_devs[0],
12664                 ut_params->op), "failed to process sym crypto op");
12665
12666         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12667                         "crypto op processing failed");
12668
12669         auth_tag = digest_mem;
12670         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
12671         TEST_ASSERT_BUFFERS_ARE_EQUAL(
12672                         auth_tag,
12673                         tdata->gmac_tag.data,
12674                         tdata->gmac_tag.len,
12675                         "GMAC Generated auth tag not as expected");
12676
12677         return 0;
12678 }
12679
12680 /* Segment size not multiple of block size (16B) */
12681 static int
12682 test_AES_GMAC_authentication_SGL_40B(void)
12683 {
12684         return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 40);
12685 }
12686
12687 static int
12688 test_AES_GMAC_authentication_SGL_80B(void)
12689 {
12690         return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 80);
12691 }
12692
12693 static int
12694 test_AES_GMAC_authentication_SGL_2048B(void)
12695 {
12696         return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2048);
12697 }
12698
12699 /* Segment size not multiple of block size (16B) */
12700 static int
12701 test_AES_GMAC_authentication_SGL_2047B(void)
12702 {
12703         return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2047);
12704 }
12705
12706 struct test_crypto_vector {
12707         enum rte_crypto_cipher_algorithm crypto_algo;
12708         unsigned int cipher_offset;
12709         unsigned int cipher_len;
12710
12711         struct {
12712                 uint8_t data[64];
12713                 unsigned int len;
12714         } cipher_key;
12715
12716         struct {
12717                 uint8_t data[64];
12718                 unsigned int len;
12719         } iv;
12720
12721         struct {
12722                 const uint8_t *data;
12723                 unsigned int len;
12724         } plaintext;
12725
12726         struct {
12727                 const uint8_t *data;
12728                 unsigned int len;
12729         } ciphertext;
12730
12731         enum rte_crypto_auth_algorithm auth_algo;
12732         unsigned int auth_offset;
12733
12734         struct {
12735                 uint8_t data[128];
12736                 unsigned int len;
12737         } auth_key;
12738
12739         struct {
12740                 const uint8_t *data;
12741                 unsigned int len;
12742         } aad;
12743
12744         struct {
12745                 uint8_t data[128];
12746                 unsigned int len;
12747         } digest;
12748 };
12749
12750 static const struct test_crypto_vector
12751 hmac_sha1_test_crypto_vector = {
12752         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
12753         .plaintext = {
12754                 .data = plaintext_hash,
12755                 .len = 512
12756         },
12757         .auth_key = {
12758                 .data = {
12759                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
12760                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
12761                         0xDE, 0xF4, 0xDE, 0xAD
12762                 },
12763                 .len = 20
12764         },
12765         .digest = {
12766                 .data = {
12767                         0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
12768                         0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
12769                         0x3F, 0x91, 0x64, 0x59
12770                 },
12771                 .len = 20
12772         }
12773 };
12774
12775 static const struct test_crypto_vector
12776 aes128_gmac_test_vector = {
12777         .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
12778         .plaintext = {
12779                 .data = plaintext_hash,
12780                 .len = 512
12781         },
12782         .iv = {
12783                 .data = {
12784                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
12785                         0x08, 0x09, 0x0A, 0x0B
12786                 },
12787                 .len = 12
12788         },
12789         .auth_key = {
12790                 .data = {
12791                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
12792                         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
12793                 },
12794                 .len = 16
12795         },
12796         .digest = {
12797                 .data = {
12798                         0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56,
12799                         0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A
12800                 },
12801                 .len = 16
12802         }
12803 };
12804
12805 static const struct test_crypto_vector
12806 aes128cbc_hmac_sha1_test_vector = {
12807         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
12808         .cipher_offset = 0,
12809         .cipher_len = 512,
12810         .cipher_key = {
12811                 .data = {
12812                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
12813                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
12814                 },
12815                 .len = 16
12816         },
12817         .iv = {
12818                 .data = {
12819                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
12820                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
12821                 },
12822                 .len = 16
12823         },
12824         .plaintext = {
12825                 .data = plaintext_hash,
12826                 .len = 512
12827         },
12828         .ciphertext = {
12829                 .data = ciphertext512_aes128cbc,
12830                 .len = 512
12831         },
12832         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
12833         .auth_offset = 0,
12834         .auth_key = {
12835                 .data = {
12836                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
12837                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
12838                         0xDE, 0xF4, 0xDE, 0xAD
12839                 },
12840                 .len = 20
12841         },
12842         .digest = {
12843                 .data = {
12844                         0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
12845                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
12846                         0x18, 0x8C, 0x1D, 0x32
12847                 },
12848                 .len = 20
12849         }
12850 };
12851
12852 static const struct test_crypto_vector
12853 aes128cbc_hmac_sha1_aad_test_vector = {
12854         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
12855         .cipher_offset = 8,
12856         .cipher_len = 496,
12857         .cipher_key = {
12858                 .data = {
12859                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
12860                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
12861                 },
12862                 .len = 16
12863         },
12864         .iv = {
12865                 .data = {
12866                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
12867                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
12868                 },
12869                 .len = 16
12870         },
12871         .plaintext = {
12872                 .data = plaintext_hash,
12873                 .len = 512
12874         },
12875         .ciphertext = {
12876                 .data = ciphertext512_aes128cbc_aad,
12877                 .len = 512
12878         },
12879         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
12880         .auth_offset = 0,
12881         .auth_key = {
12882                 .data = {
12883                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
12884                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
12885                         0xDE, 0xF4, 0xDE, 0xAD
12886                 },
12887                 .len = 20
12888         },
12889         .digest = {
12890                 .data = {
12891                         0x6D, 0xF3, 0x50, 0x79, 0x7A, 0x2A, 0xAC, 0x7F,
12892                         0xA6, 0xF0, 0xC6, 0x38, 0x1F, 0xA4, 0xDD, 0x9B,
12893                         0x62, 0x0F, 0xFB, 0x10
12894                 },
12895                 .len = 20
12896         }
12897 };
12898
12899 static void
12900 data_corruption(uint8_t *data)
12901 {
12902         data[0] += 1;
12903 }
12904
12905 static void
12906 tag_corruption(uint8_t *data, unsigned int tag_offset)
12907 {
12908         data[tag_offset] += 1;
12909 }
12910
12911 static int
12912 create_auth_session(struct crypto_unittest_params *ut_params,
12913                 uint8_t dev_id,
12914                 const struct test_crypto_vector *reference,
12915                 enum rte_crypto_auth_operation auth_op)
12916 {
12917         struct crypto_testsuite_params *ts_params = &testsuite_params;
12918         uint8_t auth_key[reference->auth_key.len + 1];
12919         int status;
12920
12921         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
12922
12923         /* Setup Authentication Parameters */
12924         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12925         ut_params->auth_xform.auth.op = auth_op;
12926         ut_params->auth_xform.next = NULL;
12927         ut_params->auth_xform.auth.algo = reference->auth_algo;
12928         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
12929         ut_params->auth_xform.auth.key.data = auth_key;
12930         ut_params->auth_xform.auth.digest_length = reference->digest.len;
12931
12932         /* Create Crypto session*/
12933         ut_params->sess = rte_cryptodev_sym_session_create(
12934                         ts_params->session_mpool);
12935         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12936
12937         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
12938                                 &ut_params->auth_xform,
12939                                 ts_params->session_priv_mpool);
12940
12941         return status;
12942 }
12943
12944 static int
12945 create_auth_cipher_session(struct crypto_unittest_params *ut_params,
12946                 uint8_t dev_id,
12947                 const struct test_crypto_vector *reference,
12948                 enum rte_crypto_auth_operation auth_op,
12949                 enum rte_crypto_cipher_operation cipher_op)
12950 {
12951         struct crypto_testsuite_params *ts_params = &testsuite_params;
12952         uint8_t cipher_key[reference->cipher_key.len + 1];
12953         uint8_t auth_key[reference->auth_key.len + 1];
12954         int status;
12955
12956         memcpy(cipher_key, reference->cipher_key.data,
12957                         reference->cipher_key.len);
12958         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
12959
12960         /* Setup Authentication Parameters */
12961         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12962         ut_params->auth_xform.auth.op = auth_op;
12963         ut_params->auth_xform.auth.algo = reference->auth_algo;
12964         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
12965         ut_params->auth_xform.auth.key.data = auth_key;
12966         ut_params->auth_xform.auth.digest_length = reference->digest.len;
12967
12968         if (reference->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) {
12969                 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
12970                 ut_params->auth_xform.auth.iv.length = reference->iv.len;
12971         } else {
12972                 ut_params->auth_xform.next = &ut_params->cipher_xform;
12973
12974                 /* Setup Cipher Parameters */
12975                 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12976                 ut_params->cipher_xform.next = NULL;
12977                 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
12978                 ut_params->cipher_xform.cipher.op = cipher_op;
12979                 ut_params->cipher_xform.cipher.key.data = cipher_key;
12980                 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
12981                 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
12982                 ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
12983         }
12984
12985         /* Create Crypto session*/
12986         ut_params->sess = rte_cryptodev_sym_session_create(
12987                         ts_params->session_mpool);
12988         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12989
12990         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
12991                                 &ut_params->auth_xform,
12992                                 ts_params->session_priv_mpool);
12993
12994         return status;
12995 }
12996
12997 static int
12998 create_auth_operation(struct crypto_testsuite_params *ts_params,
12999                 struct crypto_unittest_params *ut_params,
13000                 const struct test_crypto_vector *reference,
13001                 unsigned int auth_generate)
13002 {
13003         /* Generate Crypto op data structure */
13004         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
13005                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
13006         TEST_ASSERT_NOT_NULL(ut_params->op,
13007                         "Failed to allocate pktmbuf offload");
13008
13009         /* Set crypto operation data parameters */
13010         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
13011
13012         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
13013
13014         /* set crypto operation source mbuf */
13015         sym_op->m_src = ut_params->ibuf;
13016
13017         /* digest */
13018         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
13019                         ut_params->ibuf, reference->digest.len);
13020
13021         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
13022                         "no room to append auth tag");
13023
13024         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
13025                         ut_params->ibuf, reference->plaintext.len);
13026
13027         if (auth_generate)
13028                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
13029         else
13030                 memcpy(sym_op->auth.digest.data,
13031                                 reference->digest.data,
13032                                 reference->digest.len);
13033
13034         debug_hexdump(stdout, "digest:",
13035                         sym_op->auth.digest.data,
13036                         reference->digest.len);
13037
13038         sym_op->auth.data.length = reference->plaintext.len;
13039         sym_op->auth.data.offset = 0;
13040
13041         return 0;
13042 }
13043
13044 static int
13045 create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
13046                 struct crypto_unittest_params *ut_params,
13047                 const struct test_crypto_vector *reference,
13048                 unsigned int auth_generate)
13049 {
13050         /* Generate Crypto op data structure */
13051         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
13052                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
13053         TEST_ASSERT_NOT_NULL(ut_params->op,
13054                         "Failed to allocate pktmbuf offload");
13055
13056         /* Set crypto operation data parameters */
13057         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
13058
13059         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
13060
13061         /* set crypto operation source mbuf */
13062         sym_op->m_src = ut_params->ibuf;
13063
13064         /* digest */
13065         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
13066                         ut_params->ibuf, reference->digest.len);
13067
13068         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
13069                         "no room to append auth tag");
13070
13071         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
13072                         ut_params->ibuf, reference->ciphertext.len);
13073
13074         if (auth_generate)
13075                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
13076         else
13077                 memcpy(sym_op->auth.digest.data,
13078                                 reference->digest.data,
13079                                 reference->digest.len);
13080
13081         debug_hexdump(stdout, "digest:",
13082                         sym_op->auth.digest.data,
13083                         reference->digest.len);
13084
13085         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
13086                         reference->iv.data, reference->iv.len);
13087
13088         sym_op->cipher.data.length = 0;
13089         sym_op->cipher.data.offset = 0;
13090
13091         sym_op->auth.data.length = reference->plaintext.len;
13092         sym_op->auth.data.offset = 0;
13093
13094         return 0;
13095 }
13096
13097 static int
13098 create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
13099                 struct crypto_unittest_params *ut_params,
13100                 const struct test_crypto_vector *reference,
13101                 unsigned int auth_generate)
13102 {
13103         /* Generate Crypto op data structure */
13104         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
13105                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
13106         TEST_ASSERT_NOT_NULL(ut_params->op,
13107                         "Failed to allocate pktmbuf offload");
13108
13109         /* Set crypto operation data parameters */
13110         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
13111
13112         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
13113
13114         /* set crypto operation source mbuf */
13115         sym_op->m_src = ut_params->ibuf;
13116
13117         /* digest */
13118         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
13119                         ut_params->ibuf, reference->digest.len);
13120
13121         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
13122                         "no room to append auth tag");
13123
13124         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
13125                         ut_params->ibuf, reference->ciphertext.len);
13126
13127         if (auth_generate)
13128                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
13129         else
13130                 memcpy(sym_op->auth.digest.data,
13131                                 reference->digest.data,
13132                                 reference->digest.len);
13133
13134         debug_hexdump(stdout, "digest:",
13135                         sym_op->auth.digest.data,
13136                         reference->digest.len);
13137
13138         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
13139                         reference->iv.data, reference->iv.len);
13140
13141         sym_op->cipher.data.length = reference->cipher_len;
13142         sym_op->cipher.data.offset = reference->cipher_offset;
13143
13144         sym_op->auth.data.length = reference->plaintext.len;
13145         sym_op->auth.data.offset = reference->auth_offset;
13146
13147         return 0;
13148 }
13149
13150 static int
13151 create_auth_verify_operation(struct crypto_testsuite_params *ts_params,
13152                 struct crypto_unittest_params *ut_params,
13153                 const struct test_crypto_vector *reference)
13154 {
13155         return create_auth_operation(ts_params, ut_params, reference, 0);
13156 }
13157
13158 static int
13159 create_auth_verify_GMAC_operation(
13160                 struct crypto_testsuite_params *ts_params,
13161                 struct crypto_unittest_params *ut_params,
13162                 const struct test_crypto_vector *reference)
13163 {
13164         return create_auth_GMAC_operation(ts_params, ut_params, reference, 0);
13165 }
13166
13167 static int
13168 create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params,
13169                 struct crypto_unittest_params *ut_params,
13170                 const struct test_crypto_vector *reference)
13171 {
13172         return create_cipher_auth_operation(ts_params, ut_params, reference, 0);
13173 }
13174
13175 static int
13176 test_authentication_verify_fail_when_data_corruption(
13177                 struct crypto_testsuite_params *ts_params,
13178                 struct crypto_unittest_params *ut_params,
13179                 const struct test_crypto_vector *reference,
13180                 unsigned int data_corrupted)
13181 {
13182         int retval;
13183
13184         uint8_t *plaintext;
13185         struct rte_cryptodev_info dev_info;
13186
13187         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13188         uint64_t feat_flags = dev_info.feature_flags;
13189
13190         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13191                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13192                 printf("Device doesn't support RAW data-path APIs.\n");
13193                 return TEST_SKIPPED;
13194         }
13195
13196         /* Verify the capabilities */
13197         struct rte_cryptodev_sym_capability_idx cap_idx;
13198         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13199         cap_idx.algo.auth = reference->auth_algo;
13200         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13201                         &cap_idx) == NULL)
13202                 return TEST_SKIPPED;
13203
13204
13205         /* Create session */
13206         retval = create_auth_session(ut_params,
13207                         ts_params->valid_devs[0],
13208                         reference,
13209                         RTE_CRYPTO_AUTH_OP_VERIFY);
13210
13211         if (retval == -ENOTSUP)
13212                 return TEST_SKIPPED;
13213         if (retval < 0)
13214                 return retval;
13215
13216         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13217         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13218                         "Failed to allocate input buffer in mempool");
13219
13220         /* clear mbuf payload */
13221         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13222                         rte_pktmbuf_tailroom(ut_params->ibuf));
13223
13224         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13225                         reference->plaintext.len);
13226         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
13227         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
13228
13229         debug_hexdump(stdout, "plaintext:", plaintext,
13230                 reference->plaintext.len);
13231
13232         /* Create operation */
13233         retval = create_auth_verify_operation(ts_params, ut_params, reference);
13234
13235         if (retval < 0)
13236                 return retval;
13237
13238         if (data_corrupted)
13239                 data_corruption(plaintext);
13240         else
13241                 tag_corruption(plaintext, reference->plaintext.len);
13242
13243         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
13244                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13245                         ut_params->op);
13246                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
13247                         RTE_CRYPTO_OP_STATUS_SUCCESS,
13248                         "authentication not failed");
13249         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13250                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13251                                 ut_params->op, 0, 1, 0, 0);
13252         else {
13253                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13254                         ut_params->op);
13255         }
13256         if (ut_params->op == NULL)
13257                 return 0;
13258         else if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS)
13259                 return 0;
13260
13261         return -1;
13262 }
13263
13264 static int
13265 test_authentication_verify_GMAC_fail_when_corruption(
13266                 struct crypto_testsuite_params *ts_params,
13267                 struct crypto_unittest_params *ut_params,
13268                 const struct test_crypto_vector *reference,
13269                 unsigned int data_corrupted)
13270 {
13271         int retval;
13272         uint8_t *plaintext;
13273         struct rte_cryptodev_info dev_info;
13274
13275         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13276         uint64_t feat_flags = dev_info.feature_flags;
13277
13278         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13279                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13280                 printf("Device doesn't support RAW data-path APIs.\n");
13281                 return TEST_SKIPPED;
13282         }
13283
13284         /* Verify the capabilities */
13285         struct rte_cryptodev_sym_capability_idx cap_idx;
13286         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13287         cap_idx.algo.auth = reference->auth_algo;
13288         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13289                         &cap_idx) == NULL)
13290                 return TEST_SKIPPED;
13291
13292         /* Create session */
13293         retval = create_auth_cipher_session(ut_params,
13294                         ts_params->valid_devs[0],
13295                         reference,
13296                         RTE_CRYPTO_AUTH_OP_VERIFY,
13297                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
13298         if (retval < 0)
13299                 return retval;
13300
13301         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13302         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13303                         "Failed to allocate input buffer in mempool");
13304
13305         /* clear mbuf payload */
13306         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13307                         rte_pktmbuf_tailroom(ut_params->ibuf));
13308
13309         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13310                         reference->plaintext.len);
13311         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
13312         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
13313
13314         debug_hexdump(stdout, "plaintext:", plaintext,
13315                 reference->plaintext.len);
13316
13317         /* Create operation */
13318         retval = create_auth_verify_GMAC_operation(ts_params,
13319                         ut_params,
13320                         reference);
13321
13322         if (retval < 0)
13323                 return retval;
13324
13325         if (data_corrupted)
13326                 data_corruption(plaintext);
13327         else
13328                 tag_corruption(plaintext, reference->aad.len);
13329
13330         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
13331                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13332                         ut_params->op);
13333                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
13334                         RTE_CRYPTO_OP_STATUS_SUCCESS,
13335                         "authentication not failed");
13336         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13337                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13338                                 ut_params->op, 0, 1, 0, 0);
13339         else {
13340                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13341                         ut_params->op);
13342                 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
13343         }
13344
13345         return 0;
13346 }
13347
13348 static int
13349 test_authenticated_decryption_fail_when_corruption(
13350                 struct crypto_testsuite_params *ts_params,
13351                 struct crypto_unittest_params *ut_params,
13352                 const struct test_crypto_vector *reference,
13353                 unsigned int data_corrupted)
13354 {
13355         int retval;
13356
13357         uint8_t *ciphertext;
13358         struct rte_cryptodev_info dev_info;
13359
13360         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13361         uint64_t feat_flags = dev_info.feature_flags;
13362
13363         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13364                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13365                 printf("Device doesn't support RAW data-path APIs.\n");
13366                 return TEST_SKIPPED;
13367         }
13368
13369         /* Verify the capabilities */
13370         struct rte_cryptodev_sym_capability_idx cap_idx;
13371         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13372         cap_idx.algo.auth = reference->auth_algo;
13373         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13374                         &cap_idx) == NULL)
13375                 return TEST_SKIPPED;
13376         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13377         cap_idx.algo.cipher = reference->crypto_algo;
13378         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13379                         &cap_idx) == NULL)
13380                 return TEST_SKIPPED;
13381
13382         /* Create session */
13383         retval = create_auth_cipher_session(ut_params,
13384                         ts_params->valid_devs[0],
13385                         reference,
13386                         RTE_CRYPTO_AUTH_OP_VERIFY,
13387                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
13388
13389         if (retval == -ENOTSUP)
13390                 return TEST_SKIPPED;
13391         if (retval < 0)
13392                 return retval;
13393
13394         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13395         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13396                         "Failed to allocate input buffer in mempool");
13397
13398         /* clear mbuf payload */
13399         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13400                         rte_pktmbuf_tailroom(ut_params->ibuf));
13401
13402         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13403                         reference->ciphertext.len);
13404         TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
13405         memcpy(ciphertext, reference->ciphertext.data,
13406                         reference->ciphertext.len);
13407
13408         /* Create operation */
13409         retval = create_cipher_auth_verify_operation(ts_params,
13410                         ut_params,
13411                         reference);
13412
13413         if (retval < 0)
13414                 return retval;
13415
13416         if (data_corrupted)
13417                 data_corruption(ciphertext);
13418         else
13419                 tag_corruption(ciphertext, reference->ciphertext.len);
13420
13421         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
13422                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13423                         ut_params->op);
13424                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
13425                         RTE_CRYPTO_OP_STATUS_SUCCESS,
13426                         "authentication not failed");
13427         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13428                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13429                                 ut_params->op, 1, 1, 0, 0);
13430         else {
13431                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13432                         ut_params->op);
13433                 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
13434         }
13435
13436         return 0;
13437 }
13438
13439 static int
13440 test_authenticated_encrypt_with_esn(
13441                 struct crypto_testsuite_params *ts_params,
13442                 struct crypto_unittest_params *ut_params,
13443                 const struct test_crypto_vector *reference)
13444 {
13445         int retval;
13446
13447         uint8_t *authciphertext, *plaintext, *auth_tag;
13448         uint16_t plaintext_pad_len;
13449         uint8_t cipher_key[reference->cipher_key.len + 1];
13450         uint8_t auth_key[reference->auth_key.len + 1];
13451         struct rte_cryptodev_info dev_info;
13452         int status;
13453
13454         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13455         uint64_t feat_flags = dev_info.feature_flags;
13456
13457         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13458                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13459                 printf("Device doesn't support RAW data-path APIs.\n");
13460                 return TEST_SKIPPED;
13461         }
13462
13463         /* Verify the capabilities */
13464         struct rte_cryptodev_sym_capability_idx cap_idx;
13465         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13466         cap_idx.algo.auth = reference->auth_algo;
13467         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13468                         &cap_idx) == NULL)
13469                 return TEST_SKIPPED;
13470         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13471         cap_idx.algo.cipher = reference->crypto_algo;
13472         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13473                         &cap_idx) == NULL)
13474                 return TEST_SKIPPED;
13475
13476         /* Create session */
13477         memcpy(cipher_key, reference->cipher_key.data,
13478                         reference->cipher_key.len);
13479         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
13480
13481         /* Setup Cipher Parameters */
13482         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13483         ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
13484         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
13485         ut_params->cipher_xform.cipher.key.data = cipher_key;
13486         ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
13487         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
13488         ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
13489
13490         ut_params->cipher_xform.next = &ut_params->auth_xform;
13491
13492         /* Setup Authentication Parameters */
13493         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13494         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
13495         ut_params->auth_xform.auth.algo = reference->auth_algo;
13496         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
13497         ut_params->auth_xform.auth.key.data = auth_key;
13498         ut_params->auth_xform.auth.digest_length = reference->digest.len;
13499         ut_params->auth_xform.next = NULL;
13500
13501         /* Create Crypto session*/
13502         ut_params->sess = rte_cryptodev_sym_session_create(
13503                         ts_params->session_mpool);
13504         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
13505
13506         status = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
13507                                 ut_params->sess,
13508                                 &ut_params->cipher_xform,
13509                                 ts_params->session_priv_mpool);
13510
13511         if (status == -ENOTSUP)
13512                 return TEST_SKIPPED;
13513
13514         TEST_ASSERT_EQUAL(status, 0, "Session init failed");
13515
13516         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13517         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13518                         "Failed to allocate input buffer in mempool");
13519
13520         /* clear mbuf payload */
13521         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13522                         rte_pktmbuf_tailroom(ut_params->ibuf));
13523
13524         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13525                         reference->plaintext.len);
13526         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
13527         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
13528
13529         /* Create operation */
13530         retval = create_cipher_auth_operation(ts_params,
13531                         ut_params,
13532                         reference, 0);
13533
13534         if (retval < 0)
13535                 return retval;
13536
13537         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13538                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13539                         ut_params->op);
13540         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13541                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13542                                 ut_params->op, 1, 1, 0, 0);
13543         else
13544                 ut_params->op = process_crypto_request(
13545                         ts_params->valid_devs[0], ut_params->op);
13546
13547         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
13548
13549         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
13550                         "crypto op processing failed");
13551
13552         plaintext_pad_len = RTE_ALIGN_CEIL(reference->plaintext.len, 16);
13553
13554         authciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
13555                         ut_params->op->sym->auth.data.offset);
13556         auth_tag = authciphertext + plaintext_pad_len;
13557         debug_hexdump(stdout, "ciphertext:", authciphertext,
13558                         reference->ciphertext.len);
13559         debug_hexdump(stdout, "auth tag:", auth_tag, reference->digest.len);
13560
13561         /* Validate obuf */
13562         TEST_ASSERT_BUFFERS_ARE_EQUAL(
13563                         authciphertext,
13564                         reference->ciphertext.data,
13565                         reference->ciphertext.len,
13566                         "Ciphertext data not as expected");
13567
13568         TEST_ASSERT_BUFFERS_ARE_EQUAL(
13569                         auth_tag,
13570                         reference->digest.data,
13571                         reference->digest.len,
13572                         "Generated digest not as expected");
13573
13574         return TEST_SUCCESS;
13575
13576 }
13577
13578 static int
13579 test_authenticated_decrypt_with_esn(
13580                 struct crypto_testsuite_params *ts_params,
13581                 struct crypto_unittest_params *ut_params,
13582                 const struct test_crypto_vector *reference)
13583 {
13584         int retval;
13585
13586         uint8_t *ciphertext;
13587         uint8_t cipher_key[reference->cipher_key.len + 1];
13588         uint8_t auth_key[reference->auth_key.len + 1];
13589         struct rte_cryptodev_info dev_info;
13590
13591         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13592         uint64_t feat_flags = dev_info.feature_flags;
13593
13594         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13595                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13596                 printf("Device doesn't support RAW data-path APIs.\n");
13597                 return TEST_SKIPPED;
13598         }
13599
13600         /* Verify the capabilities */
13601         struct rte_cryptodev_sym_capability_idx cap_idx;
13602         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13603         cap_idx.algo.auth = reference->auth_algo;
13604         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13605                         &cap_idx) == NULL)
13606                 return TEST_SKIPPED;
13607         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13608         cap_idx.algo.cipher = reference->crypto_algo;
13609         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13610                         &cap_idx) == NULL)
13611                 return TEST_SKIPPED;
13612
13613         /* Create session */
13614         memcpy(cipher_key, reference->cipher_key.data,
13615                         reference->cipher_key.len);
13616         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
13617
13618         /* Setup Authentication Parameters */
13619         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13620         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
13621         ut_params->auth_xform.auth.algo = reference->auth_algo;
13622         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
13623         ut_params->auth_xform.auth.key.data = auth_key;
13624         ut_params->auth_xform.auth.digest_length = reference->digest.len;
13625         ut_params->auth_xform.next = &ut_params->cipher_xform;
13626
13627         /* Setup Cipher Parameters */
13628         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13629         ut_params->cipher_xform.next = NULL;
13630         ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
13631         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
13632         ut_params->cipher_xform.cipher.key.data = cipher_key;
13633         ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
13634         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
13635         ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
13636
13637         /* Create Crypto session*/
13638         ut_params->sess = rte_cryptodev_sym_session_create(
13639                         ts_params->session_mpool);
13640         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
13641
13642         retval = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
13643                                 ut_params->sess,
13644                                 &ut_params->auth_xform,
13645                                 ts_params->session_priv_mpool);
13646
13647         if (retval == -ENOTSUP)
13648                 return TEST_SKIPPED;
13649
13650         TEST_ASSERT_EQUAL(retval, 0, "Session init failed");
13651
13652         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13653         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13654                         "Failed to allocate input buffer in mempool");
13655
13656         /* clear mbuf payload */
13657         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13658                         rte_pktmbuf_tailroom(ut_params->ibuf));
13659
13660         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13661                         reference->ciphertext.len);
13662         TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
13663         memcpy(ciphertext, reference->ciphertext.data,
13664                         reference->ciphertext.len);
13665
13666         /* Create operation */
13667         retval = create_cipher_auth_verify_operation(ts_params,
13668                         ut_params,
13669                         reference);
13670
13671         if (retval < 0)
13672                 return retval;
13673
13674         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13675                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13676                         ut_params->op);
13677         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13678                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13679                                 ut_params->op, 1, 1, 0, 0);
13680         else
13681                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13682                         ut_params->op);
13683
13684         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
13685         TEST_ASSERT_EQUAL(ut_params->op->status,
13686                         RTE_CRYPTO_OP_STATUS_SUCCESS,
13687                         "crypto op processing passed");
13688
13689         ut_params->obuf = ut_params->op->sym->m_src;
13690         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
13691
13692         return 0;
13693 }
13694
13695 static int
13696 create_aead_operation_SGL(enum rte_crypto_aead_operation op,
13697                 const struct aead_test_data *tdata,
13698                 void *digest_mem, uint64_t digest_phys)
13699 {
13700         struct crypto_testsuite_params *ts_params = &testsuite_params;
13701         struct crypto_unittest_params *ut_params = &unittest_params;
13702
13703         const unsigned int auth_tag_len = tdata->auth_tag.len;
13704         const unsigned int iv_len = tdata->iv.len;
13705         unsigned int aad_len = tdata->aad.len;
13706         unsigned int aad_len_pad = 0;
13707
13708         /* Generate Crypto op data structure */
13709         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
13710                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
13711         TEST_ASSERT_NOT_NULL(ut_params->op,
13712                 "Failed to allocate symmetric crypto operation struct");
13713
13714         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
13715
13716         sym_op->aead.digest.data = digest_mem;
13717
13718         TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
13719                         "no room to append digest");
13720
13721         sym_op->aead.digest.phys_addr = digest_phys;
13722
13723         if (op == RTE_CRYPTO_AEAD_OP_DECRYPT) {
13724                 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
13725                                 auth_tag_len);
13726                 debug_hexdump(stdout, "digest:",
13727                                 sym_op->aead.digest.data,
13728                                 auth_tag_len);
13729         }
13730
13731         /* Append aad data */
13732         if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
13733                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
13734                                 uint8_t *, IV_OFFSET);
13735
13736                 /* Copy IV 1 byte after the IV pointer, according to the API */
13737                 rte_memcpy(iv_ptr + 1, tdata->iv.data, iv_len);
13738
13739                 aad_len = RTE_ALIGN_CEIL(aad_len + 18, 16);
13740
13741                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
13742                                 ut_params->ibuf, aad_len);
13743                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
13744                                 "no room to prepend aad");
13745                 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
13746                                 ut_params->ibuf);
13747
13748                 memset(sym_op->aead.aad.data, 0, aad_len);
13749                 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
13750                 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
13751
13752                 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
13753                 debug_hexdump(stdout, "aad:",
13754                                 sym_op->aead.aad.data, aad_len);
13755         } else {
13756                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
13757                                 uint8_t *, IV_OFFSET);
13758
13759                 rte_memcpy(iv_ptr, tdata->iv.data, iv_len);
13760
13761                 aad_len_pad = RTE_ALIGN_CEIL(aad_len, 16);
13762
13763                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
13764                                 ut_params->ibuf, aad_len_pad);
13765                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
13766                                 "no room to prepend aad");
13767                 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
13768                                 ut_params->ibuf);
13769
13770                 memset(sym_op->aead.aad.data, 0, aad_len);
13771                 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
13772
13773                 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
13774                 debug_hexdump(stdout, "aad:",
13775                                 sym_op->aead.aad.data, aad_len);
13776         }
13777
13778         sym_op->aead.data.length = tdata->plaintext.len;
13779         sym_op->aead.data.offset = aad_len_pad;
13780
13781         return 0;
13782 }
13783
13784 #define SGL_MAX_NO      16
13785
13786 static int
13787 test_authenticated_encryption_SGL(const struct aead_test_data *tdata,
13788                 const int oop, uint32_t fragsz, uint32_t fragsz_oop)
13789 {
13790         struct crypto_testsuite_params *ts_params = &testsuite_params;
13791         struct crypto_unittest_params *ut_params = &unittest_params;
13792         struct rte_mbuf *buf, *buf_oop = NULL, *buf_last_oop = NULL;
13793         int retval;
13794         int to_trn = 0;
13795         int to_trn_tbl[SGL_MAX_NO];
13796         int segs = 1;
13797         unsigned int trn_data = 0;
13798         uint8_t *plaintext, *ciphertext, *auth_tag;
13799         struct rte_cryptodev_info dev_info;
13800
13801         /* Verify the capabilities */
13802         struct rte_cryptodev_sym_capability_idx cap_idx;
13803         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
13804         cap_idx.algo.aead = tdata->algo;
13805         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13806                         &cap_idx) == NULL)
13807                 return TEST_SKIPPED;
13808
13809         /* OOP not supported with CPU crypto */
13810         if (oop && gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13811                 return TEST_SKIPPED;
13812
13813         /* Detailed check for the particular SGL support flag */
13814         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13815         if (!oop) {
13816                 unsigned int sgl_in = fragsz < tdata->plaintext.len;
13817                 if (sgl_in && (!(dev_info.feature_flags &
13818                                 RTE_CRYPTODEV_FF_IN_PLACE_SGL)))
13819                         return TEST_SKIPPED;
13820
13821                 uint64_t feat_flags = dev_info.feature_flags;
13822
13823                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13824                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13825                         printf("Device doesn't support RAW data-path APIs.\n");
13826                         return TEST_SKIPPED;
13827                 }
13828         } else {
13829                 unsigned int sgl_in = fragsz < tdata->plaintext.len;
13830                 unsigned int sgl_out = (fragsz_oop ? fragsz_oop : fragsz) <
13831                                 tdata->plaintext.len;
13832                 /* Raw data path API does not support OOP */
13833                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13834                         return TEST_SKIPPED;
13835                 if (sgl_in && !sgl_out) {
13836                         if (!(dev_info.feature_flags &
13837                                         RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT))
13838                                 return TEST_SKIPPED;
13839                 } else if (!sgl_in && sgl_out) {
13840                         if (!(dev_info.feature_flags &
13841                                         RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT))
13842                                 return TEST_SKIPPED;
13843                 } else if (sgl_in && sgl_out) {
13844                         if (!(dev_info.feature_flags &
13845                                         RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT))
13846                                 return TEST_SKIPPED;
13847                 }
13848         }
13849
13850         if (fragsz > tdata->plaintext.len)
13851                 fragsz = tdata->plaintext.len;
13852
13853         uint16_t plaintext_len = fragsz;
13854         uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
13855
13856         if (fragsz_oop > tdata->plaintext.len)
13857                 frag_size_oop = tdata->plaintext.len;
13858
13859         int ecx = 0;
13860         void *digest_mem = NULL;
13861
13862         uint32_t prepend_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
13863
13864         if (tdata->plaintext.len % fragsz != 0) {
13865                 if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO)
13866                         return 1;
13867         }       else {
13868                 if (tdata->plaintext.len / fragsz > SGL_MAX_NO)
13869                         return 1;
13870         }
13871
13872         /*
13873          * For out-op-place we need to alloc another mbuf
13874          */
13875         if (oop) {
13876                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13877                 rte_pktmbuf_append(ut_params->obuf,
13878                                 frag_size_oop + prepend_len);
13879                 buf_oop = ut_params->obuf;
13880         }
13881
13882         /* Create AEAD session */
13883         retval = create_aead_session(ts_params->valid_devs[0],
13884                         tdata->algo,
13885                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
13886                         tdata->key.data, tdata->key.len,
13887                         tdata->aad.len, tdata->auth_tag.len,
13888                         tdata->iv.len);
13889         if (retval < 0)
13890                 return retval;
13891
13892         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13893
13894         /* clear mbuf payload */
13895         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13896                         rte_pktmbuf_tailroom(ut_params->ibuf));
13897
13898         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13899                         plaintext_len);
13900
13901         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
13902
13903         trn_data += plaintext_len;
13904
13905         buf = ut_params->ibuf;
13906
13907         /*
13908          * Loop until no more fragments
13909          */
13910
13911         while (trn_data < tdata->plaintext.len) {
13912                 ++segs;
13913                 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
13914                                 (tdata->plaintext.len - trn_data) : fragsz;
13915
13916                 to_trn_tbl[ecx++] = to_trn;
13917
13918                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13919                 buf = buf->next;
13920
13921                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
13922                                 rte_pktmbuf_tailroom(buf));
13923
13924                 /* OOP */
13925                 if (oop && !fragsz_oop) {
13926                         buf_last_oop = buf_oop->next =
13927                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
13928                         buf_oop = buf_oop->next;
13929                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
13930                                         0, rte_pktmbuf_tailroom(buf_oop));
13931                         rte_pktmbuf_append(buf_oop, to_trn);
13932                 }
13933
13934                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
13935                                 to_trn);
13936
13937                 memcpy(plaintext, tdata->plaintext.data + trn_data,
13938                                 to_trn);
13939                 trn_data += to_trn;
13940                 if (trn_data  == tdata->plaintext.len) {
13941                         if (oop) {
13942                                 if (!fragsz_oop)
13943                                         digest_mem = rte_pktmbuf_append(buf_oop,
13944                                                 tdata->auth_tag.len);
13945                         } else
13946                                 digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
13947                                         tdata->auth_tag.len);
13948                 }
13949         }
13950
13951         uint64_t digest_phys = 0;
13952
13953         ut_params->ibuf->nb_segs = segs;
13954
13955         segs = 1;
13956         if (fragsz_oop && oop) {
13957                 to_trn = 0;
13958                 ecx = 0;
13959
13960                 if (frag_size_oop == tdata->plaintext.len) {
13961                         digest_mem = rte_pktmbuf_append(ut_params->obuf,
13962                                 tdata->auth_tag.len);
13963
13964                         digest_phys = rte_pktmbuf_iova_offset(
13965                                         ut_params->obuf,
13966                                         tdata->plaintext.len + prepend_len);
13967                 }
13968
13969                 trn_data = frag_size_oop;
13970                 while (trn_data < tdata->plaintext.len) {
13971                         ++segs;
13972                         to_trn =
13973                                 (tdata->plaintext.len - trn_data <
13974                                                 frag_size_oop) ?
13975                                 (tdata->plaintext.len - trn_data) :
13976                                                 frag_size_oop;
13977
13978                         to_trn_tbl[ecx++] = to_trn;
13979
13980                         buf_last_oop = buf_oop->next =
13981                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
13982                         buf_oop = buf_oop->next;
13983                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
13984                                         0, rte_pktmbuf_tailroom(buf_oop));
13985                         rte_pktmbuf_append(buf_oop, to_trn);
13986
13987                         trn_data += to_trn;
13988
13989                         if (trn_data  == tdata->plaintext.len) {
13990                                 digest_mem = rte_pktmbuf_append(buf_oop,
13991                                         tdata->auth_tag.len);
13992                         }
13993                 }
13994
13995                 ut_params->obuf->nb_segs = segs;
13996         }
13997
13998         /*
13999          * Place digest at the end of the last buffer
14000          */
14001         if (!digest_phys)
14002                 digest_phys = rte_pktmbuf_iova(buf) + to_trn;
14003         if (oop && buf_last_oop)
14004                 digest_phys = rte_pktmbuf_iova(buf_last_oop) + to_trn;
14005
14006         if (!digest_mem && !oop) {
14007                 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
14008                                 + tdata->auth_tag.len);
14009                 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
14010                                 tdata->plaintext.len);
14011         }
14012
14013         /* Create AEAD operation */
14014         retval = create_aead_operation_SGL(RTE_CRYPTO_AEAD_OP_ENCRYPT,
14015                         tdata, digest_mem, digest_phys);
14016
14017         if (retval < 0)
14018                 return retval;
14019
14020         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
14021
14022         ut_params->op->sym->m_src = ut_params->ibuf;
14023         if (oop)
14024                 ut_params->op->sym->m_dst = ut_params->obuf;
14025
14026         /* Process crypto operation */
14027         if (oop == IN_PLACE &&
14028                         gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
14029                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
14030         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
14031                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
14032                                 ut_params->op, 0, 0, 0, 0);
14033         else
14034                 TEST_ASSERT_NOT_NULL(
14035                         process_crypto_request(ts_params->valid_devs[0],
14036                         ut_params->op), "failed to process sym crypto op");
14037
14038         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
14039                         "crypto op processing failed");
14040
14041
14042         ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
14043                         uint8_t *, prepend_len);
14044         if (oop) {
14045                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
14046                                 uint8_t *, prepend_len);
14047         }
14048
14049         if (fragsz_oop)
14050                 fragsz = fragsz_oop;
14051
14052         TEST_ASSERT_BUFFERS_ARE_EQUAL(
14053                         ciphertext,
14054                         tdata->ciphertext.data,
14055                         fragsz,
14056                         "Ciphertext data not as expected");
14057
14058         buf = ut_params->op->sym->m_src->next;
14059         if (oop)
14060                 buf = ut_params->op->sym->m_dst->next;
14061
14062         unsigned int off = fragsz;
14063
14064         ecx = 0;
14065         while (buf) {
14066                 ciphertext = rte_pktmbuf_mtod(buf,
14067                                 uint8_t *);
14068
14069                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
14070                                 ciphertext,
14071                                 tdata->ciphertext.data + off,
14072                                 to_trn_tbl[ecx],
14073                                 "Ciphertext data not as expected");
14074
14075                 off += to_trn_tbl[ecx++];
14076                 buf = buf->next;
14077         }
14078
14079         auth_tag = digest_mem;
14080         TEST_ASSERT_BUFFERS_ARE_EQUAL(
14081                         auth_tag,
14082                         tdata->auth_tag.data,
14083                         tdata->auth_tag.len,
14084                         "Generated auth tag not as expected");
14085
14086         return 0;
14087 }
14088
14089 static int
14090 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void)
14091 {
14092         return test_authenticated_encryption_SGL(
14093                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 400, 400);
14094 }
14095
14096 static int
14097 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B(void)
14098 {
14099         return test_authenticated_encryption_SGL(
14100                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 1500, 2000);
14101 }
14102
14103 static int
14104 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void)
14105 {
14106         return test_authenticated_encryption_SGL(
14107                         &gcm_test_case_8, OUT_OF_PLACE, 400,
14108                         gcm_test_case_8.plaintext.len);
14109 }
14110
14111 static int
14112 test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void)
14113 {
14114         /* This test is not for OPENSSL PMD */
14115         if (gbl_driver_id == rte_cryptodev_driver_id_get(
14116                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)))
14117                 return TEST_SKIPPED;
14118
14119         return test_authenticated_encryption_SGL(
14120                         &gcm_test_case_SGL_1, IN_PLACE, 1500, 0);
14121 }
14122
14123 static int
14124 test_authentication_verify_fail_when_data_corrupted(
14125                 struct crypto_testsuite_params *ts_params,
14126                 struct crypto_unittest_params *ut_params,
14127                 const struct test_crypto_vector *reference)
14128 {
14129         return test_authentication_verify_fail_when_data_corruption(
14130                         ts_params, ut_params, reference, 1);
14131 }
14132
14133 static int
14134 test_authentication_verify_fail_when_tag_corrupted(
14135                 struct crypto_testsuite_params *ts_params,
14136                 struct crypto_unittest_params *ut_params,
14137                 const struct test_crypto_vector *reference)
14138 {
14139         return test_authentication_verify_fail_when_data_corruption(
14140                         ts_params, ut_params, reference, 0);
14141 }
14142
14143 static int
14144 test_authentication_verify_GMAC_fail_when_data_corrupted(
14145                 struct crypto_testsuite_params *ts_params,
14146                 struct crypto_unittest_params *ut_params,
14147                 const struct test_crypto_vector *reference)
14148 {
14149         return test_authentication_verify_GMAC_fail_when_corruption(
14150                         ts_params, ut_params, reference, 1);
14151 }
14152
14153 static int
14154 test_authentication_verify_GMAC_fail_when_tag_corrupted(
14155                 struct crypto_testsuite_params *ts_params,
14156                 struct crypto_unittest_params *ut_params,
14157                 const struct test_crypto_vector *reference)
14158 {
14159         return test_authentication_verify_GMAC_fail_when_corruption(
14160                         ts_params, ut_params, reference, 0);
14161 }
14162
14163 static int
14164 test_authenticated_decryption_fail_when_data_corrupted(
14165                 struct crypto_testsuite_params *ts_params,
14166                 struct crypto_unittest_params *ut_params,
14167                 const struct test_crypto_vector *reference)
14168 {
14169         return test_authenticated_decryption_fail_when_corruption(
14170                         ts_params, ut_params, reference, 1);
14171 }
14172
14173 static int
14174 test_authenticated_decryption_fail_when_tag_corrupted(
14175                 struct crypto_testsuite_params *ts_params,
14176                 struct crypto_unittest_params *ut_params,
14177                 const struct test_crypto_vector *reference)
14178 {
14179         return test_authenticated_decryption_fail_when_corruption(
14180                         ts_params, ut_params, reference, 0);
14181 }
14182
14183 static int
14184 authentication_verify_HMAC_SHA1_fail_data_corrupt(void)
14185 {
14186         return test_authentication_verify_fail_when_data_corrupted(
14187                         &testsuite_params, &unittest_params,
14188                         &hmac_sha1_test_crypto_vector);
14189 }
14190
14191 static int
14192 authentication_verify_HMAC_SHA1_fail_tag_corrupt(void)
14193 {
14194         return test_authentication_verify_fail_when_tag_corrupted(
14195                         &testsuite_params, &unittest_params,
14196                         &hmac_sha1_test_crypto_vector);
14197 }
14198
14199 static int
14200 authentication_verify_AES128_GMAC_fail_data_corrupt(void)
14201 {
14202         return test_authentication_verify_GMAC_fail_when_data_corrupted(
14203                         &testsuite_params, &unittest_params,
14204                         &aes128_gmac_test_vector);
14205 }
14206
14207 static int
14208 authentication_verify_AES128_GMAC_fail_tag_corrupt(void)
14209 {
14210         return test_authentication_verify_GMAC_fail_when_tag_corrupted(
14211                         &testsuite_params, &unittest_params,
14212                         &aes128_gmac_test_vector);
14213 }
14214
14215 static int
14216 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void)
14217 {
14218         return test_authenticated_decryption_fail_when_data_corrupted(
14219                         &testsuite_params,
14220                         &unittest_params,
14221                         &aes128cbc_hmac_sha1_test_vector);
14222 }
14223
14224 static int
14225 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void)
14226 {
14227         return test_authenticated_decryption_fail_when_tag_corrupted(
14228                         &testsuite_params,
14229                         &unittest_params,
14230                         &aes128cbc_hmac_sha1_test_vector);
14231 }
14232
14233 static int
14234 auth_encrypt_AES128CBC_HMAC_SHA1_esn_check(void)
14235 {
14236         return test_authenticated_encrypt_with_esn(
14237                         &testsuite_params,
14238                         &unittest_params,
14239                         &aes128cbc_hmac_sha1_aad_test_vector);
14240 }
14241
14242 static int
14243 auth_decrypt_AES128CBC_HMAC_SHA1_esn_check(void)
14244 {
14245         return test_authenticated_decrypt_with_esn(
14246                         &testsuite_params,
14247                         &unittest_params,
14248                         &aes128cbc_hmac_sha1_aad_test_vector);
14249 }
14250
14251 static int
14252 test_chacha20_poly1305_encrypt_test_case_rfc8439(void)
14253 {
14254         return test_authenticated_encryption(&chacha20_poly1305_case_rfc8439);
14255 }
14256
14257 static int
14258 test_chacha20_poly1305_decrypt_test_case_rfc8439(void)
14259 {
14260         return test_authenticated_decryption(&chacha20_poly1305_case_rfc8439);
14261 }
14262
14263 static int
14264 test_chacha20_poly1305_encrypt_SGL_out_of_place(void)
14265 {
14266         return test_authenticated_encryption_SGL(
14267                 &chacha20_poly1305_case_2, OUT_OF_PLACE, 32,
14268                 chacha20_poly1305_case_2.plaintext.len);
14269 }
14270
14271 #ifdef RTE_CRYPTO_SCHEDULER
14272
14273 /* global AESNI worker IDs for the scheduler test */
14274 uint8_t aesni_ids[2];
14275
14276 static int
14277 scheduler_testsuite_setup(void)
14278 {
14279         uint32_t i = 0;
14280         int32_t nb_devs, ret;
14281         char vdev_args[VDEV_ARGS_SIZE] = {""};
14282         char temp_str[VDEV_ARGS_SIZE] = {"mode=multi-core,"
14283                 "ordering=enable,name=cryptodev_test_scheduler,corelist="};
14284         uint16_t worker_core_count = 0;
14285         uint16_t socket_id = 0;
14286
14287         if (gbl_driver_id == rte_cryptodev_driver_id_get(
14288                         RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD))) {
14289
14290                 /* Identify the Worker Cores
14291                  * Use 2 worker cores for the device args
14292                  */
14293                 RTE_LCORE_FOREACH_WORKER(i) {
14294                         if (worker_core_count > 1)
14295                                 break;
14296                         snprintf(vdev_args, sizeof(vdev_args),
14297                                         "%s%d", temp_str, i);
14298                         strcpy(temp_str, vdev_args);
14299                         strlcat(temp_str, ";", sizeof(temp_str));
14300                         worker_core_count++;
14301                         socket_id = rte_lcore_to_socket_id(i);
14302                 }
14303                 if (worker_core_count != 2) {
14304                         RTE_LOG(ERR, USER1,
14305                                 "Cryptodev scheduler test require at least "
14306                                 "two worker cores to run. "
14307                                 "Please use the correct coremask.\n");
14308                         return TEST_FAILED;
14309                 }
14310                 strcpy(temp_str, vdev_args);
14311                 snprintf(vdev_args, sizeof(vdev_args), "%s,socket_id=%d",
14312                                 temp_str, socket_id);
14313                 RTE_LOG(DEBUG, USER1, "vdev_args: %s\n", vdev_args);
14314                 nb_devs = rte_cryptodev_device_count_by_driver(
14315                                 rte_cryptodev_driver_id_get(
14316                                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)));
14317                 if (nb_devs < 1) {
14318                         ret = rte_vdev_init(
14319                                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),
14320                                         vdev_args);
14321                         TEST_ASSERT(ret == 0,
14322                                 "Failed to create instance %u of pmd : %s",
14323                                 i, RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
14324                 }
14325         }
14326         return testsuite_setup();
14327 }
14328
14329 static int
14330 test_scheduler_attach_worker_op(void)
14331 {
14332         struct crypto_testsuite_params *ts_params = &testsuite_params;
14333         uint8_t sched_id = ts_params->valid_devs[0];
14334         uint32_t i, nb_devs_attached = 0;
14335         int ret;
14336         char vdev_name[32];
14337         unsigned int count = rte_cryptodev_count();
14338
14339         /* create 2 AESNI_MB vdevs on top of existing devices */
14340         for (i = count; i < count + 2; i++) {
14341                 snprintf(vdev_name, sizeof(vdev_name), "%s_%u",
14342                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD),
14343                                 i);
14344                 ret = rte_vdev_init(vdev_name, NULL);
14345
14346                 TEST_ASSERT(ret == 0,
14347                         "Failed to create instance %u of"
14348                         " pmd : %s",
14349                         i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
14350
14351                 if (ret < 0) {
14352                         RTE_LOG(ERR, USER1,
14353                                 "Failed to create 2 AESNI MB PMDs.\n");
14354                         return TEST_SKIPPED;
14355                 }
14356         }
14357
14358         /* attach 2 AESNI_MB cdevs */
14359         for (i = count; i < count + 2; i++) {
14360                 struct rte_cryptodev_info info;
14361                 unsigned int session_size;
14362
14363                 rte_cryptodev_info_get(i, &info);
14364                 if (info.driver_id != rte_cryptodev_driver_id_get(
14365                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)))
14366                         continue;
14367
14368                 session_size = rte_cryptodev_sym_get_private_session_size(i);
14369                 /*
14370                  * Create the session mempool again, since now there are new devices
14371                  * to use the mempool.
14372                  */
14373                 if (ts_params->session_mpool) {
14374                         rte_mempool_free(ts_params->session_mpool);
14375                         ts_params->session_mpool = NULL;
14376                 }
14377                 if (ts_params->session_priv_mpool) {
14378                         rte_mempool_free(ts_params->session_priv_mpool);
14379                         ts_params->session_priv_mpool = NULL;
14380                 }
14381
14382                 if (info.sym.max_nb_sessions != 0 &&
14383                                 info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
14384                         RTE_LOG(ERR, USER1,
14385                                         "Device does not support "
14386                                         "at least %u sessions\n",
14387                                         MAX_NB_SESSIONS);
14388                         return TEST_FAILED;
14389                 }
14390                 /*
14391                  * Create mempool with maximum number of sessions,
14392                  * to include the session headers
14393                  */
14394                 if (ts_params->session_mpool == NULL) {
14395                         ts_params->session_mpool =
14396                                 rte_cryptodev_sym_session_pool_create(
14397                                                 "test_sess_mp",
14398                                                 MAX_NB_SESSIONS, 0, 0, 0,
14399                                                 SOCKET_ID_ANY);
14400                         TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
14401                                         "session mempool allocation failed");
14402                 }
14403
14404                 /*
14405                  * Create mempool with maximum number of sessions,
14406                  * to include device specific session private data
14407                  */
14408                 if (ts_params->session_priv_mpool == NULL) {
14409                         ts_params->session_priv_mpool = rte_mempool_create(
14410                                         "test_sess_mp_priv",
14411                                         MAX_NB_SESSIONS,
14412                                         session_size,
14413                                         0, 0, NULL, NULL, NULL,
14414                                         NULL, SOCKET_ID_ANY,
14415                                         0);
14416
14417                         TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
14418                                         "session mempool allocation failed");
14419                 }
14420
14421                 ts_params->qp_conf.mp_session = ts_params->session_mpool;
14422                 ts_params->qp_conf.mp_session_private =
14423                                 ts_params->session_priv_mpool;
14424
14425                 ret = rte_cryptodev_scheduler_worker_attach(sched_id,
14426                                 (uint8_t)i);
14427
14428                 TEST_ASSERT(ret == 0,
14429                         "Failed to attach device %u of pmd : %s", i,
14430                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
14431
14432                 aesni_ids[nb_devs_attached] = (uint8_t)i;
14433
14434                 nb_devs_attached++;
14435         }
14436
14437         return 0;
14438 }
14439
14440 static int
14441 test_scheduler_detach_worker_op(void)
14442 {
14443         struct crypto_testsuite_params *ts_params = &testsuite_params;
14444         uint8_t sched_id = ts_params->valid_devs[0];
14445         uint32_t i;
14446         int ret;
14447
14448         for (i = 0; i < 2; i++) {
14449                 ret = rte_cryptodev_scheduler_worker_detach(sched_id,
14450                                 aesni_ids[i]);
14451                 TEST_ASSERT(ret == 0,
14452                         "Failed to detach device %u", aesni_ids[i]);
14453         }
14454
14455         return 0;
14456 }
14457
14458 static int
14459 test_scheduler_mode_op(enum rte_cryptodev_scheduler_mode scheduler_mode)
14460 {
14461         struct crypto_testsuite_params *ts_params = &testsuite_params;
14462         uint8_t sched_id = ts_params->valid_devs[0];
14463         /* set mode */
14464         return rte_cryptodev_scheduler_mode_set(sched_id,
14465                 scheduler_mode);
14466 }
14467
14468 static int
14469 test_scheduler_mode_roundrobin_op(void)
14470 {
14471         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) ==
14472                         0, "Failed to set roundrobin mode");
14473         return 0;
14474
14475 }
14476
14477 static int
14478 test_scheduler_mode_multicore_op(void)
14479 {
14480         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) ==
14481                         0, "Failed to set multicore mode");
14482
14483         return 0;
14484 }
14485
14486 static int
14487 test_scheduler_mode_failover_op(void)
14488 {
14489         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) ==
14490                         0, "Failed to set failover mode");
14491
14492         return 0;
14493 }
14494
14495 static int
14496 test_scheduler_mode_pkt_size_distr_op(void)
14497 {
14498         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) ==
14499                         0, "Failed to set pktsize mode");
14500
14501         return 0;
14502 }
14503
14504 static int
14505 scheduler_multicore_testsuite_setup(void)
14506 {
14507         if (test_scheduler_attach_worker_op() < 0)
14508                 return TEST_SKIPPED;
14509         if (test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) < 0)
14510                 return TEST_SKIPPED;
14511         return 0;
14512 }
14513
14514 static int
14515 scheduler_roundrobin_testsuite_setup(void)
14516 {
14517         if (test_scheduler_attach_worker_op() < 0)
14518                 return TEST_SKIPPED;
14519         if (test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) < 0)
14520                 return TEST_SKIPPED;
14521         return 0;
14522 }
14523
14524 static int
14525 scheduler_failover_testsuite_setup(void)
14526 {
14527         if (test_scheduler_attach_worker_op() < 0)
14528                 return TEST_SKIPPED;
14529         if (test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) < 0)
14530                 return TEST_SKIPPED;
14531         return 0;
14532 }
14533
14534 static int
14535 scheduler_pkt_size_distr_testsuite_setup(void)
14536 {
14537         if (test_scheduler_attach_worker_op() < 0)
14538                 return TEST_SKIPPED;
14539         if (test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) < 0)
14540                 return TEST_SKIPPED;
14541         return 0;
14542 }
14543
14544 static void
14545 scheduler_mode_testsuite_teardown(void)
14546 {
14547         test_scheduler_detach_worker_op();
14548 }
14549
14550 #endif /* RTE_CRYPTO_SCHEDULER */
14551
14552 static struct unit_test_suite end_testsuite = {
14553         .suite_name = NULL,
14554         .setup = NULL,
14555         .teardown = NULL,
14556         .unit_test_suites = NULL
14557 };
14558
14559 #ifdef RTE_LIB_SECURITY
14560 static struct unit_test_suite ipsec_proto_testsuite  = {
14561         .suite_name = "IPsec Proto Unit Test Suite",
14562         .setup = ipsec_proto_testsuite_setup,
14563         .unit_test_cases = {
14564                 TEST_CASE_NAMED_WITH_DATA(
14565                         "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 128)",
14566                         ut_setup_security, ut_teardown,
14567                         test_ipsec_proto_known_vec, &pkt_aes_128_gcm),
14568                 TEST_CASE_NAMED_WITH_DATA(
14569                         "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 192)",
14570                         ut_setup_security, ut_teardown,
14571                         test_ipsec_proto_known_vec, &pkt_aes_192_gcm),
14572                 TEST_CASE_NAMED_WITH_DATA(
14573                         "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 256)",
14574                         ut_setup_security, ut_teardown,
14575                         test_ipsec_proto_known_vec, &pkt_aes_256_gcm),
14576                 TEST_CASE_NAMED_WITH_DATA(
14577                         "Outbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA256 [16B ICV])",
14578                         ut_setup_security, ut_teardown,
14579                         test_ipsec_proto_known_vec,
14580                         &pkt_aes_128_cbc_hmac_sha256),
14581                 TEST_CASE_NAMED_WITH_DATA(
14582                         "Outbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA384 [24B ICV])",
14583                         ut_setup_security, ut_teardown,
14584                         test_ipsec_proto_known_vec,
14585                         &pkt_aes_128_cbc_hmac_sha384),
14586                 TEST_CASE_NAMED_WITH_DATA(
14587                         "Outbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA512 [32B ICV])",
14588                         ut_setup_security, ut_teardown,
14589                         test_ipsec_proto_known_vec,
14590                         &pkt_aes_128_cbc_hmac_sha512),
14591                 TEST_CASE_NAMED_WITH_DATA(
14592                         "Outbound known vector (ESP tunnel mode IPv6 AES-GCM 128)",
14593                         ut_setup_security, ut_teardown,
14594                         test_ipsec_proto_known_vec, &pkt_aes_256_gcm_v6),
14595                 TEST_CASE_NAMED_WITH_DATA(
14596                         "Outbound known vector (ESP tunnel mode IPv6 AES-CBC 128 HMAC-SHA256 [16B ICV])",
14597                         ut_setup_security, ut_teardown,
14598                         test_ipsec_proto_known_vec,
14599                         &pkt_aes_128_cbc_hmac_sha256_v6),
14600                 TEST_CASE_NAMED_WITH_DATA(
14601                         "Outbound known vector (ESP tunnel mode IPv4 NULL AES-XCBC-MAC [12B ICV])",
14602                         ut_setup_security, ut_teardown,
14603                         test_ipsec_proto_known_vec,
14604                         &pkt_null_aes_xcbc),
14605                 TEST_CASE_NAMED_WITH_DATA(
14606                         "Outbound fragmented packet",
14607                         ut_setup_security, ut_teardown,
14608                         test_ipsec_proto_known_vec_fragmented,
14609                         &pkt_aes_128_gcm_frag),
14610                 TEST_CASE_NAMED_WITH_DATA(
14611                         "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 128)",
14612                         ut_setup_security, ut_teardown,
14613                         test_ipsec_proto_known_vec_inb, &pkt_aes_128_gcm),
14614                 TEST_CASE_NAMED_WITH_DATA(
14615                         "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 192)",
14616                         ut_setup_security, ut_teardown,
14617                         test_ipsec_proto_known_vec_inb, &pkt_aes_192_gcm),
14618                 TEST_CASE_NAMED_WITH_DATA(
14619                         "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 256)",
14620                         ut_setup_security, ut_teardown,
14621                         test_ipsec_proto_known_vec_inb, &pkt_aes_256_gcm),
14622                 TEST_CASE_NAMED_WITH_DATA(
14623                         "Inbound known vector (ESP tunnel mode IPv4 AES-CBC 128)",
14624                         ut_setup_security, ut_teardown,
14625                         test_ipsec_proto_known_vec_inb, &pkt_aes_128_cbc_null),
14626                 TEST_CASE_NAMED_WITH_DATA(
14627                         "Inbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA256 [16B ICV])",
14628                         ut_setup_security, ut_teardown,
14629                         test_ipsec_proto_known_vec_inb,
14630                         &pkt_aes_128_cbc_hmac_sha256),
14631                 TEST_CASE_NAMED_WITH_DATA(
14632                         "Inbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA384 [24B ICV])",
14633                         ut_setup_security, ut_teardown,
14634                         test_ipsec_proto_known_vec_inb,
14635                         &pkt_aes_128_cbc_hmac_sha384),
14636                 TEST_CASE_NAMED_WITH_DATA(
14637                         "Inbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA512 [32B ICV])",
14638                         ut_setup_security, ut_teardown,
14639                         test_ipsec_proto_known_vec_inb,
14640                         &pkt_aes_128_cbc_hmac_sha512),
14641                 TEST_CASE_NAMED_WITH_DATA(
14642                         "Inbound known vector (ESP tunnel mode IPv6 AES-GCM 128)",
14643                         ut_setup_security, ut_teardown,
14644                         test_ipsec_proto_known_vec_inb, &pkt_aes_256_gcm_v6),
14645                 TEST_CASE_NAMED_WITH_DATA(
14646                         "Inbound known vector (ESP tunnel mode IPv6 AES-CBC 128 HMAC-SHA256 [16B ICV])",
14647                         ut_setup_security, ut_teardown,
14648                         test_ipsec_proto_known_vec_inb,
14649                         &pkt_aes_128_cbc_hmac_sha256_v6),
14650                 TEST_CASE_NAMED_WITH_DATA(
14651                         "Inbound known vector (ESP tunnel mode IPv4 NULL AES-XCBC-MAC [12B ICV])",
14652                         ut_setup_security, ut_teardown,
14653                         test_ipsec_proto_known_vec_inb,
14654                         &pkt_null_aes_xcbc),
14655                 TEST_CASE_NAMED_ST(
14656                         "Combined test alg list",
14657                         ut_setup_security, ut_teardown,
14658                         test_ipsec_proto_display_list),
14659                 TEST_CASE_NAMED_ST(
14660                         "IV generation",
14661                         ut_setup_security, ut_teardown,
14662                         test_ipsec_proto_iv_gen),
14663                 TEST_CASE_NAMED_ST(
14664                         "UDP encapsulation",
14665                         ut_setup_security, ut_teardown,
14666                         test_ipsec_proto_udp_encap),
14667                 TEST_CASE_NAMED_ST(
14668                         "UDP encapsulation ports verification test",
14669                         ut_setup_security, ut_teardown,
14670                         test_ipsec_proto_udp_ports_verify),
14671                 TEST_CASE_NAMED_ST(
14672                         "SA expiry packets soft",
14673                         ut_setup_security, ut_teardown,
14674                         test_ipsec_proto_sa_exp_pkts_soft),
14675                 TEST_CASE_NAMED_ST(
14676                         "SA expiry packets hard",
14677                         ut_setup_security, ut_teardown,
14678                         test_ipsec_proto_sa_exp_pkts_hard),
14679                 TEST_CASE_NAMED_ST(
14680                         "Negative test: ICV corruption",
14681                         ut_setup_security, ut_teardown,
14682                         test_ipsec_proto_err_icv_corrupt),
14683                 TEST_CASE_NAMED_ST(
14684                         "Tunnel dst addr verification",
14685                         ut_setup_security, ut_teardown,
14686                         test_ipsec_proto_tunnel_dst_addr_verify),
14687                 TEST_CASE_NAMED_ST(
14688                         "Tunnel src and dst addr verification",
14689                         ut_setup_security, ut_teardown,
14690                         test_ipsec_proto_tunnel_src_dst_addr_verify),
14691                 TEST_CASE_NAMED_ST(
14692                         "Inner IP checksum",
14693                         ut_setup_security, ut_teardown,
14694                         test_ipsec_proto_inner_ip_csum),
14695                 TEST_CASE_NAMED_ST(
14696                         "Inner L4 checksum",
14697                         ut_setup_security, ut_teardown,
14698                         test_ipsec_proto_inner_l4_csum),
14699                 TEST_CASE_NAMED_ST(
14700                         "Tunnel IPv4 in IPv4",
14701                         ut_setup_security, ut_teardown,
14702                         test_ipsec_proto_tunnel_v4_in_v4),
14703                 TEST_CASE_NAMED_ST(
14704                         "Tunnel IPv6 in IPv6",
14705                         ut_setup_security, ut_teardown,
14706                         test_ipsec_proto_tunnel_v6_in_v6),
14707                 TEST_CASE_NAMED_ST(
14708                         "Tunnel IPv4 in IPv6",
14709                         ut_setup_security, ut_teardown,
14710                         test_ipsec_proto_tunnel_v4_in_v6),
14711                 TEST_CASE_NAMED_ST(
14712                         "Tunnel IPv6 in IPv4",
14713                         ut_setup_security, ut_teardown,
14714                         test_ipsec_proto_tunnel_v6_in_v4),
14715                 TEST_CASE_NAMED_ST(
14716                         "Transport IPv4",
14717                         ut_setup_security, ut_teardown,
14718                         test_ipsec_proto_transport_v4),
14719                 TEST_CASE_NAMED_ST(
14720                         "Statistics: success",
14721                         ut_setup_security, ut_teardown,
14722                         test_ipsec_proto_stats),
14723                 TEST_CASE_NAMED_ST(
14724                         "Fragmented packet",
14725                         ut_setup_security, ut_teardown,
14726                         test_ipsec_proto_pkt_fragment),
14727                 TEST_CASES_END() /**< NULL terminate unit test array */
14728         }
14729 };
14730
14731 static struct unit_test_suite pdcp_proto_testsuite  = {
14732         .suite_name = "PDCP Proto Unit Test Suite",
14733         .setup = pdcp_proto_testsuite_setup,
14734         .unit_test_cases = {
14735                 TEST_CASE_ST(ut_setup_security, ut_teardown,
14736                         test_PDCP_PROTO_all),
14737                 TEST_CASES_END() /**< NULL terminate unit test array */
14738         }
14739 };
14740
14741 #define ADD_UPLINK_TESTCASE(data)                                               \
14742         TEST_CASE_NAMED_WITH_DATA(data.test_descr_uplink, ut_setup_security,    \
14743         ut_teardown, test_docsis_proto_uplink, (const void *) &data),           \
14744
14745 #define ADD_DOWNLINK_TESTCASE(data)                                             \
14746         TEST_CASE_NAMED_WITH_DATA(data.test_descr_downlink, ut_setup_security,  \
14747         ut_teardown, test_docsis_proto_downlink, (const void *) &data),         \
14748
14749 static struct unit_test_suite docsis_proto_testsuite  = {
14750         .suite_name = "DOCSIS Proto Unit Test Suite",
14751         .setup = docsis_proto_testsuite_setup,
14752         .unit_test_cases = {
14753                 /* Uplink */
14754                 ADD_UPLINK_TESTCASE(docsis_test_case_1)
14755                 ADD_UPLINK_TESTCASE(docsis_test_case_2)
14756                 ADD_UPLINK_TESTCASE(docsis_test_case_3)
14757                 ADD_UPLINK_TESTCASE(docsis_test_case_4)
14758                 ADD_UPLINK_TESTCASE(docsis_test_case_5)
14759                 ADD_UPLINK_TESTCASE(docsis_test_case_6)
14760                 ADD_UPLINK_TESTCASE(docsis_test_case_7)
14761                 ADD_UPLINK_TESTCASE(docsis_test_case_8)
14762                 ADD_UPLINK_TESTCASE(docsis_test_case_9)
14763                 ADD_UPLINK_TESTCASE(docsis_test_case_10)
14764                 ADD_UPLINK_TESTCASE(docsis_test_case_11)
14765                 ADD_UPLINK_TESTCASE(docsis_test_case_12)
14766                 ADD_UPLINK_TESTCASE(docsis_test_case_13)
14767                 ADD_UPLINK_TESTCASE(docsis_test_case_14)
14768                 ADD_UPLINK_TESTCASE(docsis_test_case_15)
14769                 ADD_UPLINK_TESTCASE(docsis_test_case_16)
14770                 ADD_UPLINK_TESTCASE(docsis_test_case_17)
14771                 ADD_UPLINK_TESTCASE(docsis_test_case_18)
14772                 ADD_UPLINK_TESTCASE(docsis_test_case_19)
14773                 ADD_UPLINK_TESTCASE(docsis_test_case_20)
14774                 ADD_UPLINK_TESTCASE(docsis_test_case_21)
14775                 ADD_UPLINK_TESTCASE(docsis_test_case_22)
14776                 ADD_UPLINK_TESTCASE(docsis_test_case_23)
14777                 ADD_UPLINK_TESTCASE(docsis_test_case_24)
14778                 ADD_UPLINK_TESTCASE(docsis_test_case_25)
14779                 ADD_UPLINK_TESTCASE(docsis_test_case_26)
14780                 /* Downlink */
14781                 ADD_DOWNLINK_TESTCASE(docsis_test_case_1)
14782                 ADD_DOWNLINK_TESTCASE(docsis_test_case_2)
14783                 ADD_DOWNLINK_TESTCASE(docsis_test_case_3)
14784                 ADD_DOWNLINK_TESTCASE(docsis_test_case_4)
14785                 ADD_DOWNLINK_TESTCASE(docsis_test_case_5)
14786                 ADD_DOWNLINK_TESTCASE(docsis_test_case_6)
14787                 ADD_DOWNLINK_TESTCASE(docsis_test_case_7)
14788                 ADD_DOWNLINK_TESTCASE(docsis_test_case_8)
14789                 ADD_DOWNLINK_TESTCASE(docsis_test_case_9)
14790                 ADD_DOWNLINK_TESTCASE(docsis_test_case_10)
14791                 ADD_DOWNLINK_TESTCASE(docsis_test_case_11)
14792                 ADD_DOWNLINK_TESTCASE(docsis_test_case_12)
14793                 ADD_DOWNLINK_TESTCASE(docsis_test_case_13)
14794                 ADD_DOWNLINK_TESTCASE(docsis_test_case_14)
14795                 ADD_DOWNLINK_TESTCASE(docsis_test_case_15)
14796                 ADD_DOWNLINK_TESTCASE(docsis_test_case_16)
14797                 ADD_DOWNLINK_TESTCASE(docsis_test_case_17)
14798                 ADD_DOWNLINK_TESTCASE(docsis_test_case_18)
14799                 ADD_DOWNLINK_TESTCASE(docsis_test_case_19)
14800                 ADD_DOWNLINK_TESTCASE(docsis_test_case_20)
14801                 ADD_DOWNLINK_TESTCASE(docsis_test_case_21)
14802                 ADD_DOWNLINK_TESTCASE(docsis_test_case_22)
14803                 ADD_DOWNLINK_TESTCASE(docsis_test_case_23)
14804                 ADD_DOWNLINK_TESTCASE(docsis_test_case_24)
14805                 ADD_DOWNLINK_TESTCASE(docsis_test_case_25)
14806                 ADD_DOWNLINK_TESTCASE(docsis_test_case_26)
14807                 TEST_CASES_END() /**< NULL terminate unit test array */
14808         }
14809 };
14810 #endif
14811
14812 static struct unit_test_suite cryptodev_gen_testsuite  = {
14813         .suite_name = "Crypto General Unit Test Suite",
14814         .setup = crypto_gen_testsuite_setup,
14815         .unit_test_cases = {
14816                 TEST_CASE_ST(ut_setup, ut_teardown,
14817                                 test_device_configure_invalid_dev_id),
14818                 TEST_CASE_ST(ut_setup, ut_teardown,
14819                                 test_queue_pair_descriptor_setup),
14820                 TEST_CASE_ST(ut_setup, ut_teardown,
14821                                 test_device_configure_invalid_queue_pair_ids),
14822                 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
14823                 TEST_CASE_ST(ut_setup, ut_teardown, test_enq_callback_setup),
14824                 TEST_CASE_ST(ut_setup, ut_teardown, test_deq_callback_setup),
14825                 TEST_CASES_END() /**< NULL terminate unit test array */
14826         }
14827 };
14828
14829 static struct unit_test_suite cryptodev_negative_hmac_sha1_testsuite = {
14830         .suite_name = "Negative HMAC SHA1 Unit Test Suite",
14831         .setup = negative_hmac_sha1_testsuite_setup,
14832         .unit_test_cases = {
14833                 /** Negative tests */
14834                 TEST_CASE_ST(ut_setup, ut_teardown,
14835                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
14836                 TEST_CASE_ST(ut_setup, ut_teardown,
14837                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
14838                 TEST_CASE_ST(ut_setup, ut_teardown,
14839                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
14840                 TEST_CASE_ST(ut_setup, ut_teardown,
14841                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
14842
14843                 TEST_CASES_END() /**< NULL terminate unit test array */
14844         }
14845 };
14846
14847 static struct unit_test_suite cryptodev_multi_session_testsuite = {
14848         .suite_name = "Multi Session Unit Test Suite",
14849         .setup = multi_session_testsuite_setup,
14850         .unit_test_cases = {
14851                 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
14852                 TEST_CASE_ST(ut_setup, ut_teardown,
14853                                 test_multi_session_random_usage),
14854
14855                 TEST_CASES_END() /**< NULL terminate unit test array */
14856         }
14857 };
14858
14859 static struct unit_test_suite cryptodev_null_testsuite  = {
14860         .suite_name = "NULL Test Suite",
14861         .setup = null_testsuite_setup,
14862         .unit_test_cases = {
14863                 TEST_CASE_ST(ut_setup, ut_teardown,
14864                         test_null_invalid_operation),
14865                 TEST_CASE_ST(ut_setup, ut_teardown, test_null_burst_operation),
14866                 TEST_CASES_END()
14867         }
14868 };
14869
14870 static struct unit_test_suite cryptodev_aes_ccm_auth_testsuite  = {
14871         .suite_name = "AES CCM Authenticated Test Suite",
14872         .setup = aes_ccm_auth_testsuite_setup,
14873         .unit_test_cases = {
14874                 /** AES CCM Authenticated Encryption 128 bits key*/
14875                 TEST_CASE_ST(ut_setup, ut_teardown,
14876                         test_AES_CCM_authenticated_encryption_test_case_128_1),
14877                 TEST_CASE_ST(ut_setup, ut_teardown,
14878                         test_AES_CCM_authenticated_encryption_test_case_128_2),
14879                 TEST_CASE_ST(ut_setup, ut_teardown,
14880                         test_AES_CCM_authenticated_encryption_test_case_128_3),
14881
14882                 /** AES CCM Authenticated Decryption 128 bits key*/
14883                 TEST_CASE_ST(ut_setup, ut_teardown,
14884                         test_AES_CCM_authenticated_decryption_test_case_128_1),
14885                 TEST_CASE_ST(ut_setup, ut_teardown,
14886                         test_AES_CCM_authenticated_decryption_test_case_128_2),
14887                 TEST_CASE_ST(ut_setup, ut_teardown,
14888                         test_AES_CCM_authenticated_decryption_test_case_128_3),
14889
14890                 /** AES CCM Authenticated Encryption 192 bits key */
14891                 TEST_CASE_ST(ut_setup, ut_teardown,
14892                         test_AES_CCM_authenticated_encryption_test_case_192_1),
14893                 TEST_CASE_ST(ut_setup, ut_teardown,
14894                         test_AES_CCM_authenticated_encryption_test_case_192_2),
14895                 TEST_CASE_ST(ut_setup, ut_teardown,
14896                         test_AES_CCM_authenticated_encryption_test_case_192_3),
14897
14898                 /** AES CCM Authenticated Decryption 192 bits key*/
14899                 TEST_CASE_ST(ut_setup, ut_teardown,
14900                         test_AES_CCM_authenticated_decryption_test_case_192_1),
14901                 TEST_CASE_ST(ut_setup, ut_teardown,
14902                         test_AES_CCM_authenticated_decryption_test_case_192_2),
14903                 TEST_CASE_ST(ut_setup, ut_teardown,
14904                         test_AES_CCM_authenticated_decryption_test_case_192_3),
14905
14906                 /** AES CCM Authenticated Encryption 256 bits key */
14907                 TEST_CASE_ST(ut_setup, ut_teardown,
14908                         test_AES_CCM_authenticated_encryption_test_case_256_1),
14909                 TEST_CASE_ST(ut_setup, ut_teardown,
14910                         test_AES_CCM_authenticated_encryption_test_case_256_2),
14911                 TEST_CASE_ST(ut_setup, ut_teardown,
14912                         test_AES_CCM_authenticated_encryption_test_case_256_3),
14913
14914                 /** AES CCM Authenticated Decryption 256 bits key*/
14915                 TEST_CASE_ST(ut_setup, ut_teardown,
14916                         test_AES_CCM_authenticated_decryption_test_case_256_1),
14917                 TEST_CASE_ST(ut_setup, ut_teardown,
14918                         test_AES_CCM_authenticated_decryption_test_case_256_2),
14919                 TEST_CASE_ST(ut_setup, ut_teardown,
14920                         test_AES_CCM_authenticated_decryption_test_case_256_3),
14921                 TEST_CASES_END()
14922         }
14923 };
14924
14925 static struct unit_test_suite cryptodev_aes_gcm_auth_testsuite  = {
14926         .suite_name = "AES GCM Authenticated Test Suite",
14927         .setup = aes_gcm_auth_testsuite_setup,
14928         .unit_test_cases = {
14929                 /** AES GCM Authenticated Encryption */
14930                 TEST_CASE_ST(ut_setup, ut_teardown,
14931                         test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
14932                 TEST_CASE_ST(ut_setup, ut_teardown,
14933                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
14934                 TEST_CASE_ST(ut_setup, ut_teardown,
14935                         test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
14936                 TEST_CASE_ST(ut_setup, ut_teardown,
14937                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
14938                 TEST_CASE_ST(ut_setup, ut_teardown,
14939                         test_AES_GCM_authenticated_encryption_test_case_1),
14940                 TEST_CASE_ST(ut_setup, ut_teardown,
14941                         test_AES_GCM_authenticated_encryption_test_case_2),
14942                 TEST_CASE_ST(ut_setup, ut_teardown,
14943                         test_AES_GCM_authenticated_encryption_test_case_3),
14944                 TEST_CASE_ST(ut_setup, ut_teardown,
14945                         test_AES_GCM_authenticated_encryption_test_case_4),
14946                 TEST_CASE_ST(ut_setup, ut_teardown,
14947                         test_AES_GCM_authenticated_encryption_test_case_5),
14948                 TEST_CASE_ST(ut_setup, ut_teardown,
14949                         test_AES_GCM_authenticated_encryption_test_case_6),
14950                 TEST_CASE_ST(ut_setup, ut_teardown,
14951                         test_AES_GCM_authenticated_encryption_test_case_7),
14952                 TEST_CASE_ST(ut_setup, ut_teardown,
14953                         test_AES_GCM_authenticated_encryption_test_case_8),
14954                 TEST_CASE_ST(ut_setup, ut_teardown,
14955                         test_AES_GCM_J0_authenticated_encryption_test_case_1),
14956
14957                 /** AES GCM Authenticated Decryption */
14958                 TEST_CASE_ST(ut_setup, ut_teardown,
14959                         test_AES_GCM_authenticated_decryption_test_case_1),
14960                 TEST_CASE_ST(ut_setup, ut_teardown,
14961                         test_AES_GCM_authenticated_decryption_test_case_2),
14962                 TEST_CASE_ST(ut_setup, ut_teardown,
14963                         test_AES_GCM_authenticated_decryption_test_case_3),
14964                 TEST_CASE_ST(ut_setup, ut_teardown,
14965                         test_AES_GCM_authenticated_decryption_test_case_4),
14966                 TEST_CASE_ST(ut_setup, ut_teardown,
14967                         test_AES_GCM_authenticated_decryption_test_case_5),
14968                 TEST_CASE_ST(ut_setup, ut_teardown,
14969                         test_AES_GCM_authenticated_decryption_test_case_6),
14970                 TEST_CASE_ST(ut_setup, ut_teardown,
14971                         test_AES_GCM_authenticated_decryption_test_case_7),
14972                 TEST_CASE_ST(ut_setup, ut_teardown,
14973                         test_AES_GCM_authenticated_decryption_test_case_8),
14974                 TEST_CASE_ST(ut_setup, ut_teardown,
14975                         test_AES_GCM_J0_authenticated_decryption_test_case_1),
14976
14977                 /** AES GCM Authenticated Encryption 192 bits key */
14978                 TEST_CASE_ST(ut_setup, ut_teardown,
14979                         test_AES_GCM_auth_encryption_test_case_192_1),
14980                 TEST_CASE_ST(ut_setup, ut_teardown,
14981                         test_AES_GCM_auth_encryption_test_case_192_2),
14982                 TEST_CASE_ST(ut_setup, ut_teardown,
14983                         test_AES_GCM_auth_encryption_test_case_192_3),
14984                 TEST_CASE_ST(ut_setup, ut_teardown,
14985                         test_AES_GCM_auth_encryption_test_case_192_4),
14986                 TEST_CASE_ST(ut_setup, ut_teardown,
14987                         test_AES_GCM_auth_encryption_test_case_192_5),
14988                 TEST_CASE_ST(ut_setup, ut_teardown,
14989                         test_AES_GCM_auth_encryption_test_case_192_6),
14990                 TEST_CASE_ST(ut_setup, ut_teardown,
14991                         test_AES_GCM_auth_encryption_test_case_192_7),
14992
14993                 /** AES GCM Authenticated Decryption 192 bits key */
14994                 TEST_CASE_ST(ut_setup, ut_teardown,
14995                         test_AES_GCM_auth_decryption_test_case_192_1),
14996                 TEST_CASE_ST(ut_setup, ut_teardown,
14997                         test_AES_GCM_auth_decryption_test_case_192_2),
14998                 TEST_CASE_ST(ut_setup, ut_teardown,
14999                         test_AES_GCM_auth_decryption_test_case_192_3),
15000                 TEST_CASE_ST(ut_setup, ut_teardown,
15001                         test_AES_GCM_auth_decryption_test_case_192_4),
15002                 TEST_CASE_ST(ut_setup, ut_teardown,
15003                         test_AES_GCM_auth_decryption_test_case_192_5),
15004                 TEST_CASE_ST(ut_setup, ut_teardown,
15005                         test_AES_GCM_auth_decryption_test_case_192_6),
15006                 TEST_CASE_ST(ut_setup, ut_teardown,
15007                         test_AES_GCM_auth_decryption_test_case_192_7),
15008
15009                 /** AES GCM Authenticated Encryption 256 bits key */
15010                 TEST_CASE_ST(ut_setup, ut_teardown,
15011                         test_AES_GCM_auth_encryption_test_case_256_1),
15012                 TEST_CASE_ST(ut_setup, ut_teardown,
15013                         test_AES_GCM_auth_encryption_test_case_256_2),
15014                 TEST_CASE_ST(ut_setup, ut_teardown,
15015                         test_AES_GCM_auth_encryption_test_case_256_3),
15016                 TEST_CASE_ST(ut_setup, ut_teardown,
15017                         test_AES_GCM_auth_encryption_test_case_256_4),
15018                 TEST_CASE_ST(ut_setup, ut_teardown,
15019                         test_AES_GCM_auth_encryption_test_case_256_5),
15020                 TEST_CASE_ST(ut_setup, ut_teardown,
15021                         test_AES_GCM_auth_encryption_test_case_256_6),
15022                 TEST_CASE_ST(ut_setup, ut_teardown,
15023                         test_AES_GCM_auth_encryption_test_case_256_7),
15024
15025                 /** AES GCM Authenticated Decryption 256 bits key */
15026                 TEST_CASE_ST(ut_setup, ut_teardown,
15027                         test_AES_GCM_auth_decryption_test_case_256_1),
15028                 TEST_CASE_ST(ut_setup, ut_teardown,
15029                         test_AES_GCM_auth_decryption_test_case_256_2),
15030                 TEST_CASE_ST(ut_setup, ut_teardown,
15031                         test_AES_GCM_auth_decryption_test_case_256_3),
15032                 TEST_CASE_ST(ut_setup, ut_teardown,
15033                         test_AES_GCM_auth_decryption_test_case_256_4),
15034                 TEST_CASE_ST(ut_setup, ut_teardown,
15035                         test_AES_GCM_auth_decryption_test_case_256_5),
15036                 TEST_CASE_ST(ut_setup, ut_teardown,
15037                         test_AES_GCM_auth_decryption_test_case_256_6),
15038                 TEST_CASE_ST(ut_setup, ut_teardown,
15039                         test_AES_GCM_auth_decryption_test_case_256_7),
15040
15041                 /** AES GCM Authenticated Encryption big aad size */
15042                 TEST_CASE_ST(ut_setup, ut_teardown,
15043                         test_AES_GCM_auth_encryption_test_case_aad_1),
15044                 TEST_CASE_ST(ut_setup, ut_teardown,
15045                         test_AES_GCM_auth_encryption_test_case_aad_2),
15046
15047                 /** AES GCM Authenticated Decryption big aad size */
15048                 TEST_CASE_ST(ut_setup, ut_teardown,
15049                         test_AES_GCM_auth_decryption_test_case_aad_1),
15050                 TEST_CASE_ST(ut_setup, ut_teardown,
15051                         test_AES_GCM_auth_decryption_test_case_aad_2),
15052
15053                 /** Out of place tests */
15054                 TEST_CASE_ST(ut_setup, ut_teardown,
15055                         test_AES_GCM_authenticated_encryption_oop_test_case_1),
15056                 TEST_CASE_ST(ut_setup, ut_teardown,
15057                         test_AES_GCM_authenticated_decryption_oop_test_case_1),
15058
15059                 /** Session-less tests */
15060                 TEST_CASE_ST(ut_setup, ut_teardown,
15061                         test_AES_GCM_authenticated_encryption_sessionless_test_case_1),
15062                 TEST_CASE_ST(ut_setup, ut_teardown,
15063                         test_AES_GCM_authenticated_decryption_sessionless_test_case_1),
15064
15065                 TEST_CASES_END()
15066         }
15067 };
15068
15069 static struct unit_test_suite cryptodev_aes_gmac_auth_testsuite  = {
15070         .suite_name = "AES GMAC Authentication Test Suite",
15071         .setup = aes_gmac_auth_testsuite_setup,
15072         .unit_test_cases = {
15073                 TEST_CASE_ST(ut_setup, ut_teardown,
15074                         test_AES_GMAC_authentication_test_case_1),
15075                 TEST_CASE_ST(ut_setup, ut_teardown,
15076                         test_AES_GMAC_authentication_verify_test_case_1),
15077                 TEST_CASE_ST(ut_setup, ut_teardown,
15078                         test_AES_GMAC_authentication_test_case_2),
15079                 TEST_CASE_ST(ut_setup, ut_teardown,
15080                         test_AES_GMAC_authentication_verify_test_case_2),
15081                 TEST_CASE_ST(ut_setup, ut_teardown,
15082                         test_AES_GMAC_authentication_test_case_3),
15083                 TEST_CASE_ST(ut_setup, ut_teardown,
15084                         test_AES_GMAC_authentication_verify_test_case_3),
15085                 TEST_CASE_ST(ut_setup, ut_teardown,
15086                         test_AES_GMAC_authentication_test_case_4),
15087                 TEST_CASE_ST(ut_setup, ut_teardown,
15088                         test_AES_GMAC_authentication_verify_test_case_4),
15089                 TEST_CASE_ST(ut_setup, ut_teardown,
15090                         test_AES_GMAC_authentication_SGL_40B),
15091                 TEST_CASE_ST(ut_setup, ut_teardown,
15092                         test_AES_GMAC_authentication_SGL_80B),
15093                 TEST_CASE_ST(ut_setup, ut_teardown,
15094                         test_AES_GMAC_authentication_SGL_2048B),
15095                 TEST_CASE_ST(ut_setup, ut_teardown,
15096                         test_AES_GMAC_authentication_SGL_2047B),
15097
15098                 TEST_CASES_END()
15099         }
15100 };
15101
15102 static struct unit_test_suite cryptodev_chacha20_poly1305_testsuite  = {
15103         .suite_name = "Chacha20-Poly1305 Test Suite",
15104         .setup = chacha20_poly1305_testsuite_setup,
15105         .unit_test_cases = {
15106                 TEST_CASE_ST(ut_setup, ut_teardown,
15107                         test_chacha20_poly1305_encrypt_test_case_rfc8439),
15108                 TEST_CASE_ST(ut_setup, ut_teardown,
15109                         test_chacha20_poly1305_decrypt_test_case_rfc8439),
15110                 TEST_CASE_ST(ut_setup, ut_teardown,
15111                         test_chacha20_poly1305_encrypt_SGL_out_of_place),
15112                 TEST_CASES_END()
15113         }
15114 };
15115
15116 static struct unit_test_suite cryptodev_snow3g_testsuite  = {
15117         .suite_name = "SNOW 3G Test Suite",
15118         .setup = snow3g_testsuite_setup,
15119         .unit_test_cases = {
15120                 /** SNOW 3G encrypt only (UEA2) */
15121                 TEST_CASE_ST(ut_setup, ut_teardown,
15122                         test_snow3g_encryption_test_case_1),
15123                 TEST_CASE_ST(ut_setup, ut_teardown,
15124                         test_snow3g_encryption_test_case_2),
15125                 TEST_CASE_ST(ut_setup, ut_teardown,
15126                         test_snow3g_encryption_test_case_3),
15127                 TEST_CASE_ST(ut_setup, ut_teardown,
15128                         test_snow3g_encryption_test_case_4),
15129                 TEST_CASE_ST(ut_setup, ut_teardown,
15130                         test_snow3g_encryption_test_case_5),
15131
15132                 TEST_CASE_ST(ut_setup, ut_teardown,
15133                         test_snow3g_encryption_test_case_1_oop),
15134                 TEST_CASE_ST(ut_setup, ut_teardown,
15135                         test_snow3g_encryption_test_case_1_oop_sgl),
15136                 TEST_CASE_ST(ut_setup, ut_teardown,
15137                         test_snow3g_encryption_test_case_1_offset_oop),
15138                 TEST_CASE_ST(ut_setup, ut_teardown,
15139                         test_snow3g_decryption_test_case_1_oop),
15140
15141                 /** SNOW 3G generate auth, then encrypt (UEA2) */
15142                 TEST_CASE_ST(ut_setup, ut_teardown,
15143                         test_snow3g_auth_cipher_test_case_1),
15144                 TEST_CASE_ST(ut_setup, ut_teardown,
15145                         test_snow3g_auth_cipher_test_case_2),
15146                 TEST_CASE_ST(ut_setup, ut_teardown,
15147                         test_snow3g_auth_cipher_test_case_2_oop),
15148                 TEST_CASE_ST(ut_setup, ut_teardown,
15149                         test_snow3g_auth_cipher_part_digest_enc),
15150                 TEST_CASE_ST(ut_setup, ut_teardown,
15151                         test_snow3g_auth_cipher_part_digest_enc_oop),
15152                 TEST_CASE_ST(ut_setup, ut_teardown,
15153                         test_snow3g_auth_cipher_test_case_3_sgl),
15154                 TEST_CASE_ST(ut_setup, ut_teardown,
15155                         test_snow3g_auth_cipher_test_case_3_oop_sgl),
15156                 TEST_CASE_ST(ut_setup, ut_teardown,
15157                         test_snow3g_auth_cipher_part_digest_enc_sgl),
15158                 TEST_CASE_ST(ut_setup, ut_teardown,
15159                         test_snow3g_auth_cipher_part_digest_enc_oop_sgl),
15160
15161                 /** SNOW 3G decrypt (UEA2), then verify auth */
15162                 TEST_CASE_ST(ut_setup, ut_teardown,
15163                         test_snow3g_auth_cipher_verify_test_case_1),
15164                 TEST_CASE_ST(ut_setup, ut_teardown,
15165                         test_snow3g_auth_cipher_verify_test_case_2),
15166                 TEST_CASE_ST(ut_setup, ut_teardown,
15167                         test_snow3g_auth_cipher_verify_test_case_2_oop),
15168                 TEST_CASE_ST(ut_setup, ut_teardown,
15169                         test_snow3g_auth_cipher_verify_part_digest_enc),
15170                 TEST_CASE_ST(ut_setup, ut_teardown,
15171                         test_snow3g_auth_cipher_verify_part_digest_enc_oop),
15172                 TEST_CASE_ST(ut_setup, ut_teardown,
15173                         test_snow3g_auth_cipher_verify_test_case_3_sgl),
15174                 TEST_CASE_ST(ut_setup, ut_teardown,
15175                         test_snow3g_auth_cipher_verify_test_case_3_oop_sgl),
15176                 TEST_CASE_ST(ut_setup, ut_teardown,
15177                         test_snow3g_auth_cipher_verify_part_digest_enc_sgl),
15178                 TEST_CASE_ST(ut_setup, ut_teardown,
15179                         test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl),
15180
15181                 /** SNOW 3G decrypt only (UEA2) */
15182                 TEST_CASE_ST(ut_setup, ut_teardown,
15183                         test_snow3g_decryption_test_case_1),
15184                 TEST_CASE_ST(ut_setup, ut_teardown,
15185                         test_snow3g_decryption_test_case_2),
15186                 TEST_CASE_ST(ut_setup, ut_teardown,
15187                         test_snow3g_decryption_test_case_3),
15188                 TEST_CASE_ST(ut_setup, ut_teardown,
15189                         test_snow3g_decryption_test_case_4),
15190                 TEST_CASE_ST(ut_setup, ut_teardown,
15191                         test_snow3g_decryption_test_case_5),
15192                 TEST_CASE_ST(ut_setup, ut_teardown,
15193                         test_snow3g_decryption_with_digest_test_case_1),
15194                 TEST_CASE_ST(ut_setup, ut_teardown,
15195                         test_snow3g_hash_generate_test_case_1),
15196                 TEST_CASE_ST(ut_setup, ut_teardown,
15197                         test_snow3g_hash_generate_test_case_2),
15198                 TEST_CASE_ST(ut_setup, ut_teardown,
15199                         test_snow3g_hash_generate_test_case_3),
15200
15201                 /* Tests with buffers which length is not byte-aligned */
15202                 TEST_CASE_ST(ut_setup, ut_teardown,
15203                         test_snow3g_hash_generate_test_case_4),
15204                 TEST_CASE_ST(ut_setup, ut_teardown,
15205                         test_snow3g_hash_generate_test_case_5),
15206                 TEST_CASE_ST(ut_setup, ut_teardown,
15207                         test_snow3g_hash_generate_test_case_6),
15208                 TEST_CASE_ST(ut_setup, ut_teardown,
15209                         test_snow3g_hash_verify_test_case_1),
15210                 TEST_CASE_ST(ut_setup, ut_teardown,
15211                         test_snow3g_hash_verify_test_case_2),
15212                 TEST_CASE_ST(ut_setup, ut_teardown,
15213                         test_snow3g_hash_verify_test_case_3),
15214
15215                 /* Tests with buffers which length is not byte-aligned */
15216                 TEST_CASE_ST(ut_setup, ut_teardown,
15217                         test_snow3g_hash_verify_test_case_4),
15218                 TEST_CASE_ST(ut_setup, ut_teardown,
15219                         test_snow3g_hash_verify_test_case_5),
15220                 TEST_CASE_ST(ut_setup, ut_teardown,
15221                         test_snow3g_hash_verify_test_case_6),
15222                 TEST_CASE_ST(ut_setup, ut_teardown,
15223                         test_snow3g_cipher_auth_test_case_1),
15224                 TEST_CASE_ST(ut_setup, ut_teardown,
15225                         test_snow3g_auth_cipher_with_digest_test_case_1),
15226                 TEST_CASES_END()
15227         }
15228 };
15229
15230 static struct unit_test_suite cryptodev_zuc_testsuite  = {
15231         .suite_name = "ZUC Test Suite",
15232         .setup = zuc_testsuite_setup,
15233         .unit_test_cases = {
15234                 /** ZUC encrypt only (EEA3) */
15235                 TEST_CASE_ST(ut_setup, ut_teardown,
15236                         test_zuc_encryption_test_case_1),
15237                 TEST_CASE_ST(ut_setup, ut_teardown,
15238                         test_zuc_encryption_test_case_2),
15239                 TEST_CASE_ST(ut_setup, ut_teardown,
15240                         test_zuc_encryption_test_case_3),
15241                 TEST_CASE_ST(ut_setup, ut_teardown,
15242                         test_zuc_encryption_test_case_4),
15243                 TEST_CASE_ST(ut_setup, ut_teardown,
15244                         test_zuc_encryption_test_case_5),
15245                 TEST_CASE_ST(ut_setup, ut_teardown,
15246                         test_zuc_encryption_test_case_6_sgl),
15247
15248                 /** ZUC authenticate (EIA3) */
15249                 TEST_CASE_ST(ut_setup, ut_teardown,
15250                         test_zuc_hash_generate_test_case_1),
15251                 TEST_CASE_ST(ut_setup, ut_teardown,
15252                         test_zuc_hash_generate_test_case_2),
15253                 TEST_CASE_ST(ut_setup, ut_teardown,
15254                         test_zuc_hash_generate_test_case_3),
15255                 TEST_CASE_ST(ut_setup, ut_teardown,
15256                         test_zuc_hash_generate_test_case_4),
15257                 TEST_CASE_ST(ut_setup, ut_teardown,
15258                         test_zuc_hash_generate_test_case_5),
15259                 TEST_CASE_ST(ut_setup, ut_teardown,
15260                         test_zuc_hash_generate_test_case_6),
15261                 TEST_CASE_ST(ut_setup, ut_teardown,
15262                         test_zuc_hash_generate_test_case_7),
15263                 TEST_CASE_ST(ut_setup, ut_teardown,
15264                         test_zuc_hash_generate_test_case_8),
15265                 TEST_CASE_ST(ut_setup, ut_teardown,
15266                         test_zuc_hash_generate_test_case_9),
15267                 TEST_CASE_ST(ut_setup, ut_teardown,
15268                         test_zuc_hash_generate_test_case_10),
15269                 TEST_CASE_ST(ut_setup, ut_teardown,
15270                         test_zuc_hash_generate_test_case_11),
15271
15272
15273                 /** ZUC alg-chain (EEA3/EIA3) */
15274                 TEST_CASE_ST(ut_setup, ut_teardown,
15275                         test_zuc_cipher_auth_test_case_1),
15276                 TEST_CASE_ST(ut_setup, ut_teardown,
15277                         test_zuc_cipher_auth_test_case_2),
15278
15279                 /** ZUC generate auth, then encrypt (EEA3) */
15280                 TEST_CASE_ST(ut_setup, ut_teardown,
15281                         test_zuc_auth_cipher_test_case_1),
15282                 TEST_CASE_ST(ut_setup, ut_teardown,
15283                         test_zuc_auth_cipher_test_case_1_oop),
15284                 TEST_CASE_ST(ut_setup, ut_teardown,
15285                         test_zuc_auth_cipher_test_case_1_sgl),
15286                 TEST_CASE_ST(ut_setup, ut_teardown,
15287                         test_zuc_auth_cipher_test_case_1_oop_sgl),
15288
15289                 /** ZUC decrypt (EEA3), then verify auth */
15290                 TEST_CASE_ST(ut_setup, ut_teardown,
15291                         test_zuc_auth_cipher_verify_test_case_1),
15292                 TEST_CASE_ST(ut_setup, ut_teardown,
15293                         test_zuc_auth_cipher_verify_test_case_1_oop),
15294                 TEST_CASE_ST(ut_setup, ut_teardown,
15295                         test_zuc_auth_cipher_verify_test_case_1_sgl),
15296                 TEST_CASE_ST(ut_setup, ut_teardown,
15297                         test_zuc_auth_cipher_verify_test_case_1_oop_sgl),
15298
15299                 /** ZUC-256 encrypt only **/
15300                 TEST_CASE_ST(ut_setup, ut_teardown,
15301                         test_zuc256_encryption_test_case_1),
15302                 TEST_CASE_ST(ut_setup, ut_teardown,
15303                         test_zuc256_encryption_test_case_2),
15304
15305                 /** ZUC-256 authentication only **/
15306                 TEST_CASE_ST(ut_setup, ut_teardown,
15307                         test_zuc256_authentication_test_case_1),
15308                 TEST_CASE_ST(ut_setup, ut_teardown,
15309                         test_zuc256_authentication_test_case_2),
15310
15311                 TEST_CASES_END()
15312         }
15313 };
15314
15315 static struct unit_test_suite cryptodev_hmac_md5_auth_testsuite  = {
15316         .suite_name = "HMAC_MD5 Authentication Test Suite",
15317         .setup = hmac_md5_auth_testsuite_setup,
15318         .unit_test_cases = {
15319                 TEST_CASE_ST(ut_setup, ut_teardown,
15320                         test_MD5_HMAC_generate_case_1),
15321                 TEST_CASE_ST(ut_setup, ut_teardown,
15322                         test_MD5_HMAC_verify_case_1),
15323                 TEST_CASE_ST(ut_setup, ut_teardown,
15324                         test_MD5_HMAC_generate_case_2),
15325                 TEST_CASE_ST(ut_setup, ut_teardown,
15326                         test_MD5_HMAC_verify_case_2),
15327                 TEST_CASES_END()
15328         }
15329 };
15330
15331 static struct unit_test_suite cryptodev_kasumi_testsuite  = {
15332         .suite_name = "Kasumi Test Suite",
15333         .setup = kasumi_testsuite_setup,
15334         .unit_test_cases = {
15335                 /** KASUMI hash only (UIA1) */
15336                 TEST_CASE_ST(ut_setup, ut_teardown,
15337                         test_kasumi_hash_generate_test_case_1),
15338                 TEST_CASE_ST(ut_setup, ut_teardown,
15339                         test_kasumi_hash_generate_test_case_2),
15340                 TEST_CASE_ST(ut_setup, ut_teardown,
15341                         test_kasumi_hash_generate_test_case_3),
15342                 TEST_CASE_ST(ut_setup, ut_teardown,
15343                         test_kasumi_hash_generate_test_case_4),
15344                 TEST_CASE_ST(ut_setup, ut_teardown,
15345                         test_kasumi_hash_generate_test_case_5),
15346                 TEST_CASE_ST(ut_setup, ut_teardown,
15347                         test_kasumi_hash_generate_test_case_6),
15348
15349                 TEST_CASE_ST(ut_setup, ut_teardown,
15350                         test_kasumi_hash_verify_test_case_1),
15351                 TEST_CASE_ST(ut_setup, ut_teardown,
15352                         test_kasumi_hash_verify_test_case_2),
15353                 TEST_CASE_ST(ut_setup, ut_teardown,
15354                         test_kasumi_hash_verify_test_case_3),
15355                 TEST_CASE_ST(ut_setup, ut_teardown,
15356                         test_kasumi_hash_verify_test_case_4),
15357                 TEST_CASE_ST(ut_setup, ut_teardown,
15358                         test_kasumi_hash_verify_test_case_5),
15359
15360                 /** KASUMI encrypt only (UEA1) */
15361                 TEST_CASE_ST(ut_setup, ut_teardown,
15362                         test_kasumi_encryption_test_case_1),
15363                 TEST_CASE_ST(ut_setup, ut_teardown,
15364                         test_kasumi_encryption_test_case_1_sgl),
15365                 TEST_CASE_ST(ut_setup, ut_teardown,
15366                         test_kasumi_encryption_test_case_1_oop),
15367                 TEST_CASE_ST(ut_setup, ut_teardown,
15368                         test_kasumi_encryption_test_case_1_oop_sgl),
15369                 TEST_CASE_ST(ut_setup, ut_teardown,
15370                         test_kasumi_encryption_test_case_2),
15371                 TEST_CASE_ST(ut_setup, ut_teardown,
15372                         test_kasumi_encryption_test_case_3),
15373                 TEST_CASE_ST(ut_setup, ut_teardown,
15374                         test_kasumi_encryption_test_case_4),
15375                 TEST_CASE_ST(ut_setup, ut_teardown,
15376                         test_kasumi_encryption_test_case_5),
15377
15378                 /** KASUMI decrypt only (UEA1) */
15379                 TEST_CASE_ST(ut_setup, ut_teardown,
15380                         test_kasumi_decryption_test_case_1),
15381                 TEST_CASE_ST(ut_setup, ut_teardown,
15382                         test_kasumi_decryption_test_case_2),
15383                 TEST_CASE_ST(ut_setup, ut_teardown,
15384                         test_kasumi_decryption_test_case_3),
15385                 TEST_CASE_ST(ut_setup, ut_teardown,
15386                         test_kasumi_decryption_test_case_4),
15387                 TEST_CASE_ST(ut_setup, ut_teardown,
15388                         test_kasumi_decryption_test_case_5),
15389                 TEST_CASE_ST(ut_setup, ut_teardown,
15390                         test_kasumi_decryption_test_case_1_oop),
15391                 TEST_CASE_ST(ut_setup, ut_teardown,
15392                         test_kasumi_cipher_auth_test_case_1),
15393
15394                 /** KASUMI generate auth, then encrypt (F8) */
15395                 TEST_CASE_ST(ut_setup, ut_teardown,
15396                         test_kasumi_auth_cipher_test_case_1),
15397                 TEST_CASE_ST(ut_setup, ut_teardown,
15398                         test_kasumi_auth_cipher_test_case_2),
15399                 TEST_CASE_ST(ut_setup, ut_teardown,
15400                         test_kasumi_auth_cipher_test_case_2_oop),
15401                 TEST_CASE_ST(ut_setup, ut_teardown,
15402                         test_kasumi_auth_cipher_test_case_2_sgl),
15403                 TEST_CASE_ST(ut_setup, ut_teardown,
15404                         test_kasumi_auth_cipher_test_case_2_oop_sgl),
15405
15406                 /** KASUMI decrypt (F8), then verify auth */
15407                 TEST_CASE_ST(ut_setup, ut_teardown,
15408                         test_kasumi_auth_cipher_verify_test_case_1),
15409                 TEST_CASE_ST(ut_setup, ut_teardown,
15410                         test_kasumi_auth_cipher_verify_test_case_2),
15411                 TEST_CASE_ST(ut_setup, ut_teardown,
15412                         test_kasumi_auth_cipher_verify_test_case_2_oop),
15413                 TEST_CASE_ST(ut_setup, ut_teardown,
15414                         test_kasumi_auth_cipher_verify_test_case_2_sgl),
15415                 TEST_CASE_ST(ut_setup, ut_teardown,
15416                         test_kasumi_auth_cipher_verify_test_case_2_oop_sgl),
15417
15418                 TEST_CASES_END()
15419         }
15420 };
15421
15422 static struct unit_test_suite cryptodev_esn_testsuite  = {
15423         .suite_name = "ESN Test Suite",
15424         .setup = esn_testsuite_setup,
15425         .unit_test_cases = {
15426                 TEST_CASE_ST(ut_setup, ut_teardown,
15427                         auth_encrypt_AES128CBC_HMAC_SHA1_esn_check),
15428                 TEST_CASE_ST(ut_setup, ut_teardown,
15429                         auth_decrypt_AES128CBC_HMAC_SHA1_esn_check),
15430                 TEST_CASES_END()
15431         }
15432 };
15433
15434 static struct unit_test_suite cryptodev_negative_aes_gcm_testsuite  = {
15435         .suite_name = "Negative AES GCM Test Suite",
15436         .setup = negative_aes_gcm_testsuite_setup,
15437         .unit_test_cases = {
15438                 TEST_CASE_ST(ut_setup, ut_teardown,
15439                         test_AES_GCM_auth_encryption_fail_iv_corrupt),
15440                 TEST_CASE_ST(ut_setup, ut_teardown,
15441                         test_AES_GCM_auth_encryption_fail_in_data_corrupt),
15442                 TEST_CASE_ST(ut_setup, ut_teardown,
15443                         test_AES_GCM_auth_encryption_fail_out_data_corrupt),
15444                 TEST_CASE_ST(ut_setup, ut_teardown,
15445                         test_AES_GCM_auth_encryption_fail_aad_len_corrupt),
15446                 TEST_CASE_ST(ut_setup, ut_teardown,
15447                         test_AES_GCM_auth_encryption_fail_aad_corrupt),
15448                 TEST_CASE_ST(ut_setup, ut_teardown,
15449                         test_AES_GCM_auth_encryption_fail_tag_corrupt),
15450                 TEST_CASE_ST(ut_setup, ut_teardown,
15451                         test_AES_GCM_auth_decryption_fail_iv_corrupt),
15452                 TEST_CASE_ST(ut_setup, ut_teardown,
15453                         test_AES_GCM_auth_decryption_fail_in_data_corrupt),
15454                 TEST_CASE_ST(ut_setup, ut_teardown,
15455                         test_AES_GCM_auth_decryption_fail_out_data_corrupt),
15456                 TEST_CASE_ST(ut_setup, ut_teardown,
15457                         test_AES_GCM_auth_decryption_fail_aad_len_corrupt),
15458                 TEST_CASE_ST(ut_setup, ut_teardown,
15459                         test_AES_GCM_auth_decryption_fail_aad_corrupt),
15460                 TEST_CASE_ST(ut_setup, ut_teardown,
15461                         test_AES_GCM_auth_decryption_fail_tag_corrupt),
15462
15463                 TEST_CASES_END()
15464         }
15465 };
15466
15467 static struct unit_test_suite cryptodev_negative_aes_gmac_testsuite  = {
15468         .suite_name = "Negative AES GMAC Test Suite",
15469         .setup = negative_aes_gmac_testsuite_setup,
15470         .unit_test_cases = {
15471                 TEST_CASE_ST(ut_setup, ut_teardown,
15472                         authentication_verify_AES128_GMAC_fail_data_corrupt),
15473                 TEST_CASE_ST(ut_setup, ut_teardown,
15474                         authentication_verify_AES128_GMAC_fail_tag_corrupt),
15475
15476                 TEST_CASES_END()
15477         }
15478 };
15479
15480 static struct unit_test_suite cryptodev_mixed_cipher_hash_testsuite  = {
15481         .suite_name = "Mixed CIPHER + HASH algorithms Test Suite",
15482         .setup = mixed_cipher_hash_testsuite_setup,
15483         .unit_test_cases = {
15484                 /** AUTH AES CMAC + CIPHER AES CTR */
15485                 TEST_CASE_ST(ut_setup, ut_teardown,
15486                         test_aes_cmac_aes_ctr_digest_enc_test_case_1),
15487                 TEST_CASE_ST(ut_setup, ut_teardown,
15488                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
15489                 TEST_CASE_ST(ut_setup, ut_teardown,
15490                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
15491                 TEST_CASE_ST(ut_setup, ut_teardown,
15492                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
15493                 TEST_CASE_ST(ut_setup, ut_teardown,
15494                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1),
15495                 TEST_CASE_ST(ut_setup, ut_teardown,
15496                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
15497                 TEST_CASE_ST(ut_setup, ut_teardown,
15498                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
15499                 TEST_CASE_ST(ut_setup, ut_teardown,
15500                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
15501
15502                 /** AUTH ZUC + CIPHER SNOW3G */
15503                 TEST_CASE_ST(ut_setup, ut_teardown,
15504                         test_auth_zuc_cipher_snow_test_case_1),
15505                 TEST_CASE_ST(ut_setup, ut_teardown,
15506                         test_verify_auth_zuc_cipher_snow_test_case_1),
15507                 /** AUTH AES CMAC + CIPHER SNOW3G */
15508                 TEST_CASE_ST(ut_setup, ut_teardown,
15509                         test_auth_aes_cmac_cipher_snow_test_case_1),
15510                 TEST_CASE_ST(ut_setup, ut_teardown,
15511                         test_verify_auth_aes_cmac_cipher_snow_test_case_1),
15512                 /** AUTH ZUC + CIPHER AES CTR */
15513                 TEST_CASE_ST(ut_setup, ut_teardown,
15514                         test_auth_zuc_cipher_aes_ctr_test_case_1),
15515                 TEST_CASE_ST(ut_setup, ut_teardown,
15516                         test_verify_auth_zuc_cipher_aes_ctr_test_case_1),
15517                 /** AUTH SNOW3G + CIPHER AES CTR */
15518                 TEST_CASE_ST(ut_setup, ut_teardown,
15519                         test_auth_snow_cipher_aes_ctr_test_case_1),
15520                 TEST_CASE_ST(ut_setup, ut_teardown,
15521                         test_verify_auth_snow_cipher_aes_ctr_test_case_1),
15522                 /** AUTH SNOW3G + CIPHER ZUC */
15523                 TEST_CASE_ST(ut_setup, ut_teardown,
15524                         test_auth_snow_cipher_zuc_test_case_1),
15525                 TEST_CASE_ST(ut_setup, ut_teardown,
15526                         test_verify_auth_snow_cipher_zuc_test_case_1),
15527                 /** AUTH AES CMAC + CIPHER ZUC */
15528                 TEST_CASE_ST(ut_setup, ut_teardown,
15529                         test_auth_aes_cmac_cipher_zuc_test_case_1),
15530                 TEST_CASE_ST(ut_setup, ut_teardown,
15531                         test_verify_auth_aes_cmac_cipher_zuc_test_case_1),
15532
15533                 /** AUTH NULL + CIPHER SNOW3G */
15534                 TEST_CASE_ST(ut_setup, ut_teardown,
15535                         test_auth_null_cipher_snow_test_case_1),
15536                 TEST_CASE_ST(ut_setup, ut_teardown,
15537                         test_verify_auth_null_cipher_snow_test_case_1),
15538                 /** AUTH NULL + CIPHER ZUC */
15539                 TEST_CASE_ST(ut_setup, ut_teardown,
15540                         test_auth_null_cipher_zuc_test_case_1),
15541                 TEST_CASE_ST(ut_setup, ut_teardown,
15542                         test_verify_auth_null_cipher_zuc_test_case_1),
15543                 /** AUTH SNOW3G + CIPHER NULL */
15544                 TEST_CASE_ST(ut_setup, ut_teardown,
15545                         test_auth_snow_cipher_null_test_case_1),
15546                 TEST_CASE_ST(ut_setup, ut_teardown,
15547                         test_verify_auth_snow_cipher_null_test_case_1),
15548                 /** AUTH ZUC + CIPHER NULL */
15549                 TEST_CASE_ST(ut_setup, ut_teardown,
15550                         test_auth_zuc_cipher_null_test_case_1),
15551                 TEST_CASE_ST(ut_setup, ut_teardown,
15552                         test_verify_auth_zuc_cipher_null_test_case_1),
15553                 /** AUTH NULL + CIPHER AES CTR */
15554                 TEST_CASE_ST(ut_setup, ut_teardown,
15555                         test_auth_null_cipher_aes_ctr_test_case_1),
15556                 TEST_CASE_ST(ut_setup, ut_teardown,
15557                         test_verify_auth_null_cipher_aes_ctr_test_case_1),
15558                 /** AUTH AES CMAC + CIPHER NULL */
15559                 TEST_CASE_ST(ut_setup, ut_teardown,
15560                         test_auth_aes_cmac_cipher_null_test_case_1),
15561                 TEST_CASE_ST(ut_setup, ut_teardown,
15562                         test_verify_auth_aes_cmac_cipher_null_test_case_1),
15563                 TEST_CASES_END()
15564         }
15565 };
15566
15567 static int
15568 run_cryptodev_testsuite(const char *pmd_name)
15569 {
15570         uint8_t ret, j, i = 0, blk_start_idx = 0;
15571         const enum blockcipher_test_type blk_suites[] = {
15572                 BLKCIPHER_AES_CHAIN_TYPE,
15573                 BLKCIPHER_AES_CIPHERONLY_TYPE,
15574                 BLKCIPHER_AES_DOCSIS_TYPE,
15575                 BLKCIPHER_3DES_CHAIN_TYPE,
15576                 BLKCIPHER_3DES_CIPHERONLY_TYPE,
15577                 BLKCIPHER_DES_CIPHERONLY_TYPE,
15578                 BLKCIPHER_DES_DOCSIS_TYPE,
15579                 BLKCIPHER_AUTHONLY_TYPE};
15580         struct unit_test_suite *static_suites[] = {
15581                 &cryptodev_multi_session_testsuite,
15582                 &cryptodev_null_testsuite,
15583                 &cryptodev_aes_ccm_auth_testsuite,
15584                 &cryptodev_aes_gcm_auth_testsuite,
15585                 &cryptodev_aes_gmac_auth_testsuite,
15586                 &cryptodev_snow3g_testsuite,
15587                 &cryptodev_chacha20_poly1305_testsuite,
15588                 &cryptodev_zuc_testsuite,
15589                 &cryptodev_hmac_md5_auth_testsuite,
15590                 &cryptodev_kasumi_testsuite,
15591                 &cryptodev_esn_testsuite,
15592                 &cryptodev_negative_aes_gcm_testsuite,
15593                 &cryptodev_negative_aes_gmac_testsuite,
15594                 &cryptodev_mixed_cipher_hash_testsuite,
15595                 &cryptodev_negative_hmac_sha1_testsuite,
15596                 &cryptodev_gen_testsuite,
15597 #ifdef RTE_LIB_SECURITY
15598                 &ipsec_proto_testsuite,
15599                 &pdcp_proto_testsuite,
15600                 &docsis_proto_testsuite,
15601 #endif
15602                 &end_testsuite
15603         };
15604         static struct unit_test_suite ts = {
15605                 .suite_name = "Cryptodev Unit Test Suite",
15606                 .setup = testsuite_setup,
15607                 .teardown = testsuite_teardown,
15608                 .unit_test_cases = {TEST_CASES_END()}
15609         };
15610
15611         gbl_driver_id = rte_cryptodev_driver_id_get(pmd_name);
15612
15613         if (gbl_driver_id == -1) {
15614                 RTE_LOG(ERR, USER1, "%s PMD must be loaded.\n", pmd_name);
15615                 return TEST_SKIPPED;
15616         }
15617
15618         ts.unit_test_suites = malloc(sizeof(struct unit_test_suite *) *
15619                         (RTE_DIM(blk_suites) + RTE_DIM(static_suites)));
15620
15621         ADD_BLOCKCIPHER_TESTSUITE(i, ts, blk_suites, RTE_DIM(blk_suites));
15622         ADD_STATIC_TESTSUITE(i, ts, static_suites, RTE_DIM(static_suites));
15623         ret = unit_test_suite_runner(&ts);
15624
15625         FREE_BLOCKCIPHER_TESTSUITE(blk_start_idx, ts, RTE_DIM(blk_suites));
15626         free(ts.unit_test_suites);
15627         return ret;
15628 }
15629
15630 static int
15631 require_feature_flag(const char *pmd_name, uint64_t flag, const char *flag_name)
15632 {
15633         struct rte_cryptodev_info dev_info;
15634         uint8_t i, nb_devs;
15635         int driver_id;
15636
15637         driver_id = rte_cryptodev_driver_id_get(pmd_name);
15638         if (driver_id == -1) {
15639                 RTE_LOG(WARNING, USER1, "%s PMD must be loaded.\n", pmd_name);
15640                 return TEST_SKIPPED;
15641         }
15642
15643         nb_devs = rte_cryptodev_count();
15644         if (nb_devs < 1) {
15645                 RTE_LOG(WARNING, USER1, "No crypto devices found?\n");
15646                 return TEST_SKIPPED;
15647         }
15648
15649         for (i = 0; i < nb_devs; i++) {
15650                 rte_cryptodev_info_get(i, &dev_info);
15651                 if (dev_info.driver_id == driver_id) {
15652                         if (!(dev_info.feature_flags & flag)) {
15653                                 RTE_LOG(INFO, USER1, "%s not supported\n",
15654                                                 flag_name);
15655                                 return TEST_SKIPPED;
15656                         }
15657                         return 0; /* found */
15658                 }
15659         }
15660
15661         RTE_LOG(INFO, USER1, "%s not supported\n", flag_name);
15662         return TEST_SKIPPED;
15663 }
15664
15665 static int
15666 test_cryptodev_qat(void)
15667 {
15668         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
15669 }
15670
15671 static int
15672 test_cryptodev_virtio(void)
15673 {
15674         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD));
15675 }
15676
15677 static int
15678 test_cryptodev_aesni_mb(void)
15679 {
15680         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
15681 }
15682
15683 static int
15684 test_cryptodev_cpu_aesni_mb(void)
15685 {
15686         int32_t rc;
15687         enum rte_security_session_action_type at = gbl_action_type;
15688         gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
15689         rc = run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
15690         gbl_action_type = at;
15691         return rc;
15692 }
15693
15694 static int
15695 test_cryptodev_chacha_poly_mb(void)
15696 {
15697         int32_t rc;
15698         enum rte_security_session_action_type at = gbl_action_type;
15699         rc = run_cryptodev_testsuite(
15700                         RTE_STR(CRYPTODEV_NAME_CHACHA20_POLY1305_PMD));
15701         gbl_action_type = at;
15702         return rc;
15703 }
15704
15705 static int
15706 test_cryptodev_openssl(void)
15707 {
15708         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
15709 }
15710
15711 static int
15712 test_cryptodev_aesni_gcm(void)
15713 {
15714         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
15715 }
15716
15717 static int
15718 test_cryptodev_cpu_aesni_gcm(void)
15719 {
15720         int32_t rc;
15721         enum rte_security_session_action_type at = gbl_action_type;
15722         gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
15723         rc  = run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
15724         gbl_action_type = at;
15725         return rc;
15726 }
15727
15728 static int
15729 test_cryptodev_mlx5(void)
15730 {
15731         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_MLX5_PMD));
15732 }
15733
15734 static int
15735 test_cryptodev_null(void)
15736 {
15737         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_NULL_PMD));
15738 }
15739
15740 static int
15741 test_cryptodev_sw_snow3g(void)
15742 {
15743         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
15744 }
15745
15746 static int
15747 test_cryptodev_sw_kasumi(void)
15748 {
15749         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
15750 }
15751
15752 static int
15753 test_cryptodev_sw_zuc(void)
15754 {
15755         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
15756 }
15757
15758 static int
15759 test_cryptodev_armv8(void)
15760 {
15761         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
15762 }
15763
15764 static int
15765 test_cryptodev_mrvl(void)
15766 {
15767         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
15768 }
15769
15770 #ifdef RTE_CRYPTO_SCHEDULER
15771
15772 static int
15773 test_cryptodev_scheduler(void)
15774 {
15775         uint8_t ret, sched_i, j, i = 0, blk_start_idx = 0;
15776         const enum blockcipher_test_type blk_suites[] = {
15777                 BLKCIPHER_AES_CHAIN_TYPE,
15778                 BLKCIPHER_AES_CIPHERONLY_TYPE,
15779                 BLKCIPHER_AUTHONLY_TYPE
15780         };
15781         static struct unit_test_suite scheduler_multicore = {
15782                 .suite_name = "Scheduler Multicore Unit Test Suite",
15783                 .setup = scheduler_multicore_testsuite_setup,
15784                 .teardown = scheduler_mode_testsuite_teardown,
15785                 .unit_test_cases = {TEST_CASES_END()}
15786         };
15787         static struct unit_test_suite scheduler_round_robin = {
15788                 .suite_name = "Scheduler Round Robin Unit Test Suite",
15789                 .setup = scheduler_roundrobin_testsuite_setup,
15790                 .teardown = scheduler_mode_testsuite_teardown,
15791                 .unit_test_cases = {TEST_CASES_END()}
15792         };
15793         static struct unit_test_suite scheduler_failover = {
15794                 .suite_name = "Scheduler Failover Unit Test Suite",
15795                 .setup = scheduler_failover_testsuite_setup,
15796                 .teardown = scheduler_mode_testsuite_teardown,
15797                 .unit_test_cases = {TEST_CASES_END()}
15798         };
15799         static struct unit_test_suite scheduler_pkt_size_distr = {
15800                 .suite_name = "Scheduler Pkt Size Distr Unit Test Suite",
15801                 .setup = scheduler_pkt_size_distr_testsuite_setup,
15802                 .teardown = scheduler_mode_testsuite_teardown,
15803                 .unit_test_cases = {TEST_CASES_END()}
15804         };
15805         struct unit_test_suite *sched_mode_suites[] = {
15806                 &scheduler_multicore,
15807                 &scheduler_round_robin,
15808                 &scheduler_failover,
15809                 &scheduler_pkt_size_distr
15810         };
15811         static struct unit_test_suite scheduler_config = {
15812                 .suite_name = "Crypto Device Scheduler Config Unit Test Suite",
15813                 .unit_test_cases = {
15814                         TEST_CASE(test_scheduler_attach_worker_op),
15815                         TEST_CASE(test_scheduler_mode_multicore_op),
15816                         TEST_CASE(test_scheduler_mode_roundrobin_op),
15817                         TEST_CASE(test_scheduler_mode_failover_op),
15818                         TEST_CASE(test_scheduler_mode_pkt_size_distr_op),
15819                         TEST_CASE(test_scheduler_detach_worker_op),
15820
15821                         TEST_CASES_END() /**< NULL terminate array */
15822                 }
15823         };
15824         struct unit_test_suite *static_suites[] = {
15825                 &scheduler_config,
15826                 &end_testsuite
15827         };
15828         static struct unit_test_suite ts = {
15829                 .suite_name = "Scheduler Unit Test Suite",
15830                 .setup = scheduler_testsuite_setup,
15831                 .teardown = testsuite_teardown,
15832                 .unit_test_cases = {TEST_CASES_END()}
15833         };
15834
15835         gbl_driver_id = rte_cryptodev_driver_id_get(
15836                         RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
15837
15838         if (gbl_driver_id == -1) {
15839                 RTE_LOG(ERR, USER1, "SCHEDULER PMD must be loaded.\n");
15840                 return TEST_SKIPPED;
15841         }
15842
15843         if (rte_cryptodev_driver_id_get(
15844                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) == -1) {
15845                 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded.\n");
15846                 return TEST_SKIPPED;
15847         }
15848
15849         for (sched_i = 0; sched_i < RTE_DIM(sched_mode_suites); sched_i++) {
15850                 uint8_t blk_i = 0;
15851                 sched_mode_suites[sched_i]->unit_test_suites = malloc(sizeof
15852                                 (struct unit_test_suite *) *
15853                                 (RTE_DIM(blk_suites) + 1));
15854                 ADD_BLOCKCIPHER_TESTSUITE(blk_i, (*sched_mode_suites[sched_i]),
15855                                 blk_suites, RTE_DIM(blk_suites));
15856                 sched_mode_suites[sched_i]->unit_test_suites[blk_i] = &end_testsuite;
15857         }
15858
15859         ts.unit_test_suites = malloc(sizeof(struct unit_test_suite *) *
15860                         (RTE_DIM(static_suites) + RTE_DIM(sched_mode_suites)));
15861         ADD_STATIC_TESTSUITE(i, ts, sched_mode_suites,
15862                         RTE_DIM(sched_mode_suites));
15863         ADD_STATIC_TESTSUITE(i, ts, static_suites, RTE_DIM(static_suites));
15864         ret = unit_test_suite_runner(&ts);
15865
15866         for (sched_i = 0; sched_i < RTE_DIM(sched_mode_suites); sched_i++) {
15867                 FREE_BLOCKCIPHER_TESTSUITE(blk_start_idx,
15868                                 (*sched_mode_suites[sched_i]),
15869                                 RTE_DIM(blk_suites));
15870                 free(sched_mode_suites[sched_i]->unit_test_suites);
15871         }
15872         free(ts.unit_test_suites);
15873         return ret;
15874 }
15875
15876 REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler);
15877
15878 #endif
15879
15880 static int
15881 test_cryptodev_dpaa2_sec(void)
15882 {
15883         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
15884 }
15885
15886 static int
15887 test_cryptodev_dpaa_sec(void)
15888 {
15889         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD));
15890 }
15891
15892 static int
15893 test_cryptodev_ccp(void)
15894 {
15895         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CCP_PMD));
15896 }
15897
15898 static int
15899 test_cryptodev_octeontx(void)
15900 {
15901         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD));
15902 }
15903
15904 static int
15905 test_cryptodev_caam_jr(void)
15906 {
15907         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD));
15908 }
15909
15910 static int
15911 test_cryptodev_nitrox(void)
15912 {
15913         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_NITROX_PMD));
15914 }
15915
15916 static int
15917 test_cryptodev_bcmfs(void)
15918 {
15919         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_BCMFS_PMD));
15920 }
15921
15922 static int
15923 test_cryptodev_qat_raw_api(void)
15924 {
15925         static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD);
15926         int ret;
15927
15928         ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
15929                         "RAW API");
15930         if (ret)
15931                 return ret;
15932
15933         global_api_test_type = CRYPTODEV_RAW_API_TEST;
15934         ret = run_cryptodev_testsuite(pmd_name);
15935         global_api_test_type = CRYPTODEV_API_TEST;
15936
15937         return ret;
15938 }
15939
15940 static int
15941 test_cryptodev_cn9k(void)
15942 {
15943         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CN9K_PMD));
15944 }
15945
15946 static int
15947 test_cryptodev_cn10k(void)
15948 {
15949         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CN10K_PMD));
15950 }
15951
15952 static int
15953 test_cryptodev_dpaa2_sec_raw_api(void)
15954 {
15955         static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD);
15956         int ret;
15957
15958         ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
15959                         "RAW API");
15960         if (ret)
15961                 return ret;
15962
15963         global_api_test_type = CRYPTODEV_RAW_API_TEST;
15964         ret = run_cryptodev_testsuite(pmd_name);
15965         global_api_test_type = CRYPTODEV_API_TEST;
15966
15967         return ret;
15968 }
15969
15970 static int
15971 test_cryptodev_dpaa_sec_raw_api(void)
15972 {
15973         static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD);
15974         int ret;
15975
15976         ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
15977                         "RAW API");
15978         if (ret)
15979                 return ret;
15980
15981         global_api_test_type = CRYPTODEV_RAW_API_TEST;
15982         ret = run_cryptodev_testsuite(pmd_name);
15983         global_api_test_type = CRYPTODEV_API_TEST;
15984
15985         return ret;
15986 }
15987
15988 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_raw_api_autotest,
15989                 test_cryptodev_dpaa2_sec_raw_api);
15990 REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_raw_api_autotest,
15991                 test_cryptodev_dpaa_sec_raw_api);
15992 REGISTER_TEST_COMMAND(cryptodev_qat_raw_api_autotest,
15993                 test_cryptodev_qat_raw_api);
15994 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
15995 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
15996 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_mb_autotest,
15997         test_cryptodev_cpu_aesni_mb);
15998 REGISTER_TEST_COMMAND(cryptodev_chacha_poly_mb_autotest,
15999         test_cryptodev_chacha_poly_mb);
16000 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl);
16001 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm);
16002 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_gcm_autotest,
16003         test_cryptodev_cpu_aesni_gcm);
16004 REGISTER_TEST_COMMAND(cryptodev_mlx5_autotest, test_cryptodev_mlx5);
16005 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null);
16006 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
16007 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);
16008 REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc);
16009 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_autotest, test_cryptodev_armv8);
16010 REGISTER_TEST_COMMAND(cryptodev_sw_mvsam_autotest, test_cryptodev_mrvl);
16011 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_autotest, test_cryptodev_dpaa2_sec);
16012 REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_autotest, test_cryptodev_dpaa_sec);
16013 REGISTER_TEST_COMMAND(cryptodev_ccp_autotest, test_cryptodev_ccp);
16014 REGISTER_TEST_COMMAND(cryptodev_virtio_autotest, test_cryptodev_virtio);
16015 REGISTER_TEST_COMMAND(cryptodev_octeontx_autotest, test_cryptodev_octeontx);
16016 REGISTER_TEST_COMMAND(cryptodev_caam_jr_autotest, test_cryptodev_caam_jr);
16017 REGISTER_TEST_COMMAND(cryptodev_nitrox_autotest, test_cryptodev_nitrox);
16018 REGISTER_TEST_COMMAND(cryptodev_bcmfs_autotest, test_cryptodev_bcmfs);
16019 REGISTER_TEST_COMMAND(cryptodev_cn9k_autotest, test_cryptodev_cn9k);
16020 REGISTER_TEST_COMMAND(cryptodev_cn10k_autotest, test_cryptodev_cn10k);