app/test/test_cryptodev.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2015-2020 Intel Corporation
   3  * Copyright 2020 NXP
   4  */
   5
   6 #ifndef RTE_EXEC_ENV_WINDOWS
   7
   8 #include <time.h>
   9
  10 #include <rte_common.h>
  11 #include <rte_hexdump.h>
  12 #include <rte_mbuf.h>
  13 #include <rte_malloc.h>
  14 #include <rte_memcpy.h>
  15 #include <rte_pause.h>
  16 #include <rte_bus_vdev.h>
  17 #include <rte_ether.h>
  18
  19 #include <rte_crypto.h>
  20 #include <rte_cryptodev.h>
  21 #include <rte_ip.h>
  22 #include <rte_string_fns.h>
  23 #include <rte_tcp.h>
  24 #include <rte_udp.h>
  25
  26 #ifdef RTE_CRYPTO_SCHEDULER
  27 #include <rte_cryptodev_scheduler.h>
  28 #include <rte_cryptodev_scheduler_operations.h>
  29 #endif
  30
  31 #include <rte_lcore.h>
  32
  33 #include "test.h"
  34 #include "test_cryptodev.h"
  35
  36 #include "test_cryptodev_blockcipher.h"
  37 #include "test_cryptodev_aes_test_vectors.h"
  38 #include "test_cryptodev_des_test_vectors.h"
  39 #include "test_cryptodev_hash_test_vectors.h"
  40 #include "test_cryptodev_kasumi_test_vectors.h"
  41 #include "test_cryptodev_kasumi_hash_test_vectors.h"
  42 #include "test_cryptodev_snow3g_test_vectors.h"
  43 #include "test_cryptodev_snow3g_hash_test_vectors.h"
  44 #include "test_cryptodev_zuc_test_vectors.h"
  45 #include "test_cryptodev_aead_test_vectors.h"
  46 #include "test_cryptodev_hmac_test_vectors.h"
  47 #include "test_cryptodev_mixed_test_vectors.h"
  48 #ifdef RTE_LIB_SECURITY
  49 #include "test_cryptodev_security_ipsec.h"
  50 #include "test_cryptodev_security_ipsec_test_vectors.h"
  51 #include "test_cryptodev_security_pdcp_test_vectors.h"
  52 #include "test_cryptodev_security_pdcp_sdap_test_vectors.h"
  53 #include "test_cryptodev_security_pdcp_test_func.h"
  54 #include "test_cryptodev_security_docsis_test_vectors.h"
  55
  56 #define SDAP_DISABLED   0
  57 #define SDAP_ENABLED    1
  58 #endif
  59
  60 #define VDEV_ARGS_SIZE 100
  61 #define MAX_NB_SESSIONS 4
  62
  63 #define MAX_DRV_SERVICE_CTX_SIZE 256
  64
  65 #define MAX_RAW_DEQUEUE_COUNT   65535
  66
  67 #define IN_PLACE 0
  68 #define OUT_OF_PLACE 1
  69
  70 static int gbl_driver_id;
  71
  72 static enum rte_security_session_action_type gbl_action_type =
  73         RTE_SECURITY_ACTION_TYPE_NONE;
  74
  75 enum cryptodev_api_test_type global_api_test_type = CRYPTODEV_API_TEST;
  76
  77 struct crypto_unittest_params {
  78         struct rte_crypto_sym_xform cipher_xform;
  79         struct rte_crypto_sym_xform auth_xform;
  80         struct rte_crypto_sym_xform aead_xform;
  81 #ifdef RTE_LIB_SECURITY
  82         struct rte_security_docsis_xform docsis_xform;
  83 #endif
  84
  85         union {
  86                 struct rte_cryptodev_sym_session *sess;
  87 #ifdef RTE_LIB_SECURITY
  88                 struct rte_security_session *sec_session;
  89 #endif
  90         };
  91 #ifdef RTE_LIB_SECURITY
  92         enum rte_security_session_action_type type;
  93 #endif
  94         struct rte_crypto_op *op;
  95
  96         struct rte_mbuf *obuf, *ibuf;
  97
  98         uint8_t *digest;
  99 };
 100
 101 #define ALIGN_POW2_ROUNDUP(num, align) \
 102         (((num) + (align) - 1) & ~((align) - 1))
 103
 104 #define ADD_STATIC_TESTSUITE(index, parent_ts, child_ts, num_child_ts)  \
 105         for (j = 0; j < num_child_ts; index++, j++)                     \
 106                 parent_ts.unit_test_suites[index] = child_ts[j]
 107
 108 #define ADD_BLOCKCIPHER_TESTSUITE(index, parent_ts, blk_types, num_blk_types)   \
 109         for (j = 0; j < num_blk_types; index++, j++)                            \
 110                 parent_ts.unit_test_suites[index] =                             \
 111                                 build_blockcipher_test_suite(blk_types[j])
 112
 113 #define FREE_BLOCKCIPHER_TESTSUITE(index, parent_ts, num_blk_types)             \
 114         for (j = index; j < index + num_blk_types; j++)                         \
 115                 free_blockcipher_test_suite(parent_ts.unit_test_suites[j])
 116
 117 /*
 118  * Forward declarations.
 119  */
 120 static int
 121 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
 122                 struct crypto_unittest_params *ut_params, uint8_t *cipher_key,
 123                 uint8_t *hmac_key);
 124
 125 static int
 126 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
 127                 struct crypto_unittest_params *ut_params,
 128                 struct crypto_testsuite_params *ts_param,
 129                 const uint8_t *cipher,
 130                 const uint8_t *digest,
 131                 const uint8_t *iv);
 132
 133 static int
 134 security_proto_supported(enum rte_security_session_action_type action,
 135         enum rte_security_session_protocol proto);
 136
 137 static int
 138 dev_configure_and_start(uint64_t ff_disable);
 139
 140 static struct rte_mbuf *
 141 setup_test_string(struct rte_mempool *mpool,
 142                 const char *string, size_t len, uint8_t blocksize)
 143 {
 144         struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
 145         size_t t_len = len - (blocksize ? (len % blocksize) : 0);
 146
 147         if (m) {
 148                 char *dst;
 149
 150                 memset(m->buf_addr, 0, m->buf_len);
 151                 dst = rte_pktmbuf_append(m, t_len);
 152                 if (!dst) {
 153                         rte_pktmbuf_free(m);
 154                         return NULL;
 155                 }
 156                 if (string != NULL)
 157                         rte_memcpy(dst, string, t_len);
 158                 else
 159                         memset(dst, 0, t_len);
 160         }
 161
 162         return m;
 163 }
 164
 165 /* Get number of bytes in X bits (rounding up) */
 166 static uint32_t
 167 ceil_byte_length(uint32_t num_bits)
 168 {
 169         if (num_bits % 8)
 170                 return ((num_bits >> 3) + 1);
 171         else
 172                 return (num_bits >> 3);
 173 }
 174
 175 static void
 176 post_process_raw_dp_op(void *user_data, uint32_t index __rte_unused,
 177                 uint8_t is_op_success)
 178 {
 179         struct rte_crypto_op *op = user_data;
 180         op->status = is_op_success ? RTE_CRYPTO_OP_STATUS_SUCCESS :
 181                         RTE_CRYPTO_OP_STATUS_ERROR;
 182 }
 183
 184 static struct crypto_testsuite_params testsuite_params = { NULL };
 185 struct crypto_testsuite_params *p_testsuite_params = &testsuite_params;
 186 static struct crypto_unittest_params unittest_params;
 187
 188 void
 189 process_sym_raw_dp_op(uint8_t dev_id, uint16_t qp_id,
 190                 struct rte_crypto_op *op, uint8_t is_cipher, uint8_t is_auth,
 191                 uint8_t len_in_bits, uint8_t cipher_iv_len)
 192 {
 193         struct rte_crypto_sym_op *sop = op->sym;
 194         struct rte_crypto_op *ret_op = NULL;
 195         struct rte_crypto_vec data_vec[UINT8_MAX], dest_data_vec[UINT8_MAX];
 196         struct rte_crypto_va_iova_ptr cipher_iv, digest, aad_auth_iv;
 197         union rte_crypto_sym_ofs ofs;
 198         struct rte_crypto_sym_vec vec;
 199         struct rte_crypto_sgl sgl, dest_sgl;
 200         uint32_t max_len;
 201         union rte_cryptodev_session_ctx sess;
 202         uint64_t auth_end_iova;
 203         uint32_t count = 0;
 204         struct rte_crypto_raw_dp_ctx *ctx;
 205         uint32_t cipher_offset = 0, cipher_len = 0, auth_offset = 0,
 206                         auth_len = 0;
 207         int32_t n;
 208         uint32_t n_success;
 209         int ctx_service_size;
 210         int32_t status = 0;
 211         int enqueue_status, dequeue_status;
 212         struct crypto_unittest_params *ut_params = &unittest_params;
 213         int is_sgl = sop->m_src->nb_segs > 1;
 214         int is_oop = 0;
 215
 216         ctx_service_size = rte_cryptodev_get_raw_dp_ctx_size(dev_id);
 217         if (ctx_service_size < 0) {
 218                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 219                 return;
 220         }
 221
 222         ctx = malloc(ctx_service_size);
 223         if (!ctx) {
 224                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 225                 return;
 226         }
 227
 228         /* Both are enums, setting crypto_sess will suit any session type */
 229         sess.crypto_sess = op->sym->session;
 230
 231         if (rte_cryptodev_configure_raw_dp_ctx(dev_id, qp_id, ctx,
 232                         op->sess_type, sess, 0) < 0) {
 233                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 234                 goto exit;
 235         }
 236
 237         cipher_iv.iova = 0;
 238         cipher_iv.va = NULL;
 239         aad_auth_iv.iova = 0;
 240         aad_auth_iv.va = NULL;
 241         digest.iova = 0;
 242         digest.va = NULL;
 243         sgl.vec = data_vec;
 244         vec.num = 1;
 245         vec.src_sgl = &sgl;
 246         vec.iv = &cipher_iv;
 247         vec.digest = &digest;
 248         vec.aad = &aad_auth_iv;
 249         vec.status = &status;
 250
 251         ofs.raw = 0;
 252
 253         if ((sop->m_dst != NULL) && (sop->m_dst != sop->m_src))
 254                 is_oop = 1;
 255
 256         if (is_cipher && is_auth) {
 257                 cipher_offset = sop->cipher.data.offset;
 258                 cipher_len = sop->cipher.data.length;
 259                 auth_offset = sop->auth.data.offset;
 260                 auth_len = sop->auth.data.length;
 261                 max_len = RTE_MAX(cipher_offset + cipher_len,
 262                                 auth_offset + auth_len);
 263                 if (len_in_bits) {
 264                         max_len = max_len >> 3;
 265                         cipher_offset = cipher_offset >> 3;
 266                         auth_offset = auth_offset >> 3;
 267                         cipher_len = cipher_len >> 3;
 268                         auth_len = auth_len >> 3;
 269                 }
 270                 ofs.ofs.cipher.head = cipher_offset;
 271                 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
 272                 ofs.ofs.auth.head = auth_offset;
 273                 ofs.ofs.auth.tail = max_len - auth_offset - auth_len;
 274                 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 275                 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
 276                 aad_auth_iv.va = rte_crypto_op_ctod_offset(
 277                                 op, void *, IV_OFFSET + cipher_iv_len);
 278                 aad_auth_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET +
 279                                 cipher_iv_len);
 280                 digest.va = (void *)sop->auth.digest.data;
 281                 digest.iova = sop->auth.digest.phys_addr;
 282
 283                 if (is_sgl) {
 284                         uint32_t remaining_off = auth_offset + auth_len;
 285                         struct rte_mbuf *sgl_buf = sop->m_src;
 286                         if (is_oop)
 287                                 sgl_buf = sop->m_dst;
 288
 289                         while (remaining_off >= rte_pktmbuf_data_len(sgl_buf)
 290                                         && sgl_buf->next != NULL) {
 291                                 remaining_off -= rte_pktmbuf_data_len(sgl_buf);
 292                                 sgl_buf = sgl_buf->next;
 293                         }
 294
 295                         auth_end_iova = (uint64_t)rte_pktmbuf_iova_offset(
 296                                 sgl_buf, remaining_off);
 297                 } else {
 298                         auth_end_iova = rte_pktmbuf_iova(op->sym->m_src) +
 299                                                          auth_offset + auth_len;
 300                 }
 301                 /* Then check if digest-encrypted conditions are met */
 302                 if ((auth_offset + auth_len < cipher_offset + cipher_len) &&
 303                                 (digest.iova == auth_end_iova) && is_sgl)
 304                         max_len = RTE_MAX(max_len,
 305                                 auth_offset + auth_len +
 306                                 ut_params->auth_xform.auth.digest_length);
 307
 308         } else if (is_cipher) {
 309                 cipher_offset = sop->cipher.data.offset;
 310                 cipher_len = sop->cipher.data.length;
 311                 max_len = cipher_len + cipher_offset;
 312                 if (len_in_bits) {
 313                         max_len = max_len >> 3;
 314                         cipher_offset = cipher_offset >> 3;
 315                         cipher_len = cipher_len >> 3;
 316                 }
 317                 ofs.ofs.cipher.head = cipher_offset;
 318                 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
 319                 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 320                 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
 321
 322         } else if (is_auth) {
 323                 auth_offset = sop->auth.data.offset;
 324                 auth_len = sop->auth.data.length;
 325                 max_len = auth_len + auth_offset;
 326                 if (len_in_bits) {
 327                         max_len = max_len >> 3;
 328                         auth_offset = auth_offset >> 3;
 329                         auth_len = auth_len >> 3;
 330                 }
 331                 ofs.ofs.auth.head = auth_offset;
 332                 ofs.ofs.auth.tail = max_len - auth_offset - auth_len;
 333                 aad_auth_iv.va = rte_crypto_op_ctod_offset(
 334                                 op, void *, IV_OFFSET + cipher_iv_len);
 335                 aad_auth_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET +
 336                                 cipher_iv_len);
 337                 digest.va = (void *)sop->auth.digest.data;
 338                 digest.iova = sop->auth.digest.phys_addr;
 339
 340         } else { /* aead */
 341                 cipher_offset = sop->aead.data.offset;
 342                 cipher_len = sop->aead.data.length;
 343                 max_len = cipher_len + cipher_offset;
 344                 if (len_in_bits) {
 345                         max_len = max_len >> 3;
 346                         cipher_offset = cipher_offset >> 3;
 347                         cipher_len = cipher_len >> 3;
 348                 }
 349                 ofs.ofs.cipher.head = cipher_offset;
 350                 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
 351                 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 352                 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
 353                 aad_auth_iv.va = (void *)sop->aead.aad.data;
 354                 aad_auth_iv.iova = sop->aead.aad.phys_addr;
 355                 digest.va = (void *)sop->aead.digest.data;
 356                 digest.iova = sop->aead.digest.phys_addr;
 357         }
 358
 359         n = rte_crypto_mbuf_to_vec(sop->m_src, 0, max_len,
 360                         data_vec, RTE_DIM(data_vec));
 361         if (n < 0 || n > sop->m_src->nb_segs) {
 362                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 363                 goto exit;
 364         }
 365
 366         sgl.num = n;
 367         /* Out of place */
 368         if (is_oop) {
 369                 dest_sgl.vec = dest_data_vec;
 370                 vec.dest_sgl = &dest_sgl;
 371                 n = rte_crypto_mbuf_to_vec(sop->m_dst, 0, max_len,
 372                                 dest_data_vec, RTE_DIM(dest_data_vec));
 373                 if (n < 0 || n > sop->m_dst->nb_segs) {
 374                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 375                         goto exit;
 376                 }
 377                 dest_sgl.num = n;
 378         } else
 379                 vec.dest_sgl = NULL;
 380
 381         if (rte_cryptodev_raw_enqueue_burst(ctx, &vec, ofs, (void **)&op,
 382                         &enqueue_status) < 1) {
 383                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 384                 goto exit;
 385         }
 386
 387         if (enqueue_status == 0) {
 388                 status = rte_cryptodev_raw_enqueue_done(ctx, 1);
 389                 if (status < 0) {
 390                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 391                         goto exit;
 392                 }
 393         } else if (enqueue_status < 0) {
 394                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 395                 goto exit;
 396         }
 397
 398         n = n_success = 0;
 399         while (count++ < MAX_RAW_DEQUEUE_COUNT && n == 0) {
 400                 n = rte_cryptodev_raw_dequeue_burst(ctx,
 401                         NULL, 1, post_process_raw_dp_op,
 402                                 (void **)&ret_op, 0, &n_success,
 403                                 &dequeue_status);
 404                 if (dequeue_status < 0) {
 405                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 406                         goto exit;
 407                 }
 408                 if (n == 0)
 409                         rte_pause();
 410         }
 411
 412         if (n == 1 && dequeue_status == 0) {
 413                 if (rte_cryptodev_raw_dequeue_done(ctx, 1) < 0) {
 414                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 415                         goto exit;
 416                 }
 417         }
 418
 419         op->status = (count == MAX_RAW_DEQUEUE_COUNT + 1 || ret_op != op ||
 420                         ret_op->status == RTE_CRYPTO_OP_STATUS_ERROR ||
 421                         n_success < 1) ? RTE_CRYPTO_OP_STATUS_ERROR :
 422                                         RTE_CRYPTO_OP_STATUS_SUCCESS;
 423
 424 exit:
 425         free(ctx);
 426 }
 427
 428 static void
 429 process_cpu_aead_op(uint8_t dev_id, struct rte_crypto_op *op)
 430 {
 431         int32_t n, st;
 432         struct rte_crypto_sym_op *sop;
 433         union rte_crypto_sym_ofs ofs;
 434         struct rte_crypto_sgl sgl;
 435         struct rte_crypto_sym_vec symvec;
 436         struct rte_crypto_va_iova_ptr iv_ptr, aad_ptr, digest_ptr;
 437         struct rte_crypto_vec vec[UINT8_MAX];
 438
 439         sop = op->sym;
 440
 441         n = rte_crypto_mbuf_to_vec(sop->m_src, sop->aead.data.offset,
 442                 sop->aead.data.length, vec, RTE_DIM(vec));
 443
 444         if (n < 0 || n != sop->m_src->nb_segs) {
 445                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 446                 return;
 447         }
 448
 449         sgl.vec = vec;
 450         sgl.num = n;
 451         symvec.src_sgl = &sgl;
 452         symvec.iv = &iv_ptr;
 453         symvec.digest = &digest_ptr;
 454         symvec.aad = &aad_ptr;
 455         symvec.status = &st;
 456         symvec.num = 1;
 457
 458         /* for CPU crypto the IOVA address is not required */
 459         iv_ptr.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 460         digest_ptr.va = (void *)sop->aead.digest.data;
 461         aad_ptr.va = (void *)sop->aead.aad.data;
 462
 463         ofs.raw = 0;
 464
 465         n = rte_cryptodev_sym_cpu_crypto_process(dev_id, sop->session, ofs,
 466                 &symvec);
 467
 468         if (n != 1)
 469                 op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
 470         else
 471                 op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
 472 }
 473
 474 static void
 475 process_cpu_crypt_auth_op(uint8_t dev_id, struct rte_crypto_op *op)
 476 {
 477         int32_t n, st;
 478         struct rte_crypto_sym_op *sop;
 479         union rte_crypto_sym_ofs ofs;
 480         struct rte_crypto_sgl sgl;
 481         struct rte_crypto_sym_vec symvec;
 482         struct rte_crypto_va_iova_ptr iv_ptr, digest_ptr;
 483         struct rte_crypto_vec vec[UINT8_MAX];
 484
 485         sop = op->sym;
 486
 487         n = rte_crypto_mbuf_to_vec(sop->m_src, sop->auth.data.offset,
 488                 sop->auth.data.length, vec, RTE_DIM(vec));
 489
 490         if (n < 0 || n != sop->m_src->nb_segs) {
 491                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 492                 return;
 493         }
 494
 495         sgl.vec = vec;
 496         sgl.num = n;
 497         symvec.src_sgl = &sgl;
 498         symvec.iv = &iv_ptr;
 499         symvec.digest = &digest_ptr;
 500         symvec.status = &st;
 501         symvec.num = 1;
 502
 503         iv_ptr.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 504         digest_ptr.va = (void *)sop->auth.digest.data;
 505
 506         ofs.raw = 0;
 507         ofs.ofs.cipher.head = sop->cipher.data.offset - sop->auth.data.offset;
 508         ofs.ofs.cipher.tail = (sop->auth.data.offset + sop->auth.data.length) -
 509                 (sop->cipher.data.offset + sop->cipher.data.length);
 510
 511         n = rte_cryptodev_sym_cpu_crypto_process(dev_id, sop->session, ofs,
 512                 &symvec);
 513
 514         if (n != 1)
 515                 op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
 516         else
 517                 op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
 518 }
 519
 520 static struct rte_crypto_op *
 521 process_crypto_request(uint8_t dev_id, struct rte_crypto_op *op)
 522 {
 523
 524         RTE_VERIFY(gbl_action_type != RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO);
 525
 526         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
 527                 RTE_LOG(ERR, USER1, "Error sending packet for encryption\n");
 528                 return NULL;
 529         }
 530
 531         op = NULL;
 532
 533         while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0)
 534                 rte_pause();
 535
 536         if (op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
 537                 RTE_LOG(DEBUG, USER1, "Operation status %d\n", op->status);
 538                 return NULL;
 539         }
 540
 541         return op;
 542 }
 543
 544 static int
 545 testsuite_setup(void)
 546 {
 547         struct crypto_testsuite_params *ts_params = &testsuite_params;
 548         struct rte_cryptodev_info info;
 549         uint32_t i = 0, nb_devs, dev_id;
 550         uint16_t qp_id;
 551
 552         memset(ts_params, 0, sizeof(*ts_params));
 553
 554         ts_params->mbuf_pool = rte_mempool_lookup("CRYPTO_MBUFPOOL");
 555         if (ts_params->mbuf_pool == NULL) {
 556                 /* Not already created so create */
 557                 ts_params->mbuf_pool = rte_pktmbuf_pool_create(
 558                                 "CRYPTO_MBUFPOOL",
 559                                 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
 560                                 rte_socket_id());
 561                 if (ts_params->mbuf_pool == NULL) {
 562                         RTE_LOG(ERR, USER1, "Can't create CRYPTO_MBUFPOOL\n");
 563                         return TEST_FAILED;
 564                 }
 565         }
 566
 567         ts_params->large_mbuf_pool = rte_mempool_lookup(
 568                         "CRYPTO_LARGE_MBUFPOOL");
 569         if (ts_params->large_mbuf_pool == NULL) {
 570                 /* Not already created so create */
 571                 ts_params->large_mbuf_pool = rte_pktmbuf_pool_create(
 572                                 "CRYPTO_LARGE_MBUFPOOL",
 573                                 1, 0, 0, UINT16_MAX,
 574                                 rte_socket_id());
 575                 if (ts_params->large_mbuf_pool == NULL) {
 576                         RTE_LOG(ERR, USER1,
 577                                 "Can't create CRYPTO_LARGE_MBUFPOOL\n");
 578                         return TEST_FAILED;
 579                 }
 580         }
 581
 582         ts_params->op_mpool = rte_crypto_op_pool_create(
 583                         "MBUF_CRYPTO_SYM_OP_POOL",
 584                         RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 585                         NUM_MBUFS, MBUF_CACHE_SIZE,
 586                         DEFAULT_NUM_XFORMS *
 587                         sizeof(struct rte_crypto_sym_xform) +
 588                         MAXIMUM_IV_LENGTH,
 589                         rte_socket_id());
 590         if (ts_params->op_mpool == NULL) {
 591                 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
 592                 return TEST_FAILED;
 593         }
 594
 595         nb_devs = rte_cryptodev_count();
 596         if (nb_devs < 1) {
 597                 RTE_LOG(WARNING, USER1, "No crypto devices found?\n");
 598                 return TEST_SKIPPED;
 599         }
 600
 601         if (rte_cryptodev_device_count_by_driver(gbl_driver_id) < 1) {
 602                 RTE_LOG(WARNING, USER1, "No %s devices found?\n",
 603                                 rte_cryptodev_driver_name_get(gbl_driver_id));
 604                 return TEST_SKIPPED;
 605         }
 606
 607         /* Create list of valid crypto devs */
 608         for (i = 0; i < nb_devs; i++) {
 609                 rte_cryptodev_info_get(i, &info);
 610                 if (info.driver_id == gbl_driver_id)
 611                         ts_params->valid_devs[ts_params->valid_dev_count++] = i;
 612         }
 613
 614         if (ts_params->valid_dev_count < 1)
 615                 return TEST_FAILED;
 616
 617         /* Set up all the qps on the first of the valid devices found */
 618
 619         dev_id = ts_params->valid_devs[0];
 620
 621         rte_cryptodev_info_get(dev_id, &info);
 622
 623         ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
 624         ts_params->conf.socket_id = SOCKET_ID_ANY;
 625         ts_params->conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY;
 626
 627         unsigned int session_size =
 628                 rte_cryptodev_sym_get_private_session_size(dev_id);
 629
 630 #ifdef RTE_LIB_SECURITY
 631         unsigned int security_session_size = rte_security_session_get_size(
 632                         rte_cryptodev_get_sec_ctx(dev_id));
 633
 634         if (session_size < security_session_size)
 635                 session_size = security_session_size;
 636 #endif
 637         /*
 638          * Create mempool with maximum number of sessions.
 639          */
 640         if (info.sym.max_nb_sessions != 0 &&
 641                         info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
 642                 RTE_LOG(ERR, USER1, "Device does not support "
 643                                 "at least %u sessions\n",
 644                                 MAX_NB_SESSIONS);
 645                 return TEST_FAILED;
 646         }
 647
 648         ts_params->session_mpool = rte_cryptodev_sym_session_pool_create(
 649                         "test_sess_mp", MAX_NB_SESSIONS, 0, 0, 0,
 650                         SOCKET_ID_ANY);
 651         TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
 652                         "session mempool allocation failed");
 653
 654         ts_params->session_priv_mpool = rte_mempool_create(
 655                         "test_sess_mp_priv",
 656                         MAX_NB_SESSIONS,
 657                         session_size,
 658                         0, 0, NULL, NULL, NULL,
 659                         NULL, SOCKET_ID_ANY,
 660                         0);
 661         TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
 662                         "session mempool allocation failed");
 663
 664
 665
 666         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id,
 667                         &ts_params->conf),
 668                         "Failed to configure cryptodev %u with %u qps",
 669                         dev_id, ts_params->conf.nb_queue_pairs);
 670
 671         ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
 672         ts_params->qp_conf.mp_session = ts_params->session_mpool;
 673         ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
 674
 675         for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) {
 676                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 677                         dev_id, qp_id, &ts_params->qp_conf,
 678                         rte_cryptodev_socket_id(dev_id)),
 679                         "Failed to setup queue pair %u on cryptodev %u",
 680                         qp_id, dev_id);
 681         }
 682
 683         return TEST_SUCCESS;
 684 }
 685
 686 static void
 687 testsuite_teardown(void)
 688 {
 689         struct crypto_testsuite_params *ts_params = &testsuite_params;
 690         int res;
 691
 692         if (ts_params->mbuf_pool != NULL) {
 693                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
 694                 rte_mempool_avail_count(ts_params->mbuf_pool));
 695         }
 696
 697         if (ts_params->op_mpool != NULL) {
 698                 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n",
 699                 rte_mempool_avail_count(ts_params->op_mpool));
 700         }
 701
 702         /* Free session mempools */
 703         if (ts_params->session_priv_mpool != NULL) {
 704                 rte_mempool_free(ts_params->session_priv_mpool);
 705                 ts_params->session_priv_mpool = NULL;
 706         }
 707
 708         if (ts_params->session_mpool != NULL) {
 709                 rte_mempool_free(ts_params->session_mpool);
 710                 ts_params->session_mpool = NULL;
 711         }
 712
 713         res = rte_cryptodev_close(ts_params->valid_devs[0]);
 714         if (res)
 715                 RTE_LOG(ERR, USER1, "Crypto device close error %d\n", res);
 716 }
 717
 718 static int
 719 check_capabilities_supported(enum rte_crypto_sym_xform_type type,
 720                 const int *algs, uint16_t num_algs)
 721 {
 722         uint8_t dev_id = testsuite_params.valid_devs[0];
 723         bool some_alg_supported = FALSE;
 724         uint16_t i;
 725
 726         for (i = 0; i < num_algs && !some_alg_supported; i++) {
 727                 struct rte_cryptodev_sym_capability_idx alg = {
 728                         type, {algs[i]}
 729                 };
 730                 if (rte_cryptodev_sym_capability_get(dev_id,
 731                                 &alg) != NULL)
 732                         some_alg_supported = TRUE;
 733         }
 734         if (!some_alg_supported)
 735                 return TEST_SKIPPED;
 736
 737         return 0;
 738 }
 739
 740 int
 741 check_cipher_capabilities_supported(const enum rte_crypto_cipher_algorithm *ciphers,
 742                 uint16_t num_ciphers)
 743 {
 744         return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_CIPHER,
 745                         (const int *) ciphers, num_ciphers);
 746 }
 747
 748 int
 749 check_auth_capabilities_supported(const enum rte_crypto_auth_algorithm *auths,
 750                 uint16_t num_auths)
 751 {
 752         return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_AUTH,
 753                         (const int *) auths, num_auths);
 754 }
 755
 756 int
 757 check_aead_capabilities_supported(const enum rte_crypto_aead_algorithm *aeads,
 758                 uint16_t num_aeads)
 759 {
 760         return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_AEAD,
 761                         (const int *) aeads, num_aeads);
 762 }
 763
 764 static int
 765 null_testsuite_setup(void)
 766 {
 767         struct crypto_testsuite_params *ts_params = &testsuite_params;
 768         uint8_t dev_id = ts_params->valid_devs[0];
 769         struct rte_cryptodev_info dev_info;
 770         const enum rte_crypto_cipher_algorithm ciphers[] = {
 771                 RTE_CRYPTO_CIPHER_NULL
 772         };
 773         const enum rte_crypto_auth_algorithm auths[] = {
 774                 RTE_CRYPTO_AUTH_NULL
 775         };
 776
 777         rte_cryptodev_info_get(dev_id, &dev_info);
 778
 779         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
 780                 RTE_LOG(INFO, USER1, "Feature flag requirements for NULL "
 781                                 "testsuite not met\n");
 782                 return TEST_SKIPPED;
 783         }
 784
 785         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
 786                         && check_auth_capabilities_supported(auths,
 787                         RTE_DIM(auths)) != 0) {
 788                 RTE_LOG(INFO, USER1, "Capability requirements for NULL "
 789                                 "testsuite not met\n");
 790                 return TEST_SKIPPED;
 791         }
 792
 793         return 0;
 794 }
 795
 796 static int
 797 crypto_gen_testsuite_setup(void)
 798 {
 799         struct crypto_testsuite_params *ts_params = &testsuite_params;
 800         uint8_t dev_id = ts_params->valid_devs[0];
 801         struct rte_cryptodev_info dev_info;
 802
 803         rte_cryptodev_info_get(dev_id, &dev_info);
 804
 805         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
 806                 RTE_LOG(INFO, USER1, "Feature flag requirements for Crypto Gen "
 807                                 "testsuite not met\n");
 808                 return TEST_SKIPPED;
 809         }
 810
 811         return 0;
 812 }
 813
 814 #ifdef RTE_LIB_SECURITY
 815 static int
 816 ipsec_proto_testsuite_setup(void)
 817 {
 818         struct crypto_testsuite_params *ts_params = &testsuite_params;
 819         struct crypto_unittest_params *ut_params = &unittest_params;
 820         struct rte_cryptodev_info dev_info;
 821         int ret = 0;
 822
 823         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 824
 825         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SECURITY)) {
 826                 RTE_LOG(INFO, USER1, "Feature flag requirements for IPsec Proto "
 827                                 "testsuite not met\n");
 828                 return TEST_SKIPPED;
 829         }
 830
 831         /* Reconfigure to enable security */
 832         ret = dev_configure_and_start(0);
 833         if (ret != TEST_SUCCESS)
 834                 return ret;
 835
 836         /* Set action type */
 837         ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
 838
 839         if (security_proto_supported(
 840                         RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
 841                         RTE_SECURITY_PROTOCOL_IPSEC) < 0) {
 842                 RTE_LOG(INFO, USER1, "Capability requirements for IPsec Proto "
 843                                 "test not met\n");
 844                 ret = TEST_SKIPPED;
 845         }
 846
 847         test_ipsec_alg_list_populate();
 848
 849         /*
 850          * Stop the device. Device would be started again by individual test
 851          * case setup routine.
 852          */
 853         rte_cryptodev_stop(ts_params->valid_devs[0]);
 854
 855         return ret;
 856 }
 857
 858 static int
 859 pdcp_proto_testsuite_setup(void)
 860 {
 861         struct crypto_testsuite_params *ts_params = &testsuite_params;
 862         uint8_t dev_id = ts_params->valid_devs[0];
 863         struct rte_cryptodev_info dev_info;
 864         const enum rte_crypto_cipher_algorithm ciphers[] = {
 865                 RTE_CRYPTO_CIPHER_NULL,
 866                 RTE_CRYPTO_CIPHER_AES_CTR,
 867                 RTE_CRYPTO_CIPHER_ZUC_EEA3,
 868                 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
 869         };
 870         const enum rte_crypto_auth_algorithm auths[] = {
 871                 RTE_CRYPTO_AUTH_NULL,
 872                 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
 873                 RTE_CRYPTO_AUTH_AES_CMAC,
 874                 RTE_CRYPTO_AUTH_ZUC_EIA3
 875         };
 876
 877         rte_cryptodev_info_get(dev_id, &dev_info);
 878
 879         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 880                         !(dev_info.feature_flags &
 881                         RTE_CRYPTODEV_FF_SECURITY)) {
 882                 RTE_LOG(INFO, USER1, "Feature flag requirements for PDCP Proto "
 883                                 "testsuite not met\n");
 884                 return TEST_SKIPPED;
 885         }
 886
 887         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
 888                         && check_auth_capabilities_supported(auths,
 889                         RTE_DIM(auths)) != 0) {
 890                 RTE_LOG(INFO, USER1, "Capability requirements for PDCP Proto "
 891                                 "testsuite not met\n");
 892                 return TEST_SKIPPED;
 893         }
 894
 895         return 0;
 896 }
 897
 898 static int
 899 docsis_proto_testsuite_setup(void)
 900 {
 901         struct crypto_testsuite_params *ts_params = &testsuite_params;
 902         uint8_t dev_id = ts_params->valid_devs[0];
 903         struct rte_cryptodev_info dev_info;
 904         const enum rte_crypto_cipher_algorithm ciphers[] = {
 905                 RTE_CRYPTO_CIPHER_AES_DOCSISBPI
 906         };
 907
 908         rte_cryptodev_info_get(dev_id, &dev_info);
 909
 910         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 911                         !(dev_info.feature_flags &
 912                         RTE_CRYPTODEV_FF_SECURITY)) {
 913                 RTE_LOG(INFO, USER1, "Feature flag requirements for DOCSIS "
 914                                 "Proto testsuite not met\n");
 915                 return TEST_SKIPPED;
 916         }
 917
 918         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0) {
 919                 RTE_LOG(INFO, USER1, "Capability requirements for DOCSIS Proto "
 920                                 "testsuite not met\n");
 921                 return TEST_SKIPPED;
 922         }
 923
 924         return 0;
 925 }
 926 #endif
 927
 928 static int
 929 aes_ccm_auth_testsuite_setup(void)
 930 {
 931         struct crypto_testsuite_params *ts_params = &testsuite_params;
 932         uint8_t dev_id = ts_params->valid_devs[0];
 933         struct rte_cryptodev_info dev_info;
 934         const enum rte_crypto_aead_algorithm aeads[] = {
 935                 RTE_CRYPTO_AEAD_AES_CCM
 936         };
 937
 938         rte_cryptodev_info_get(dev_id, &dev_info);
 939
 940         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 941                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
 942                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
 943                 RTE_LOG(INFO, USER1, "Feature flag requirements for AES CCM "
 944                                 "testsuite not met\n");
 945                 return TEST_SKIPPED;
 946         }
 947
 948         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
 949                 RTE_LOG(INFO, USER1, "Capability requirements for AES CCM "
 950                                 "testsuite not met\n");
 951                 return TEST_SKIPPED;
 952         }
 953
 954         return 0;
 955 }
 956
 957 static int
 958 aes_gcm_auth_testsuite_setup(void)
 959 {
 960         struct crypto_testsuite_params *ts_params = &testsuite_params;
 961         uint8_t dev_id = ts_params->valid_devs[0];
 962         struct rte_cryptodev_info dev_info;
 963         const enum rte_crypto_aead_algorithm aeads[] = {
 964                 RTE_CRYPTO_AEAD_AES_GCM
 965         };
 966
 967         rte_cryptodev_info_get(dev_id, &dev_info);
 968
 969         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
 970                 RTE_LOG(INFO, USER1, "Feature flag requirements for AES GCM "
 971                                 "testsuite not met\n");
 972                 return TEST_SKIPPED;
 973         }
 974
 975         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
 976                 RTE_LOG(INFO, USER1, "Capability requirements for AES GCM "
 977                                 "testsuite not met\n");
 978                 return TEST_SKIPPED;
 979         }
 980
 981         return 0;
 982 }
 983
 984 static int
 985 aes_gmac_auth_testsuite_setup(void)
 986 {
 987         struct crypto_testsuite_params *ts_params = &testsuite_params;
 988         uint8_t dev_id = ts_params->valid_devs[0];
 989         struct rte_cryptodev_info dev_info;
 990         const enum rte_crypto_auth_algorithm auths[] = {
 991                 RTE_CRYPTO_AUTH_AES_GMAC
 992         };
 993
 994         rte_cryptodev_info_get(dev_id, &dev_info);
 995
 996         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 997                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
 998                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
 999                 RTE_LOG(INFO, USER1, "Feature flag requirements for AES GMAC "
1000                                 "testsuite not met\n");
1001                 return TEST_SKIPPED;
1002         }
1003
1004         if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
1005                 RTE_LOG(INFO, USER1, "Capability requirements for AES GMAC "
1006                                 "testsuite not met\n");
1007                 return TEST_SKIPPED;
1008         }
1009
1010         return 0;
1011 }
1012
1013 static int
1014 chacha20_poly1305_testsuite_setup(void)
1015 {
1016         struct crypto_testsuite_params *ts_params = &testsuite_params;
1017         uint8_t dev_id = ts_params->valid_devs[0];
1018         struct rte_cryptodev_info dev_info;
1019         const enum rte_crypto_aead_algorithm aeads[] = {
1020                 RTE_CRYPTO_AEAD_CHACHA20_POLY1305
1021         };
1022
1023         rte_cryptodev_info_get(dev_id, &dev_info);
1024
1025         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1026                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1027                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1028                 RTE_LOG(INFO, USER1, "Feature flag requirements for "
1029                                 "Chacha20-Poly1305 testsuite not met\n");
1030                 return TEST_SKIPPED;
1031         }
1032
1033         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
1034                 RTE_LOG(INFO, USER1, "Capability requirements for "
1035                                 "Chacha20-Poly1305 testsuite not met\n");
1036                 return TEST_SKIPPED;
1037         }
1038
1039         return 0;
1040 }
1041
1042 static int
1043 snow3g_testsuite_setup(void)
1044 {
1045         struct crypto_testsuite_params *ts_params = &testsuite_params;
1046         uint8_t dev_id = ts_params->valid_devs[0];
1047         struct rte_cryptodev_info dev_info;
1048         const enum rte_crypto_cipher_algorithm ciphers[] = {
1049                 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
1050
1051         };
1052         const enum rte_crypto_auth_algorithm auths[] = {
1053                 RTE_CRYPTO_AUTH_SNOW3G_UIA2
1054         };
1055
1056         rte_cryptodev_info_get(dev_id, &dev_info);
1057
1058         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1059                 RTE_LOG(INFO, USER1, "Feature flag requirements for Snow3G "
1060                                 "testsuite not met\n");
1061                 return TEST_SKIPPED;
1062         }
1063
1064         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1065                         && check_auth_capabilities_supported(auths,
1066                         RTE_DIM(auths)) != 0) {
1067                 RTE_LOG(INFO, USER1, "Capability requirements for Snow3G "
1068                                 "testsuite not met\n");
1069                 return TEST_SKIPPED;
1070         }
1071
1072         return 0;
1073 }
1074
1075 static int
1076 zuc_testsuite_setup(void)
1077 {
1078         struct crypto_testsuite_params *ts_params = &testsuite_params;
1079         uint8_t dev_id = ts_params->valid_devs[0];
1080         struct rte_cryptodev_info dev_info;
1081         const enum rte_crypto_cipher_algorithm ciphers[] = {
1082                 RTE_CRYPTO_CIPHER_ZUC_EEA3
1083         };
1084         const enum rte_crypto_auth_algorithm auths[] = {
1085                 RTE_CRYPTO_AUTH_ZUC_EIA3
1086         };
1087
1088         rte_cryptodev_info_get(dev_id, &dev_info);
1089
1090         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1091                 RTE_LOG(INFO, USER1, "Feature flag requirements for ZUC "
1092                                 "testsuite not met\n");
1093                 return TEST_SKIPPED;
1094         }
1095
1096         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1097                         && check_auth_capabilities_supported(auths,
1098                         RTE_DIM(auths)) != 0) {
1099                 RTE_LOG(INFO, USER1, "Capability requirements for ZUC "
1100                                 "testsuite not met\n");
1101                 return TEST_SKIPPED;
1102         }
1103
1104         return 0;
1105 }
1106
1107 static int
1108 hmac_md5_auth_testsuite_setup(void)
1109 {
1110         struct crypto_testsuite_params *ts_params = &testsuite_params;
1111         uint8_t dev_id = ts_params->valid_devs[0];
1112         struct rte_cryptodev_info dev_info;
1113         const enum rte_crypto_auth_algorithm auths[] = {
1114                 RTE_CRYPTO_AUTH_MD5_HMAC
1115         };
1116
1117         rte_cryptodev_info_get(dev_id, &dev_info);
1118
1119         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1120                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1121                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1122                 RTE_LOG(INFO, USER1, "Feature flag requirements for HMAC MD5 "
1123                                 "Auth testsuite not met\n");
1124                 return TEST_SKIPPED;
1125         }
1126
1127         if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
1128                 RTE_LOG(INFO, USER1, "Capability requirements for HMAC MD5 "
1129                                 "testsuite not met\n");
1130                 return TEST_SKIPPED;
1131         }
1132
1133         return 0;
1134 }
1135
1136 static int
1137 kasumi_testsuite_setup(void)
1138 {
1139         struct crypto_testsuite_params *ts_params = &testsuite_params;
1140         uint8_t dev_id = ts_params->valid_devs[0];
1141         struct rte_cryptodev_info dev_info;
1142         const enum rte_crypto_cipher_algorithm ciphers[] = {
1143                 RTE_CRYPTO_CIPHER_KASUMI_F8
1144         };
1145         const enum rte_crypto_auth_algorithm auths[] = {
1146                 RTE_CRYPTO_AUTH_KASUMI_F9
1147         };
1148
1149         rte_cryptodev_info_get(dev_id, &dev_info);
1150
1151         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1152                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1153                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1154                 RTE_LOG(INFO, USER1, "Feature flag requirements for Kasumi "
1155                                 "testsuite not met\n");
1156                 return TEST_SKIPPED;
1157         }
1158
1159         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1160                         && check_auth_capabilities_supported(auths,
1161                         RTE_DIM(auths)) != 0) {
1162                 RTE_LOG(INFO, USER1, "Capability requirements for Kasumi "
1163                                 "testsuite not met\n");
1164                 return TEST_SKIPPED;
1165         }
1166
1167         return 0;
1168 }
1169
1170 static int
1171 negative_aes_gcm_testsuite_setup(void)
1172 {
1173         struct crypto_testsuite_params *ts_params = &testsuite_params;
1174         uint8_t dev_id = ts_params->valid_devs[0];
1175         struct rte_cryptodev_info dev_info;
1176         const enum rte_crypto_aead_algorithm aeads[] = {
1177                 RTE_CRYPTO_AEAD_AES_GCM
1178         };
1179
1180         rte_cryptodev_info_get(dev_id, &dev_info);
1181
1182         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1183                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1184                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1185                 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1186                                 "AES GCM testsuite not met\n");
1187                 return TEST_SKIPPED;
1188         }
1189
1190         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
1191                 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1192                                 "AES GCM testsuite not met\n");
1193                 return TEST_SKIPPED;
1194         }
1195
1196         return 0;
1197 }
1198
1199 static int
1200 negative_aes_gmac_testsuite_setup(void)
1201 {
1202         struct crypto_testsuite_params *ts_params = &testsuite_params;
1203         uint8_t dev_id = ts_params->valid_devs[0];
1204         struct rte_cryptodev_info dev_info;
1205         const enum rte_crypto_auth_algorithm auths[] = {
1206                 RTE_CRYPTO_AUTH_AES_GMAC
1207         };
1208
1209         rte_cryptodev_info_get(dev_id, &dev_info);
1210
1211         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1212                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1213                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1214                 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1215                                 "AES GMAC testsuite not met\n");
1216                 return TEST_SKIPPED;
1217         }
1218
1219         if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
1220                 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1221                                 "AES GMAC testsuite not met\n");
1222                 return TEST_SKIPPED;
1223         }
1224
1225         return 0;
1226 }
1227
1228 static int
1229 mixed_cipher_hash_testsuite_setup(void)
1230 {
1231         struct crypto_testsuite_params *ts_params = &testsuite_params;
1232         uint8_t dev_id = ts_params->valid_devs[0];
1233         struct rte_cryptodev_info dev_info;
1234         uint64_t feat_flags;
1235         const enum rte_crypto_cipher_algorithm ciphers[] = {
1236                 RTE_CRYPTO_CIPHER_NULL,
1237                 RTE_CRYPTO_CIPHER_AES_CTR,
1238                 RTE_CRYPTO_CIPHER_ZUC_EEA3,
1239                 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
1240         };
1241         const enum rte_crypto_auth_algorithm auths[] = {
1242                 RTE_CRYPTO_AUTH_NULL,
1243                 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
1244                 RTE_CRYPTO_AUTH_AES_CMAC,
1245                 RTE_CRYPTO_AUTH_ZUC_EIA3
1246         };
1247
1248         rte_cryptodev_info_get(dev_id, &dev_info);
1249         feat_flags = dev_info.feature_flags;
1250
1251         if (!(feat_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1252                         (global_api_test_type == CRYPTODEV_RAW_API_TEST)) {
1253                 RTE_LOG(INFO, USER1, "Feature flag requirements for Mixed "
1254                                 "Cipher Hash testsuite not met\n");
1255                 return TEST_SKIPPED;
1256         }
1257
1258         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1259                         && check_auth_capabilities_supported(auths,
1260                         RTE_DIM(auths)) != 0) {
1261                 RTE_LOG(INFO, USER1, "Capability requirements for Mixed "
1262                                 "Cipher Hash testsuite not met\n");
1263                 return TEST_SKIPPED;
1264         }
1265
1266         return 0;
1267 }
1268
1269 static int
1270 esn_testsuite_setup(void)
1271 {
1272         struct crypto_testsuite_params *ts_params = &testsuite_params;
1273         uint8_t dev_id = ts_params->valid_devs[0];
1274         struct rte_cryptodev_info dev_info;
1275         const enum rte_crypto_cipher_algorithm ciphers[] = {
1276                 RTE_CRYPTO_CIPHER_AES_CBC
1277         };
1278         const enum rte_crypto_auth_algorithm auths[] = {
1279                 RTE_CRYPTO_AUTH_SHA1_HMAC
1280         };
1281
1282         rte_cryptodev_info_get(dev_id, &dev_info);
1283
1284         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1285                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1286                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1287                 RTE_LOG(INFO, USER1, "Feature flag requirements for ESN "
1288                                 "testsuite not met\n");
1289                 return TEST_SKIPPED;
1290         }
1291
1292         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1293                         && check_auth_capabilities_supported(auths,
1294                         RTE_DIM(auths)) != 0) {
1295                 RTE_LOG(INFO, USER1, "Capability requirements for ESN "
1296                                 "testsuite not met\n");
1297                 return TEST_SKIPPED;
1298         }
1299
1300         return 0;
1301 }
1302
1303 static int
1304 multi_session_testsuite_setup(void)
1305 {
1306         struct crypto_testsuite_params *ts_params = &testsuite_params;
1307         uint8_t dev_id = ts_params->valid_devs[0];
1308         struct rte_cryptodev_info dev_info;
1309         const enum rte_crypto_cipher_algorithm ciphers[] = {
1310                 RTE_CRYPTO_CIPHER_AES_CBC
1311         };
1312         const enum rte_crypto_auth_algorithm auths[] = {
1313                 RTE_CRYPTO_AUTH_SHA512_HMAC
1314         };
1315
1316         rte_cryptodev_info_get(dev_id, &dev_info);
1317
1318         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1319                 RTE_LOG(INFO, USER1, "Feature flag requirements for Multi "
1320                                 "Session testsuite not met\n");
1321                 return TEST_SKIPPED;
1322         }
1323
1324         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1325                         && check_auth_capabilities_supported(auths,
1326                         RTE_DIM(auths)) != 0) {
1327                 RTE_LOG(INFO, USER1, "Capability requirements for Multi "
1328                                 "Session testsuite not met\n");
1329                 return TEST_SKIPPED;
1330         }
1331
1332         return 0;
1333 }
1334
1335 static int
1336 negative_hmac_sha1_testsuite_setup(void)
1337 {
1338         struct crypto_testsuite_params *ts_params = &testsuite_params;
1339         uint8_t dev_id = ts_params->valid_devs[0];
1340         struct rte_cryptodev_info dev_info;
1341         const enum rte_crypto_cipher_algorithm ciphers[] = {
1342                 RTE_CRYPTO_CIPHER_AES_CBC
1343         };
1344         const enum rte_crypto_auth_algorithm auths[] = {
1345                 RTE_CRYPTO_AUTH_SHA1_HMAC
1346         };
1347
1348         rte_cryptodev_info_get(dev_id, &dev_info);
1349
1350         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1351                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1352                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1353                 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1354                                 "HMAC SHA1 testsuite not met\n");
1355                 return TEST_SKIPPED;
1356         }
1357
1358         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1359                         && check_auth_capabilities_supported(auths,
1360                         RTE_DIM(auths)) != 0) {
1361                 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1362                                 "HMAC SHA1 testsuite not met\n");
1363                 return TEST_SKIPPED;
1364         }
1365
1366         return 0;
1367 }
1368
1369 static int
1370 dev_configure_and_start(uint64_t ff_disable)
1371 {
1372         struct crypto_testsuite_params *ts_params = &testsuite_params;
1373         struct crypto_unittest_params *ut_params = &unittest_params;
1374
1375         uint16_t qp_id;
1376
1377         /* Clear unit test parameters before running test */
1378         memset(ut_params, 0, sizeof(*ut_params));
1379
1380         /* Reconfigure device to default parameters */
1381         ts_params->conf.socket_id = SOCKET_ID_ANY;
1382         ts_params->conf.ff_disable = ff_disable;
1383         ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
1384         ts_params->qp_conf.mp_session = ts_params->session_mpool;
1385         ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
1386
1387         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1388                         &ts_params->conf),
1389                         "Failed to configure cryptodev %u",
1390                         ts_params->valid_devs[0]);
1391
1392         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
1393                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1394                         ts_params->valid_devs[0], qp_id,
1395                         &ts_params->qp_conf,
1396                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1397                         "Failed to setup queue pair %u on cryptodev %u",
1398                         qp_id, ts_params->valid_devs[0]);
1399         }
1400
1401
1402         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
1403
1404         /* Start the device */
1405         TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
1406                         "Failed to start cryptodev %u",
1407                         ts_params->valid_devs[0]);
1408
1409         return TEST_SUCCESS;
1410 }
1411
1412 int
1413 ut_setup(void)
1414 {
1415         /* Configure and start the device with security feature disabled */
1416         return dev_configure_and_start(RTE_CRYPTODEV_FF_SECURITY);
1417 }
1418
1419 static int
1420 ut_setup_security(void)
1421 {
1422         /* Configure and start the device with no features disabled */
1423         return dev_configure_and_start(0);
1424 }
1425
1426 void
1427 ut_teardown(void)
1428 {
1429         struct crypto_testsuite_params *ts_params = &testsuite_params;
1430         struct crypto_unittest_params *ut_params = &unittest_params;
1431
1432         /* free crypto session structure */
1433 #ifdef RTE_LIB_SECURITY
1434         if (ut_params->type == RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL) {
1435                 if (ut_params->sec_session) {
1436                         rte_security_session_destroy(rte_cryptodev_get_sec_ctx
1437                                                 (ts_params->valid_devs[0]),
1438                                                 ut_params->sec_session);
1439                         ut_params->sec_session = NULL;
1440                 }
1441         } else
1442 #endif
1443         {
1444                 if (ut_params->sess) {
1445                         rte_cryptodev_sym_session_clear(
1446                                         ts_params->valid_devs[0],
1447                                         ut_params->sess);
1448                         rte_cryptodev_sym_session_free(ut_params->sess);
1449                         ut_params->sess = NULL;
1450                 }
1451         }
1452
1453         /* free crypto operation structure */
1454         if (ut_params->op)
1455                 rte_crypto_op_free(ut_params->op);
1456
1457         /*
1458          * free mbuf - both obuf and ibuf are usually the same,
1459          * so check if they point at the same address is necessary,
1460          * to avoid freeing the mbuf twice.
1461          */
1462         if (ut_params->obuf) {
1463                 rte_pktmbuf_free(ut_params->obuf);
1464                 if (ut_params->ibuf == ut_params->obuf)
1465                         ut_params->ibuf = 0;
1466                 ut_params->obuf = 0;
1467         }
1468         if (ut_params->ibuf) {
1469                 rte_pktmbuf_free(ut_params->ibuf);
1470                 ut_params->ibuf = 0;
1471         }
1472
1473         if (ts_params->mbuf_pool != NULL)
1474                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
1475                         rte_mempool_avail_count(ts_params->mbuf_pool));
1476
1477         /* Stop the device */
1478         rte_cryptodev_stop(ts_params->valid_devs[0]);
1479 }
1480
1481 static int
1482 test_device_configure_invalid_dev_id(void)
1483 {
1484         struct crypto_testsuite_params *ts_params = &testsuite_params;
1485         uint16_t dev_id, num_devs = 0;
1486
1487         TEST_ASSERT((num_devs = rte_cryptodev_count()) >= 1,
1488                         "Need at least %d devices for test", 1);
1489
1490         /* valid dev_id values */
1491         dev_id = ts_params->valid_devs[0];
1492
1493         /* Stop the device in case it's started so it can be configured */
1494         rte_cryptodev_stop(dev_id);
1495
1496         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf),
1497                         "Failed test for rte_cryptodev_configure: "
1498                         "invalid dev_num %u", dev_id);
1499
1500         /* invalid dev_id values */
1501         dev_id = num_devs;
1502
1503         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
1504                         "Failed test for rte_cryptodev_configure: "
1505                         "invalid dev_num %u", dev_id);
1506
1507         dev_id = 0xff;
1508
1509         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
1510                         "Failed test for rte_cryptodev_configure:"
1511                         "invalid dev_num %u", dev_id);
1512
1513         return TEST_SUCCESS;
1514 }
1515
1516 static int
1517 test_device_configure_invalid_queue_pair_ids(void)
1518 {
1519         struct crypto_testsuite_params *ts_params = &testsuite_params;
1520         uint16_t orig_nb_qps = ts_params->conf.nb_queue_pairs;
1521
1522         /* Stop the device in case it's started so it can be configured */
1523         rte_cryptodev_stop(ts_params->valid_devs[0]);
1524
1525         /* valid - max value queue pairs */
1526         ts_params->conf.nb_queue_pairs = orig_nb_qps;
1527
1528         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1529                         &ts_params->conf),
1530                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
1531                         ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
1532
1533         /* valid - one queue pairs */
1534         ts_params->conf.nb_queue_pairs = 1;
1535
1536         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1537                         &ts_params->conf),
1538                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
1539                         ts_params->valid_devs[0],
1540                         ts_params->conf.nb_queue_pairs);
1541
1542
1543         /* invalid - zero queue pairs */
1544         ts_params->conf.nb_queue_pairs = 0;
1545
1546         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1547                         &ts_params->conf),
1548                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1549                         " invalid qps: %u",
1550                         ts_params->valid_devs[0],
1551                         ts_params->conf.nb_queue_pairs);
1552
1553
1554         /* invalid - max value supported by field queue pairs */
1555         ts_params->conf.nb_queue_pairs = UINT16_MAX;
1556
1557         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1558                         &ts_params->conf),
1559                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1560                         " invalid qps: %u",
1561                         ts_params->valid_devs[0],
1562                         ts_params->conf.nb_queue_pairs);
1563
1564
1565         /* invalid - max value + 1 queue pairs */
1566         ts_params->conf.nb_queue_pairs = orig_nb_qps + 1;
1567
1568         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1569                         &ts_params->conf),
1570                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1571                         " invalid qps: %u",
1572                         ts_params->valid_devs[0],
1573                         ts_params->conf.nb_queue_pairs);
1574
1575         /* revert to original testsuite value */
1576         ts_params->conf.nb_queue_pairs = orig_nb_qps;
1577
1578         return TEST_SUCCESS;
1579 }
1580
1581 static int
1582 test_queue_pair_descriptor_setup(void)
1583 {
1584         struct crypto_testsuite_params *ts_params = &testsuite_params;
1585         struct rte_cryptodev_qp_conf qp_conf = {
1586                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
1587         };
1588         uint16_t qp_id;
1589
1590         /* Stop the device in case it's started so it can be configured */
1591         rte_cryptodev_stop(ts_params->valid_devs[0]);
1592
1593         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1594                         &ts_params->conf),
1595                         "Failed to configure cryptodev %u",
1596                         ts_params->valid_devs[0]);
1597
1598         /*
1599          * Test various ring sizes on this device. memzones can't be
1600          * freed so are re-used if ring is released and re-created.
1601          */
1602         qp_conf.nb_descriptors = MIN_NUM_OPS_INFLIGHT; /* min size*/
1603         qp_conf.mp_session = ts_params->session_mpool;
1604         qp_conf.mp_session_private = ts_params->session_priv_mpool;
1605
1606         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1607                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1608                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1609                                 rte_cryptodev_socket_id(
1610                                                 ts_params->valid_devs[0])),
1611                                 "Failed test for "
1612                                 "rte_cryptodev_queue_pair_setup: num_inflights "
1613                                 "%u on qp %u on cryptodev %u",
1614                                 qp_conf.nb_descriptors, qp_id,
1615                                 ts_params->valid_devs[0]);
1616         }
1617
1618         qp_conf.nb_descriptors = (uint32_t)(MAX_NUM_OPS_INFLIGHT / 2);
1619
1620         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1621                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1622                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1623                                 rte_cryptodev_socket_id(
1624                                                 ts_params->valid_devs[0])),
1625                                 "Failed test for"
1626                                 " rte_cryptodev_queue_pair_setup: num_inflights"
1627                                 " %u on qp %u on cryptodev %u",
1628                                 qp_conf.nb_descriptors, qp_id,
1629                                 ts_params->valid_devs[0]);
1630         }
1631
1632         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; /* valid */
1633
1634         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1635                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1636                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1637                                 rte_cryptodev_socket_id(
1638                                                 ts_params->valid_devs[0])),
1639                                 "Failed test for "
1640                                 "rte_cryptodev_queue_pair_setup: num_inflights"
1641                                 " %u on qp %u on cryptodev %u",
1642                                 qp_conf.nb_descriptors, qp_id,
1643                                 ts_params->valid_devs[0]);
1644         }
1645
1646         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
1647
1648         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1649                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1650                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1651                                 rte_cryptodev_socket_id(
1652                                                 ts_params->valid_devs[0])),
1653                                 "Failed test for"
1654                                 " rte_cryptodev_queue_pair_setup:"
1655                                 "num_inflights %u on qp %u on cryptodev %u",
1656                                 qp_conf.nb_descriptors, qp_id,
1657                                 ts_params->valid_devs[0]);
1658         }
1659
1660         /* test invalid queue pair id */
1661         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;      /*valid */
1662
1663         qp_id = ts_params->conf.nb_queue_pairs;         /*invalid */
1664
1665         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
1666                         ts_params->valid_devs[0],
1667                         qp_id, &qp_conf,
1668                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1669                         "Failed test for rte_cryptodev_queue_pair_setup:"
1670                         "invalid qp %u on cryptodev %u",
1671                         qp_id, ts_params->valid_devs[0]);
1672
1673         qp_id = 0xffff; /*invalid*/
1674
1675         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
1676                         ts_params->valid_devs[0],
1677                         qp_id, &qp_conf,
1678                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1679                         "Failed test for rte_cryptodev_queue_pair_setup:"
1680                         "invalid qp %u on cryptodev %u",
1681                         qp_id, ts_params->valid_devs[0]);
1682
1683         return TEST_SUCCESS;
1684 }
1685
1686 /* ***** Plaintext data for tests ***** */
1687
1688 const char catch_22_quote_1[] =
1689                 "There was only one catch and that was Catch-22, which "
1690                 "specified that a concern for one's safety in the face of "
1691                 "dangers that were real and immediate was the process of a "
1692                 "rational mind. Orr was crazy and could be grounded. All he "
1693                 "had to do was ask; and as soon as he did, he would no longer "
1694                 "be crazy and would have to fly more missions. Orr would be "
1695                 "crazy to fly more missions and sane if he didn't, but if he "
1696                 "was sane he had to fly them. If he flew them he was crazy "
1697                 "and didn't have to; but if he didn't want to he was sane and "
1698                 "had to. Yossarian was moved very deeply by the absolute "
1699                 "simplicity of this clause of Catch-22 and let out a "
1700                 "respectful whistle. \"That's some catch, that Catch-22\", he "
1701                 "observed. \"It's the best there is,\" Doc Daneeka agreed.";
1702
1703 const char catch_22_quote[] =
1704                 "What a lousy earth! He wondered how many people were "
1705                 "destitute that same night even in his own prosperous country, "
1706                 "how many homes were shanties, how many husbands were drunk "
1707                 "and wives socked, and how many children were bullied, abused, "
1708                 "or abandoned. How many families hungered for food they could "
1709                 "not afford to buy? How many hearts were broken? How many "
1710                 "suicides would take place that same night, how many people "
1711                 "would go insane? How many cockroaches and landlords would "
1712                 "triumph? How many winners were losers, successes failures, "
1713                 "and rich men poor men? How many wise guys were stupid? How "
1714                 "many happy endings were unhappy endings? How many honest men "
1715                 "were liars, brave men cowards, loyal men traitors, how many "
1716                 "sainted men were corrupt, how many people in positions of "
1717                 "trust had sold their souls to bodyguards, how many had never "
1718                 "had souls? How many straight-and-narrow paths were crooked "
1719                 "paths? How many best families were worst families and how "
1720                 "many good people were bad people? When you added them all up "
1721                 "and then subtracted, you might be left with only the children, "
1722                 "and perhaps with Albert Einstein and an old violinist or "
1723                 "sculptor somewhere.";
1724
1725 #define QUOTE_480_BYTES         (480)
1726 #define QUOTE_512_BYTES         (512)
1727 #define QUOTE_768_BYTES         (768)
1728 #define QUOTE_1024_BYTES        (1024)
1729
1730
1731
1732 /* ***** SHA1 Hash Tests ***** */
1733
1734 #define HMAC_KEY_LENGTH_SHA1    (DIGEST_BYTE_LENGTH_SHA1)
1735
1736 static uint8_t hmac_sha1_key[] = {
1737         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
1738         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
1739         0xDE, 0xF4, 0xDE, 0xAD };
1740
1741 /* ***** SHA224 Hash Tests ***** */
1742
1743 #define HMAC_KEY_LENGTH_SHA224  (DIGEST_BYTE_LENGTH_SHA224)
1744
1745
1746 /* ***** AES-CBC Cipher Tests ***** */
1747
1748 #define CIPHER_KEY_LENGTH_AES_CBC       (16)
1749 #define CIPHER_IV_LENGTH_AES_CBC        (CIPHER_KEY_LENGTH_AES_CBC)
1750
1751 static uint8_t aes_cbc_key[] = {
1752         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
1753         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A };
1754
1755 static uint8_t aes_cbc_iv[] = {
1756         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1757         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
1758
1759
1760 /* ***** AES-CBC / HMAC-SHA1 Hash Tests ***** */
1761
1762 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_ciphertext[] = {
1763         0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31,
1764         0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76,
1765         0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E,
1766         0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A,
1767         0x3F, 0x6B, 0x5D, 0xDF, 0x52, 0x85, 0x5F, 0x8E,
1768         0x42, 0x3C, 0xFB, 0xE9, 0x1A, 0x24, 0xD6, 0x08,
1769         0xDD, 0xFD, 0x16, 0xFB, 0xE9, 0x55, 0xEF, 0xF0,
1770         0xA0, 0x8D, 0x13, 0xAB, 0x81, 0xC6, 0x90, 0x01,
1771         0xB5, 0x18, 0x84, 0xB3, 0xF6, 0xE6, 0x11, 0x57,
1772         0xD6, 0x71, 0xC6, 0x3C, 0x3F, 0x2F, 0x33, 0xEE,
1773         0x24, 0x42, 0x6E, 0xAC, 0x0B, 0xCA, 0xEC, 0xF9,
1774         0x84, 0xF8, 0x22, 0xAA, 0x60, 0xF0, 0x32, 0xA9,
1775         0x75, 0x75, 0x3B, 0xCB, 0x70, 0x21, 0x0A, 0x8D,
1776         0x0F, 0xE0, 0xC4, 0x78, 0x2B, 0xF8, 0x97, 0xE3,
1777         0xE4, 0x26, 0x4B, 0x29, 0xDA, 0x88, 0xCD, 0x46,
1778         0xEC, 0xAA, 0xF9, 0x7F, 0xF1, 0x15, 0xEA, 0xC3,
1779         0x87, 0xE6, 0x31, 0xF2, 0xCF, 0xDE, 0x4D, 0x80,
1780         0x70, 0x91, 0x7E, 0x0C, 0xF7, 0x26, 0x3A, 0x92,
1781         0x4F, 0x18, 0x83, 0xC0, 0x8F, 0x59, 0x01, 0xA5,
1782         0x88, 0xD1, 0xDB, 0x26, 0x71, 0x27, 0x16, 0xF5,
1783         0xEE, 0x10, 0x82, 0xAC, 0x68, 0x26, 0x9B, 0xE2,
1784         0x6D, 0xD8, 0x9A, 0x80, 0xDF, 0x04, 0x31, 0xD5,
1785         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1786         0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
1787         0x73, 0x02, 0x42, 0xC9, 0x23, 0x18, 0x8E, 0xB4,
1788         0x6F, 0xB4, 0xA3, 0x54, 0x6E, 0x88, 0x3B, 0x62,
1789         0x7C, 0x02, 0x8D, 0x4C, 0x9F, 0xC8, 0x45, 0xF4,
1790         0xC9, 0xDE, 0x4F, 0xEB, 0x22, 0x83, 0x1B, 0xE4,
1791         0x49, 0x37, 0xE4, 0xAD, 0xE7, 0xCD, 0x21, 0x54,
1792         0xBC, 0x1C, 0xC2, 0x04, 0x97, 0xB4, 0x10, 0x61,
1793         0xF0, 0xE4, 0xEF, 0x27, 0x63, 0x3A, 0xDA, 0x91,
1794         0x41, 0x25, 0x62, 0x1C, 0x5C, 0xB6, 0x38, 0x4A,
1795         0x88, 0x71, 0x59, 0x5A, 0x8D, 0xA0, 0x09, 0xAF,
1796         0x72, 0x94, 0xD7, 0x79, 0x5C, 0x60, 0x7C, 0x8F,
1797         0x4C, 0xF5, 0xD9, 0xA1, 0x39, 0x6D, 0x81, 0x28,
1798         0xEF, 0x13, 0x28, 0xDF, 0xF5, 0x3E, 0xF7, 0x8E,
1799         0x09, 0x9C, 0x78, 0x18, 0x79, 0xB8, 0x68, 0xD7,
1800         0xA8, 0x29, 0x62, 0xAD, 0xDE, 0xE1, 0x61, 0x76,
1801         0x1B, 0x05, 0x16, 0xCD, 0xBF, 0x02, 0x8E, 0xA6,
1802         0x43, 0x6E, 0x92, 0x55, 0x4F, 0x60, 0x9C, 0x03,
1803         0xB8, 0x4F, 0xA3, 0x02, 0xAC, 0xA8, 0xA7, 0x0C,
1804         0x1E, 0xB5, 0x6B, 0xF8, 0xC8, 0x4D, 0xDE, 0xD2,
1805         0xB0, 0x29, 0x6E, 0x40, 0xE6, 0xD6, 0xC9, 0xE6,
1806         0xB9, 0x0F, 0xB6, 0x63, 0xF5, 0xAA, 0x2B, 0x96,
1807         0xA7, 0x16, 0xAC, 0x4E, 0x0A, 0x33, 0x1C, 0xA6,
1808         0xE6, 0xBD, 0x8A, 0xCF, 0x40, 0xA9, 0xB2, 0xFA,
1809         0x63, 0x27, 0xFD, 0x9B, 0xD9, 0xFC, 0xD5, 0x87,
1810         0x8D, 0x4C, 0xB6, 0xA4, 0xCB, 0xE7, 0x74, 0x55,
1811         0xF4, 0xFB, 0x41, 0x25, 0xB5, 0x4B, 0x0A, 0x1B,
1812         0xB1, 0xD6, 0xB7, 0xD9, 0x47, 0x2A, 0xC3, 0x98,
1813         0x6A, 0xC4, 0x03, 0x73, 0x1F, 0x93, 0x6E, 0x53,
1814         0x19, 0x25, 0x64, 0x15, 0x83, 0xF9, 0x73, 0x2A,
1815         0x74, 0xB4, 0x93, 0x69, 0xC4, 0x72, 0xFC, 0x26,
1816         0xA2, 0x9F, 0x43, 0x45, 0xDD, 0xB9, 0xEF, 0x36,
1817         0xC8, 0x3A, 0xCD, 0x99, 0x9B, 0x54, 0x1A, 0x36,
1818         0xC1, 0x59, 0xF8, 0x98, 0xA8, 0xCC, 0x28, 0x0D,
1819         0x73, 0x4C, 0xEE, 0x98, 0xCB, 0x7C, 0x58, 0x7E,
1820         0x20, 0x75, 0x1E, 0xB7, 0xC9, 0xF8, 0xF2, 0x0E,
1821         0x63, 0x9E, 0x05, 0x78, 0x1A, 0xB6, 0xA8, 0x7A,
1822         0xF9, 0x98, 0x6A, 0xA6, 0x46, 0x84, 0x2E, 0xF6,
1823         0x4B, 0xDC, 0x9B, 0x8F, 0x9B, 0x8F, 0xEE, 0xB4,
1824         0xAA, 0x3F, 0xEE, 0xC0, 0x37, 0x27, 0x76, 0xC7,
1825         0x95, 0xBB, 0x26, 0x74, 0x69, 0x12, 0x7F, 0xF1,
1826         0xBB, 0xFF, 0xAE, 0xB5, 0x99, 0x6E, 0xCB, 0x0C
1827 };
1828
1829 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest[] = {
1830         0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60,
1831         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1832         0x18, 0x8c, 0x1d, 0x32
1833 };
1834
1835
1836 /* Multisession Vector context Test */
1837 /*Begin Session 0 */
1838 static uint8_t ms_aes_cbc_key0[] = {
1839         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1840         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1841 };
1842
1843 static uint8_t ms_aes_cbc_iv0[] = {
1844         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1845         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1846 };
1847
1848 static const uint8_t ms_aes_cbc_cipher0[] = {
1849                 0x3C, 0xE4, 0xEE, 0x42, 0xB6, 0x9B, 0xC3, 0x38,
1850                 0x5F, 0xAD, 0x54, 0xDC, 0xA8, 0x32, 0x81, 0xDC,
1851                 0x7A, 0x6F, 0x85, 0x58, 0x07, 0x35, 0xED, 0xEB,
1852                 0xAD, 0x79, 0x79, 0x96, 0xD3, 0x0E, 0xA6, 0xD9,
1853                 0xAA, 0x86, 0xA4, 0x8F, 0xB5, 0xD6, 0x6E, 0x6D,
1854                 0x0C, 0x91, 0x2F, 0xC4, 0x67, 0x98, 0x0E, 0xC4,
1855                 0x8D, 0x83, 0x68, 0x69, 0xC4, 0xD3, 0x94, 0x34,
1856                 0xC4, 0x5D, 0x60, 0x55, 0x22, 0x87, 0x8F, 0x6F,
1857                 0x17, 0x8E, 0x75, 0xE4, 0x02, 0xF5, 0x1B, 0x99,
1858                 0xC8, 0x39, 0xA9, 0xAB, 0x23, 0x91, 0x12, 0xED,
1859                 0x08, 0xE7, 0xD9, 0x25, 0x89, 0x24, 0x4F, 0x8D,
1860                 0x68, 0xF3, 0x10, 0x39, 0x0A, 0xEE, 0x45, 0x24,
1861                 0xDF, 0x7A, 0x9D, 0x00, 0x25, 0xE5, 0x35, 0x71,
1862                 0x4E, 0x40, 0x59, 0x6F, 0x0A, 0x13, 0xB3, 0x72,
1863                 0x1D, 0x98, 0x63, 0x94, 0x89, 0xA5, 0x39, 0x8E,
1864                 0xD3, 0x9C, 0x8A, 0x7F, 0x71, 0x2F, 0xC7, 0xCD,
1865                 0x81, 0x05, 0xDC, 0xC0, 0x8D, 0xCE, 0x6D, 0x18,
1866                 0x30, 0xC4, 0x72, 0x51, 0xF0, 0x27, 0xC8, 0xF6,
1867                 0x60, 0x5B, 0x7C, 0xB2, 0xE3, 0x49, 0x0C, 0x29,
1868                 0xC6, 0x9F, 0x39, 0x57, 0x80, 0x55, 0x24, 0x2C,
1869                 0x9B, 0x0F, 0x5A, 0xB3, 0x89, 0x55, 0x31, 0x96,
1870                 0x0D, 0xCD, 0xF6, 0x51, 0x03, 0x2D, 0x89, 0x26,
1871                 0x74, 0x44, 0xD6, 0xE8, 0xDC, 0xEA, 0x44, 0x55,
1872                 0x64, 0x71, 0x9C, 0x9F, 0x5D, 0xBA, 0x39, 0x46,
1873                 0xA8, 0x17, 0xA1, 0x9C, 0x52, 0x9D, 0xBC, 0x6B,
1874                 0x4A, 0x98, 0xE6, 0xEA, 0x33, 0xEC, 0x58, 0xB4,
1875                 0x43, 0xF0, 0x32, 0x45, 0xA4, 0xC1, 0x55, 0xB7,
1876                 0x5D, 0xB5, 0x59, 0xB2, 0xE3, 0x96, 0xFF, 0xA5,
1877                 0xAF, 0xE1, 0x86, 0x1B, 0x42, 0xE6, 0x3B, 0xA0,
1878                 0x90, 0x4A, 0xE8, 0x8C, 0x21, 0x7F, 0x36, 0x1E,
1879                 0x5B, 0x65, 0x25, 0xD1, 0xC1, 0x5A, 0xCA, 0x3D,
1880                 0x10, 0xED, 0x2D, 0x79, 0xD0, 0x0F, 0x58, 0x44,
1881                 0x69, 0x81, 0xF5, 0xD4, 0xC9, 0x0F, 0x90, 0x76,
1882                 0x1F, 0x54, 0xD2, 0xD5, 0x97, 0xCE, 0x2C, 0xE3,
1883                 0xEF, 0xF4, 0xB7, 0xC6, 0x3A, 0x87, 0x7F, 0x83,
1884                 0x2A, 0xAF, 0xCD, 0x90, 0x12, 0xA7, 0x7D, 0x85,
1885                 0x1D, 0x62, 0xD3, 0x85, 0x25, 0x05, 0xDB, 0x45,
1886                 0x92, 0xA3, 0xF6, 0xA2, 0xA8, 0x41, 0xE4, 0x25,
1887                 0x86, 0x87, 0x67, 0x24, 0xEC, 0x89, 0x23, 0x2A,
1888                 0x9B, 0x20, 0x4D, 0x93, 0xEE, 0xE2, 0x2E, 0xC1,
1889                 0x0B, 0x15, 0x33, 0xCF, 0x00, 0xD1, 0x1A, 0xDA,
1890                 0x93, 0xFD, 0x28, 0x21, 0x5B, 0xCF, 0xD1, 0xF3,
1891                 0x5A, 0x81, 0xBA, 0x82, 0x5E, 0x2F, 0x61, 0xB4,
1892                 0x05, 0x71, 0xB5, 0xF4, 0x39, 0x3C, 0x1F, 0x60,
1893                 0x00, 0x7A, 0xC4, 0xF8, 0x35, 0x20, 0x6C, 0x3A,
1894                 0xCC, 0x03, 0x8F, 0x7B, 0xA2, 0xB6, 0x65, 0x8A,
1895                 0xB6, 0x5F, 0xFD, 0x25, 0xD3, 0x5F, 0x92, 0xF9,
1896                 0xAE, 0x17, 0x9B, 0x5E, 0x6E, 0x9A, 0xE4, 0x55,
1897                 0x10, 0x25, 0x07, 0xA4, 0xAF, 0x21, 0x69, 0x13,
1898                 0xD8, 0xFA, 0x31, 0xED, 0xF7, 0xA7, 0xA7, 0x3B,
1899                 0xB8, 0x96, 0x8E, 0x10, 0x86, 0x74, 0xD8, 0xB1,
1900                 0x34, 0x9E, 0x9B, 0x6A, 0x26, 0xA8, 0xD4, 0xD0,
1901                 0xB5, 0xF6, 0xDE, 0xE7, 0xCA, 0x06, 0xDC, 0xA3,
1902                 0x6F, 0xEE, 0x6B, 0x1E, 0xB5, 0x30, 0x99, 0x23,
1903                 0xF9, 0x76, 0xF0, 0xA0, 0xCF, 0x3B, 0x94, 0x7B,
1904                 0x19, 0x8D, 0xA5, 0x0C, 0x18, 0xA6, 0x1D, 0x07,
1905                 0x89, 0xBE, 0x5B, 0x61, 0xE5, 0xF1, 0x42, 0xDB,
1906                 0xD4, 0x2E, 0x02, 0x1F, 0xCE, 0xEF, 0x92, 0xB1,
1907                 0x1B, 0x56, 0x50, 0xF2, 0x16, 0xE5, 0xE7, 0x4F,
1908                 0xFD, 0xBB, 0x3E, 0xD2, 0xFC, 0x3C, 0xC6, 0x0F,
1909                 0xF9, 0x12, 0x4E, 0xCB, 0x1E, 0x0C, 0x15, 0x84,
1910                 0x2A, 0x14, 0x8A, 0x02, 0xE4, 0x7E, 0x95, 0x5B,
1911                 0x86, 0xDB, 0x9B, 0x62, 0x5B, 0x19, 0xD2, 0x17,
1912                 0xFA, 0x13, 0xBB, 0x6B, 0x3F, 0x45, 0x9F, 0xBF
1913 };
1914
1915
1916 static  uint8_t ms_hmac_key0[] = {
1917                 0xFF, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1918                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1919                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1920                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1921                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1922                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1923                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1924                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1925 };
1926
1927 static const uint8_t ms_hmac_digest0[] = {
1928                 0x43, 0x52, 0xED, 0x34, 0xAB, 0x36, 0xB2, 0x51,
1929                 0xFB, 0xA3, 0xA6, 0x7C, 0x38, 0xFC, 0x42, 0x8F,
1930                 0x57, 0x64, 0xAB, 0x81, 0xA7, 0x89, 0xB7, 0x6C,
1931                 0xA0, 0xDC, 0xB9, 0x4D, 0xC4, 0x30, 0xF9, 0xD4,
1932                 0x10, 0x82, 0x55, 0xD0, 0xAB, 0x32, 0xFB, 0x56,
1933                 0x0D, 0xE4, 0x68, 0x3D, 0x76, 0xD0, 0x7B, 0xE4,
1934                 0xA6, 0x2C, 0x34, 0x9E, 0x8C, 0x41, 0xF8, 0x23,
1935                 0x28, 0x1B, 0x3A, 0x90, 0x26, 0x34, 0x47, 0x90
1936                 };
1937
1938 /* End Session 0 */
1939 /* Begin session 1 */
1940
1941 static  uint8_t ms_aes_cbc_key1[] = {
1942                 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1943                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1944 };
1945
1946 static  uint8_t ms_aes_cbc_iv1[] = {
1947         0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1948         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1949 };
1950
1951 static const uint8_t ms_aes_cbc_cipher1[] = {
1952                 0x5A, 0x7A, 0x67, 0x5D, 0xB8, 0xE1, 0xDC, 0x71,
1953                 0x39, 0xA8, 0x74, 0x93, 0x9C, 0x4C, 0xFE, 0x23,
1954                 0x61, 0xCD, 0xA4, 0xB3, 0xD9, 0xCE, 0x99, 0x09,
1955                 0x2A, 0x23, 0xF3, 0x29, 0xBF, 0x4C, 0xB4, 0x6A,
1956                 0x1B, 0x6B, 0x73, 0x4D, 0x48, 0x0C, 0xCF, 0x6C,
1957                 0x5E, 0x34, 0x9E, 0x7F, 0xBC, 0x8F, 0xCC, 0x8F,
1958                 0x75, 0x1D, 0x3D, 0x77, 0x10, 0x76, 0xC8, 0xB9,
1959                 0x99, 0x6F, 0xD6, 0x56, 0x75, 0xA9, 0xB2, 0x66,
1960                 0xC2, 0x24, 0x2B, 0x9C, 0xFE, 0x40, 0x8E, 0x43,
1961                 0x20, 0x97, 0x1B, 0xFA, 0xD0, 0xCF, 0x04, 0xAB,
1962                 0xBB, 0xF6, 0x5D, 0xF5, 0xA0, 0x19, 0x7C, 0x23,
1963                 0x5D, 0x80, 0x8C, 0x49, 0xF6, 0x76, 0x88, 0x29,
1964                 0x27, 0x4C, 0x59, 0x2B, 0x43, 0xA6, 0xB2, 0x26,
1965                 0x27, 0x78, 0xBE, 0x1B, 0xE1, 0x4F, 0x5A, 0x1F,
1966                 0xFC, 0x68, 0x08, 0xE7, 0xC4, 0xD1, 0x34, 0x68,
1967                 0xB7, 0x13, 0x14, 0x41, 0x62, 0x6B, 0x1F, 0x77,
1968                 0x0C, 0x68, 0x1D, 0x0D, 0xED, 0x89, 0xAA, 0xD8,
1969                 0x97, 0x02, 0xBA, 0x5E, 0xD4, 0x84, 0x25, 0x97,
1970                 0x03, 0xA5, 0xA6, 0x13, 0x66, 0x02, 0xF4, 0xC3,
1971                 0xF3, 0xD3, 0xCC, 0x95, 0xC3, 0x87, 0x46, 0x90,
1972                 0x1F, 0x6E, 0x14, 0xA8, 0x00, 0xF2, 0x6F, 0xD5,
1973                 0xA1, 0xAD, 0xD5, 0x40, 0xA2, 0x0F, 0x32, 0x7E,
1974                 0x99, 0xA3, 0xF5, 0x53, 0xC3, 0x26, 0xA1, 0x45,
1975                 0x01, 0x88, 0x57, 0x84, 0x3E, 0x7B, 0x4E, 0x0B,
1976                 0x3C, 0xB5, 0x3E, 0x9E, 0xE9, 0x78, 0x77, 0xC5,
1977                 0xC0, 0x89, 0xA8, 0xF8, 0xF1, 0xA5, 0x2D, 0x5D,
1978                 0xF9, 0xC6, 0xFB, 0xCB, 0x05, 0x23, 0xBD, 0x6E,
1979                 0x5E, 0x14, 0xC6, 0x57, 0x73, 0xCF, 0x98, 0xBD,
1980                 0x10, 0x8B, 0x18, 0xA6, 0x01, 0x5B, 0x13, 0xAE,
1981                 0x8E, 0xDE, 0x1F, 0xB5, 0xB7, 0x40, 0x6C, 0xC1,
1982                 0x1E, 0xA1, 0x19, 0x20, 0x9E, 0x95, 0xE0, 0x2F,
1983                 0x1C, 0xF5, 0xD9, 0xD0, 0x2B, 0x1E, 0x82, 0x25,
1984                 0x62, 0xB4, 0xEB, 0xA1, 0x1F, 0xCE, 0x44, 0xA1,
1985                 0xCB, 0x92, 0x01, 0x6B, 0xE4, 0x26, 0x23, 0xE3,
1986                 0xC5, 0x67, 0x35, 0x55, 0xDA, 0xE5, 0x27, 0xEE,
1987                 0x8D, 0x12, 0x84, 0xB7, 0xBA, 0xA7, 0x1C, 0xD6,
1988                 0x32, 0x3F, 0x67, 0xED, 0xFB, 0x5B, 0x8B, 0x52,
1989                 0x46, 0x8C, 0xF9, 0x69, 0xCD, 0xAE, 0x79, 0xAA,
1990                 0x37, 0x78, 0x49, 0xEB, 0xC6, 0x8E, 0x76, 0x63,
1991                 0x84, 0xFF, 0x9D, 0x22, 0x99, 0x51, 0xB7, 0x5E,
1992                 0x83, 0x4C, 0x8B, 0xDF, 0x5A, 0x07, 0xCC, 0xBA,
1993                 0x42, 0xA5, 0x98, 0xB6, 0x47, 0x0E, 0x66, 0xEB,
1994                 0x23, 0x0E, 0xBA, 0x44, 0xA8, 0xAA, 0x20, 0x71,
1995                 0x79, 0x9C, 0x77, 0x5F, 0xF5, 0xFE, 0xEC, 0xEF,
1996                 0xC6, 0x64, 0x3D, 0x84, 0xD0, 0x2B, 0xA7, 0x0A,
1997                 0xC3, 0x72, 0x5B, 0x9C, 0xFA, 0xA8, 0x87, 0x95,
1998                 0x94, 0x11, 0x38, 0xA7, 0x1E, 0x58, 0xE3, 0x73,
1999                 0xC6, 0xC9, 0xD1, 0x7B, 0x92, 0xDB, 0x0F, 0x49,
2000                 0x74, 0xC2, 0xA2, 0x0E, 0x35, 0x57, 0xAC, 0xDB,
2001                 0x9A, 0x1C, 0xCF, 0x5A, 0x32, 0x3E, 0x26, 0x9B,
2002                 0xEC, 0xB3, 0xEF, 0x9C, 0xFE, 0xBE, 0x52, 0xAC,
2003                 0xB1, 0x29, 0xDD, 0xFD, 0x07, 0xE2, 0xEE, 0xED,
2004                 0xE4, 0x46, 0x37, 0xFE, 0xD1, 0xDC, 0xCD, 0x02,
2005                 0xF9, 0x31, 0xB0, 0xFB, 0x36, 0xB7, 0x34, 0xA4,
2006                 0x76, 0xE8, 0x57, 0xBF, 0x99, 0x92, 0xC7, 0xAF,
2007                 0x98, 0x10, 0xE2, 0x70, 0xCA, 0xC9, 0x2B, 0x82,
2008                 0x06, 0x96, 0x88, 0x0D, 0xB3, 0xAC, 0x9E, 0x6D,
2009                 0x43, 0xBC, 0x5B, 0x31, 0xCF, 0x65, 0x8D, 0xA6,
2010                 0xC7, 0xFE, 0x73, 0xE1, 0x54, 0xF7, 0x10, 0xF9,
2011                 0x86, 0xF7, 0xDF, 0xA1, 0xA1, 0xD8, 0xAE, 0x35,
2012                 0xB3, 0x90, 0xDC, 0x6F, 0x43, 0x7A, 0x8B, 0xE0,
2013                 0xFE, 0x8F, 0x33, 0x4D, 0x29, 0x6C, 0x45, 0x53,
2014                 0x73, 0xDD, 0x21, 0x0B, 0x85, 0x30, 0xB5, 0xA5,
2015                 0xF3, 0x5D, 0xEC, 0x79, 0x61, 0x9D, 0x9E, 0xB3
2016
2017 };
2018
2019 static uint8_t ms_hmac_key1[] = {
2020                 0xFE, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
2021                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
2022                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
2023                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
2024                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
2025                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
2026                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
2027                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
2028 };
2029
2030 static const uint8_t ms_hmac_digest1[] = {
2031                 0xCE, 0x6E, 0x5F, 0x77, 0x96, 0x9A, 0xB1, 0x69,
2032                 0x2D, 0x5E, 0xF3, 0x2F, 0x32, 0x10, 0xCB, 0x50,
2033                 0x0E, 0x09, 0x56, 0x25, 0x07, 0x34, 0xC9, 0x20,
2034                 0xEC, 0x13, 0x43, 0x23, 0x5C, 0x08, 0x8B, 0xCD,
2035                 0xDC, 0x86, 0x8C, 0xEE, 0x0A, 0x95, 0x2E, 0xB9,
2036                 0x8C, 0x7B, 0x02, 0x7A, 0xD4, 0xE1, 0x49, 0xB4,
2037                 0x45, 0xB5, 0x52, 0x37, 0xC6, 0xFF, 0xFE, 0xAA,
2038                 0x0A, 0x87, 0xB8, 0x51, 0xF9, 0x2A, 0x01, 0x8F
2039 };
2040 /* End Session 1  */
2041 /* Begin Session 2 */
2042 static  uint8_t ms_aes_cbc_key2[] = {
2043                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
2044                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
2045 };
2046
2047 static  uint8_t ms_aes_cbc_iv2[] = {
2048                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
2049                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
2050 };
2051
2052 static const uint8_t ms_aes_cbc_cipher2[] = {
2053                 0xBB, 0x3C, 0x68, 0x25, 0xFD, 0xB6, 0xA2, 0x91,
2054                 0x20, 0x56, 0xF6, 0x30, 0x35, 0xFC, 0x9E, 0x97,
2055                 0xF2, 0x90, 0xFC, 0x7E, 0x3E, 0x0A, 0x75, 0xC8,
2056                 0x4C, 0xF2, 0x2D, 0xAC, 0xD3, 0x93, 0xF0, 0xC5,
2057                 0x14, 0x88, 0x8A, 0x23, 0xC2, 0x59, 0x9A, 0x98,
2058                 0x4B, 0xD5, 0x2C, 0xDA, 0x43, 0xA9, 0x34, 0x69,
2059                 0x7C, 0x6D, 0xDB, 0xDC, 0xCB, 0xC0, 0xA0, 0x09,
2060                 0xA7, 0x86, 0x16, 0x4B, 0xBF, 0xA8, 0xB6, 0xCF,
2061                 0x7F, 0x74, 0x1F, 0x22, 0xF0, 0xF6, 0xBB, 0x44,
2062                 0x8B, 0x4C, 0x9E, 0x23, 0xF8, 0x9F, 0xFC, 0x5B,
2063                 0x9E, 0x9C, 0x2A, 0x79, 0x30, 0x8F, 0xBF, 0xA9,
2064                 0x68, 0xA1, 0x20, 0x71, 0x7C, 0x77, 0x22, 0x34,
2065                 0x07, 0xCD, 0xC6, 0xF6, 0x50, 0x0A, 0x08, 0x99,
2066                 0x17, 0x98, 0xE3, 0x93, 0x8A, 0xB0, 0xEE, 0xDF,
2067                 0xC2, 0xBA, 0x3B, 0x44, 0x73, 0xDF, 0xDD, 0xDC,
2068                 0x14, 0x4D, 0x3B, 0xBB, 0x5E, 0x58, 0xC1, 0x26,
2069                 0xA7, 0xAE, 0x47, 0xF3, 0x24, 0x6D, 0x4F, 0xD3,
2070                 0x6E, 0x3E, 0x33, 0xE6, 0x7F, 0xCA, 0x50, 0xAF,
2071                 0x5D, 0x3D, 0xA0, 0xDD, 0xC9, 0xF3, 0x30, 0xD3,
2072                 0x6E, 0x8B, 0x2E, 0x12, 0x24, 0x34, 0xF0, 0xD3,
2073                 0xC7, 0x8D, 0x23, 0x29, 0xAA, 0x05, 0xE1, 0xFA,
2074                 0x2E, 0xF6, 0x8D, 0x37, 0x86, 0xC0, 0x6D, 0x13,
2075                 0x2D, 0x98, 0xF3, 0x52, 0x39, 0x22, 0xCE, 0x38,
2076                 0xC2, 0x1A, 0x72, 0xED, 0xFB, 0xCC, 0xE4, 0x71,
2077                 0x5A, 0x0C, 0x0D, 0x09, 0xF8, 0xE8, 0x1B, 0xBC,
2078                 0x53, 0xC8, 0xD8, 0x8F, 0xE5, 0x98, 0x5A, 0xB1,
2079                 0x06, 0xA6, 0x5B, 0xE6, 0xA2, 0x88, 0x21, 0x9E,
2080                 0x36, 0xC0, 0x34, 0xF9, 0xFB, 0x3B, 0x0A, 0x22,
2081                 0x00, 0x00, 0x39, 0x48, 0x8D, 0x23, 0x74, 0x62,
2082                 0x72, 0x91, 0xE6, 0x36, 0xAA, 0x77, 0x9C, 0x72,
2083                 0x9D, 0xA8, 0xC3, 0xA9, 0xD5, 0x44, 0x72, 0xA6,
2084                 0xB9, 0x28, 0x8F, 0x64, 0x4C, 0x8A, 0x64, 0xE6,
2085                 0x4E, 0xFA, 0xEF, 0x87, 0xDE, 0x7B, 0x22, 0x44,
2086                 0xB0, 0xDF, 0x2E, 0x5F, 0x0B, 0xA5, 0xF2, 0x24,
2087                 0x07, 0x5C, 0x2D, 0x39, 0xB7, 0x3D, 0x8A, 0xE5,
2088                 0x0E, 0x9D, 0x4E, 0x50, 0xED, 0x03, 0x99, 0x8E,
2089                 0xF0, 0x06, 0x55, 0x4E, 0xA2, 0x24, 0xE7, 0x17,
2090                 0x46, 0xDF, 0x6C, 0xCD, 0xC6, 0x44, 0xE8, 0xF9,
2091                 0xB9, 0x1B, 0x36, 0xF6, 0x7F, 0x10, 0xA4, 0x7D,
2092                 0x90, 0xBD, 0xE4, 0xAA, 0xD6, 0x9E, 0x18, 0x9D,
2093                 0x22, 0x35, 0xD6, 0x55, 0x54, 0xAA, 0xF7, 0x22,
2094                 0xA3, 0x3E, 0xEF, 0xC8, 0xA2, 0x34, 0x8D, 0xA9,
2095                 0x37, 0x63, 0xA6, 0xC3, 0x57, 0xCB, 0x0C, 0x49,
2096                 0x7D, 0x02, 0xBE, 0xAA, 0x13, 0x75, 0xB7, 0x4E,
2097                 0x52, 0x62, 0xA5, 0xC2, 0x33, 0xC7, 0x6C, 0x1B,
2098                 0xF6, 0x34, 0xF6, 0x09, 0xA5, 0x0C, 0xC7, 0xA2,
2099                 0x61, 0x48, 0x62, 0x7D, 0x17, 0x15, 0xE3, 0x95,
2100                 0xC8, 0x63, 0xD2, 0xA4, 0x43, 0xA9, 0x49, 0x07,
2101                 0xB2, 0x3B, 0x2B, 0x62, 0x7D, 0xCB, 0x51, 0xB3,
2102                 0x25, 0x33, 0x47, 0x0E, 0x14, 0x67, 0xDC, 0x6A,
2103                 0x9B, 0x51, 0xAC, 0x9D, 0x8F, 0xA2, 0x2B, 0x57,
2104                 0x8C, 0x5C, 0x5F, 0x76, 0x23, 0x92, 0x0F, 0x84,
2105                 0x46, 0x0E, 0x40, 0x85, 0x38, 0x60, 0xFA, 0x61,
2106                 0x20, 0xC5, 0xE3, 0xF1, 0x70, 0xAC, 0x1B, 0xBF,
2107                 0xC4, 0x2B, 0xC5, 0x67, 0xD1, 0x43, 0xC5, 0x17,
2108                 0x74, 0x71, 0x69, 0x6F, 0x82, 0x89, 0x19, 0x8A,
2109                 0x70, 0x43, 0x92, 0x01, 0xC4, 0x63, 0x7E, 0xB1,
2110                 0x59, 0x4E, 0xCD, 0xEA, 0x93, 0xA4, 0x52, 0x53,
2111                 0x9B, 0x61, 0x5B, 0xD2, 0x3E, 0x19, 0x39, 0xB7,
2112                 0x32, 0xEA, 0x8E, 0xF8, 0x1D, 0x76, 0x5C, 0xB2,
2113                 0x73, 0x2D, 0x91, 0xC0, 0x18, 0xED, 0x25, 0x2A,
2114                 0x53, 0x64, 0xF0, 0x92, 0x31, 0x55, 0x21, 0xA8,
2115                 0x24, 0xA9, 0xD1, 0x02, 0xF6, 0x6C, 0x2B, 0x70,
2116                 0xA9, 0x59, 0xC1, 0xD6, 0xC3, 0x57, 0x5B, 0x92
2117 };
2118
2119 static  uint8_t ms_hmac_key2[] = {
2120                 0xFC, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
2121                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
2122                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
2123                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
2124                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
2125                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
2126                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
2127                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
2128 };
2129
2130 static const uint8_t ms_hmac_digest2[] = {
2131                 0xA5, 0x0F, 0x9C, 0xFB, 0x08, 0x62, 0x59, 0xFF,
2132                 0x80, 0x2F, 0xEB, 0x4B, 0xE1, 0x46, 0x21, 0xD6,
2133                 0x02, 0x98, 0xF2, 0x8E, 0xF4, 0xEC, 0xD4, 0x77,
2134                 0x86, 0x4C, 0x31, 0x28, 0xC8, 0x25, 0x80, 0x27,
2135                 0x3A, 0x72, 0x5D, 0x6A, 0x56, 0x8A, 0xD3, 0x82,
2136                 0xB0, 0xEC, 0x31, 0x6D, 0x8B, 0x6B, 0xB4, 0x24,
2137                 0xE7, 0x62, 0xC1, 0x52, 0xBC, 0x14, 0x1B, 0x8E,
2138                 0xEC, 0x9A, 0xF1, 0x47, 0x80, 0xD2, 0xB0, 0x59
2139 };
2140
2141 /* End Session 2 */
2142
2143
2144 static int
2145 test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
2146 {
2147         struct crypto_testsuite_params *ts_params = &testsuite_params;
2148         struct crypto_unittest_params *ut_params = &unittest_params;
2149         int status;
2150
2151         /* Verify the capabilities */
2152         struct rte_cryptodev_sym_capability_idx cap_idx;
2153         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2154         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
2155         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2156                         &cap_idx) == NULL)
2157                 return TEST_SKIPPED;
2158         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2159         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
2160         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2161                         &cap_idx) == NULL)
2162                 return TEST_SKIPPED;
2163
2164         /* Generate test mbuf data and space for digest */
2165         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
2166                         catch_22_quote, QUOTE_512_BYTES, 0);
2167
2168         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2169                         DIGEST_BYTE_LENGTH_SHA1);
2170         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
2171
2172         /* Setup Cipher Parameters */
2173         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2174         ut_params->cipher_xform.next = &ut_params->auth_xform;
2175
2176         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
2177         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2178         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
2179         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
2180         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2181         ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
2182
2183         /* Setup HMAC Parameters */
2184         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2185
2186         ut_params->auth_xform.next = NULL;
2187
2188         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2189         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
2190         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1;
2191         ut_params->auth_xform.auth.key.data = hmac_sha1_key;
2192         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
2193
2194         ut_params->sess = rte_cryptodev_sym_session_create(
2195                         ts_params->session_mpool);
2196         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2197
2198         /* Create crypto session*/
2199         status = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
2200                         ut_params->sess, &ut_params->cipher_xform,
2201                         ts_params->session_priv_mpool);
2202
2203         if (status == -ENOTSUP)
2204                 return TEST_SKIPPED;
2205
2206         TEST_ASSERT_EQUAL(status, 0, "Session init failed");
2207
2208         /* Generate crypto op data structure */
2209         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2210                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2211         TEST_ASSERT_NOT_NULL(ut_params->op,
2212                         "Failed to allocate symmetric crypto operation struct");
2213
2214         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2215
2216         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2217
2218         /* set crypto operation source mbuf */
2219         sym_op->m_src = ut_params->ibuf;
2220
2221         /* Set crypto operation authentication parameters */
2222         sym_op->auth.digest.data = ut_params->digest;
2223         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2224                         ut_params->ibuf, QUOTE_512_BYTES);
2225
2226         sym_op->auth.data.offset = 0;
2227         sym_op->auth.data.length = QUOTE_512_BYTES;
2228
2229         /* Copy IV at the end of the crypto operation */
2230         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2231                         aes_cbc_iv, CIPHER_IV_LENGTH_AES_CBC);
2232
2233         /* Set crypto operation cipher parameters */
2234         sym_op->cipher.data.offset = 0;
2235         sym_op->cipher.data.length = QUOTE_512_BYTES;
2236
2237         /* Process crypto operation */
2238         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2239                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
2240                         ut_params->op);
2241         else
2242                 TEST_ASSERT_NOT_NULL(
2243                         process_crypto_request(ts_params->valid_devs[0],
2244                                 ut_params->op),
2245                                 "failed to process sym crypto op");
2246
2247         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2248                         "crypto op processing failed");
2249
2250         /* Validate obuf */
2251         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
2252                         uint8_t *);
2253
2254         TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext,
2255                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
2256                         QUOTE_512_BYTES,
2257                         "ciphertext data not as expected");
2258
2259         uint8_t *digest = ciphertext + QUOTE_512_BYTES;
2260
2261         TEST_ASSERT_BUFFERS_ARE_EQUAL(digest,
2262                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
2263                         gbl_driver_id == rte_cryptodev_driver_id_get(
2264                                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) ?
2265                                         TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
2266                                         DIGEST_BYTE_LENGTH_SHA1,
2267                         "Generated digest data not as expected");
2268
2269         return TEST_SUCCESS;
2270 }
2271
2272 /* ***** AES-CBC / HMAC-SHA512 Hash Tests ***** */
2273
2274 #define HMAC_KEY_LENGTH_SHA512  (DIGEST_BYTE_LENGTH_SHA512)
2275
2276 static uint8_t hmac_sha512_key[] = {
2277         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
2278         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
2279         0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
2280         0x9a, 0xaf, 0x88, 0x1b, 0xb6, 0x8f, 0xf8, 0x60,
2281         0xa2, 0x5a, 0x7f, 0x3f, 0xf4, 0x72, 0x70, 0xf1,
2282         0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
2283         0x47, 0x3a, 0x75, 0x61, 0x5C, 0xa2, 0x10, 0x76,
2284         0x9a, 0xaf, 0x77, 0x5b, 0xb6, 0x7f, 0xf7, 0x60 };
2285
2286 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest[] = {
2287         0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8,
2288         0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48,
2289         0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8,
2290         0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70,
2291         0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8,
2292         0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E,
2293         0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D,
2294         0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A };
2295
2296
2297
2298 static int
2299 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
2300                 struct crypto_unittest_params *ut_params,
2301                 uint8_t *cipher_key,
2302                 uint8_t *hmac_key);
2303
2304 static int
2305 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
2306                 struct crypto_unittest_params *ut_params,
2307                 struct crypto_testsuite_params *ts_params,
2308                 const uint8_t *cipher,
2309                 const uint8_t *digest,
2310                 const uint8_t *iv);
2311
2312
2313 static int
2314 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
2315                 struct crypto_unittest_params *ut_params,
2316                 uint8_t *cipher_key,
2317                 uint8_t *hmac_key)
2318 {
2319
2320         /* Setup Cipher Parameters */
2321         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2322         ut_params->cipher_xform.next = NULL;
2323
2324         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
2325         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
2326         ut_params->cipher_xform.cipher.key.data = cipher_key;
2327         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
2328         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2329         ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
2330
2331         /* Setup HMAC Parameters */
2332         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2333         ut_params->auth_xform.next = &ut_params->cipher_xform;
2334
2335         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
2336         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC;
2337         ut_params->auth_xform.auth.key.data = hmac_key;
2338         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512;
2339         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512;
2340
2341         return TEST_SUCCESS;
2342 }
2343
2344
2345 static int
2346 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
2347                 struct crypto_unittest_params *ut_params,
2348                 struct crypto_testsuite_params *ts_params,
2349                 const uint8_t *cipher,
2350                 const uint8_t *digest,
2351                 const uint8_t *iv)
2352 {
2353         /* Generate test mbuf data and digest */
2354         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
2355                         (const char *)
2356                         cipher,
2357                         QUOTE_512_BYTES, 0);
2358
2359         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2360                         DIGEST_BYTE_LENGTH_SHA512);
2361         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
2362
2363         rte_memcpy(ut_params->digest,
2364                         digest,
2365                         DIGEST_BYTE_LENGTH_SHA512);
2366
2367         /* Generate Crypto op data structure */
2368         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2369                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2370         TEST_ASSERT_NOT_NULL(ut_params->op,
2371                         "Failed to allocate symmetric crypto operation struct");
2372
2373         rte_crypto_op_attach_sym_session(ut_params->op, sess);
2374
2375         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2376
2377         /* set crypto operation source mbuf */
2378         sym_op->m_src = ut_params->ibuf;
2379
2380         sym_op->auth.digest.data = ut_params->digest;
2381         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2382                         ut_params->ibuf, QUOTE_512_BYTES);
2383
2384         sym_op->auth.data.offset = 0;
2385         sym_op->auth.data.length = QUOTE_512_BYTES;
2386
2387         /* Copy IV at the end of the crypto operation */
2388         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2389                         iv, CIPHER_IV_LENGTH_AES_CBC);
2390
2391         sym_op->cipher.data.offset = 0;
2392         sym_op->cipher.data.length = QUOTE_512_BYTES;
2393
2394         /* Process crypto operation */
2395         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2396                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
2397                         ut_params->op);
2398         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
2399                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
2400                                 ut_params->op, 1, 1, 0, 0);
2401         else
2402                 TEST_ASSERT_NOT_NULL(
2403                                 process_crypto_request(ts_params->valid_devs[0],
2404                                         ut_params->op),
2405                                         "failed to process sym crypto op");
2406
2407         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2408                         "crypto op processing failed");
2409
2410         ut_params->obuf = ut_params->op->sym->m_src;
2411
2412         /* Validate obuf */
2413         TEST_ASSERT_BUFFERS_ARE_EQUAL(
2414                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *),
2415                         catch_22_quote,
2416                         QUOTE_512_BYTES,
2417                         "Plaintext data not as expected");
2418
2419         /* Validate obuf */
2420         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2421                         "Digest verification failed");
2422
2423         return TEST_SUCCESS;
2424 }
2425
2426 /* ***** SNOW 3G Tests ***** */
2427 static int
2428 create_wireless_algo_hash_session(uint8_t dev_id,
2429         const uint8_t *key, const uint8_t key_len,
2430         const uint8_t iv_len, const uint8_t auth_len,
2431         enum rte_crypto_auth_operation op,
2432         enum rte_crypto_auth_algorithm algo)
2433 {
2434         uint8_t hash_key[key_len];
2435         int status;
2436
2437         struct crypto_testsuite_params *ts_params = &testsuite_params;
2438         struct crypto_unittest_params *ut_params = &unittest_params;
2439
2440         memcpy(hash_key, key, key_len);
2441
2442         debug_hexdump(stdout, "key:", key, key_len);
2443
2444         /* Setup Authentication Parameters */
2445         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2446         ut_params->auth_xform.next = NULL;
2447
2448         ut_params->auth_xform.auth.op = op;
2449         ut_params->auth_xform.auth.algo = algo;
2450         ut_params->auth_xform.auth.key.length = key_len;
2451         ut_params->auth_xform.auth.key.data = hash_key;
2452         ut_params->auth_xform.auth.digest_length = auth_len;
2453         ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
2454         ut_params->auth_xform.auth.iv.length = iv_len;
2455         ut_params->sess = rte_cryptodev_sym_session_create(
2456                         ts_params->session_mpool);
2457
2458         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2459                         &ut_params->auth_xform,
2460                         ts_params->session_priv_mpool);
2461         if (status == -ENOTSUP)
2462                 return TEST_SKIPPED;
2463
2464         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2465         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2466         return 0;
2467 }
2468
2469 static int
2470 create_wireless_algo_cipher_session(uint8_t dev_id,
2471                         enum rte_crypto_cipher_operation op,
2472                         enum rte_crypto_cipher_algorithm algo,
2473                         const uint8_t *key, const uint8_t key_len,
2474                         uint8_t iv_len)
2475 {
2476         uint8_t cipher_key[key_len];
2477         int status;
2478         struct crypto_testsuite_params *ts_params = &testsuite_params;
2479         struct crypto_unittest_params *ut_params = &unittest_params;
2480
2481         memcpy(cipher_key, key, key_len);
2482
2483         /* Setup Cipher Parameters */
2484         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2485         ut_params->cipher_xform.next = NULL;
2486
2487         ut_params->cipher_xform.cipher.algo = algo;
2488         ut_params->cipher_xform.cipher.op = op;
2489         ut_params->cipher_xform.cipher.key.data = cipher_key;
2490         ut_params->cipher_xform.cipher.key.length = key_len;
2491         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2492         ut_params->cipher_xform.cipher.iv.length = iv_len;
2493
2494         debug_hexdump(stdout, "key:", key, key_len);
2495
2496         /* Create Crypto session */
2497         ut_params->sess = rte_cryptodev_sym_session_create(
2498                         ts_params->session_mpool);
2499
2500         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2501                         &ut_params->cipher_xform,
2502                         ts_params->session_priv_mpool);
2503         if (status == -ENOTSUP)
2504                 return TEST_SKIPPED;
2505
2506         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2507         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2508         return 0;
2509 }
2510
2511 static int
2512 create_wireless_algo_cipher_operation(const uint8_t *iv, uint8_t iv_len,
2513                         unsigned int cipher_len,
2514                         unsigned int cipher_offset)
2515 {
2516         struct crypto_testsuite_params *ts_params = &testsuite_params;
2517         struct crypto_unittest_params *ut_params = &unittest_params;
2518
2519         /* Generate Crypto op data structure */
2520         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2521                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2522         TEST_ASSERT_NOT_NULL(ut_params->op,
2523                                 "Failed to allocate pktmbuf offload");
2524
2525         /* Set crypto operation data parameters */
2526         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2527
2528         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2529
2530         /* set crypto operation source mbuf */
2531         sym_op->m_src = ut_params->ibuf;
2532
2533         /* iv */
2534         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2535                         iv, iv_len);
2536         sym_op->cipher.data.length = cipher_len;
2537         sym_op->cipher.data.offset = cipher_offset;
2538         return 0;
2539 }
2540
2541 static int
2542 create_wireless_algo_cipher_operation_oop(const uint8_t *iv, uint8_t iv_len,
2543                         unsigned int cipher_len,
2544                         unsigned int cipher_offset)
2545 {
2546         struct crypto_testsuite_params *ts_params = &testsuite_params;
2547         struct crypto_unittest_params *ut_params = &unittest_params;
2548
2549         /* Generate Crypto op data structure */
2550         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2551                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2552         TEST_ASSERT_NOT_NULL(ut_params->op,
2553                                 "Failed to allocate pktmbuf offload");
2554
2555         /* Set crypto operation data parameters */
2556         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2557
2558         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2559
2560         /* set crypto operation source mbuf */
2561         sym_op->m_src = ut_params->ibuf;
2562         sym_op->m_dst = ut_params->obuf;
2563
2564         /* iv */
2565         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2566                         iv, iv_len);
2567         sym_op->cipher.data.length = cipher_len;
2568         sym_op->cipher.data.offset = cipher_offset;
2569         return 0;
2570 }
2571
2572 static int
2573 create_wireless_algo_cipher_auth_session(uint8_t dev_id,
2574                 enum rte_crypto_cipher_operation cipher_op,
2575                 enum rte_crypto_auth_operation auth_op,
2576                 enum rte_crypto_auth_algorithm auth_algo,
2577                 enum rte_crypto_cipher_algorithm cipher_algo,
2578                 const uint8_t *key, uint8_t key_len,
2579                 uint8_t auth_iv_len, uint8_t auth_len,
2580                 uint8_t cipher_iv_len)
2581
2582 {
2583         uint8_t cipher_auth_key[key_len];
2584         int status;
2585
2586         struct crypto_testsuite_params *ts_params = &testsuite_params;
2587         struct crypto_unittest_params *ut_params = &unittest_params;
2588
2589         memcpy(cipher_auth_key, key, key_len);
2590
2591         /* Setup Authentication Parameters */
2592         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2593         ut_params->auth_xform.next = NULL;
2594
2595         ut_params->auth_xform.auth.op = auth_op;
2596         ut_params->auth_xform.auth.algo = auth_algo;
2597         ut_params->auth_xform.auth.key.length = key_len;
2598         /* Hash key = cipher key */
2599         ut_params->auth_xform.auth.key.data = cipher_auth_key;
2600         ut_params->auth_xform.auth.digest_length = auth_len;
2601         /* Auth IV will be after cipher IV */
2602         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2603         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2604
2605         /* Setup Cipher Parameters */
2606         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2607         ut_params->cipher_xform.next = &ut_params->auth_xform;
2608
2609         ut_params->cipher_xform.cipher.algo = cipher_algo;
2610         ut_params->cipher_xform.cipher.op = cipher_op;
2611         ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2612         ut_params->cipher_xform.cipher.key.length = key_len;
2613         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2614         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2615
2616         debug_hexdump(stdout, "key:", key, key_len);
2617
2618         /* Create Crypto session*/
2619         ut_params->sess = rte_cryptodev_sym_session_create(
2620                         ts_params->session_mpool);
2621         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2622
2623         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2624                         &ut_params->cipher_xform,
2625                         ts_params->session_priv_mpool);
2626         if (status == -ENOTSUP)
2627                 return TEST_SKIPPED;
2628
2629         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2630         return 0;
2631 }
2632
2633 static int
2634 create_wireless_cipher_auth_session(uint8_t dev_id,
2635                 enum rte_crypto_cipher_operation cipher_op,
2636                 enum rte_crypto_auth_operation auth_op,
2637                 enum rte_crypto_auth_algorithm auth_algo,
2638                 enum rte_crypto_cipher_algorithm cipher_algo,
2639                 const struct wireless_test_data *tdata)
2640 {
2641         const uint8_t key_len = tdata->key.len;
2642         uint8_t cipher_auth_key[key_len];
2643         int status;
2644
2645         struct crypto_testsuite_params *ts_params = &testsuite_params;
2646         struct crypto_unittest_params *ut_params = &unittest_params;
2647         const uint8_t *key = tdata->key.data;
2648         const uint8_t auth_len = tdata->digest.len;
2649         uint8_t cipher_iv_len = tdata->cipher_iv.len;
2650         uint8_t auth_iv_len = tdata->auth_iv.len;
2651
2652         memcpy(cipher_auth_key, key, key_len);
2653
2654         /* Setup Authentication Parameters */
2655         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2656         ut_params->auth_xform.next = NULL;
2657
2658         ut_params->auth_xform.auth.op = auth_op;
2659         ut_params->auth_xform.auth.algo = auth_algo;
2660         ut_params->auth_xform.auth.key.length = key_len;
2661         /* Hash key = cipher key */
2662         ut_params->auth_xform.auth.key.data = cipher_auth_key;
2663         ut_params->auth_xform.auth.digest_length = auth_len;
2664         /* Auth IV will be after cipher IV */
2665         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2666         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2667
2668         /* Setup Cipher Parameters */
2669         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2670         ut_params->cipher_xform.next = &ut_params->auth_xform;
2671
2672         ut_params->cipher_xform.cipher.algo = cipher_algo;
2673         ut_params->cipher_xform.cipher.op = cipher_op;
2674         ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2675         ut_params->cipher_xform.cipher.key.length = key_len;
2676         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2677         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2678
2679
2680         debug_hexdump(stdout, "key:", key, key_len);
2681
2682         /* Create Crypto session*/
2683         ut_params->sess = rte_cryptodev_sym_session_create(
2684                         ts_params->session_mpool);
2685
2686         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2687                         &ut_params->cipher_xform,
2688                         ts_params->session_priv_mpool);
2689         if (status == -ENOTSUP)
2690                 return TEST_SKIPPED;
2691
2692         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2693         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2694         return 0;
2695 }
2696
2697 static int
2698 create_zuc_cipher_auth_encrypt_generate_session(uint8_t dev_id,
2699                 const struct wireless_test_data *tdata)
2700 {
2701         return create_wireless_cipher_auth_session(dev_id,
2702                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2703                 RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_ZUC_EIA3,
2704                 RTE_CRYPTO_CIPHER_ZUC_EEA3, tdata);
2705 }
2706
2707 static int
2708 create_wireless_algo_auth_cipher_session(uint8_t dev_id,
2709                 enum rte_crypto_cipher_operation cipher_op,
2710                 enum rte_crypto_auth_operation auth_op,
2711                 enum rte_crypto_auth_algorithm auth_algo,
2712                 enum rte_crypto_cipher_algorithm cipher_algo,
2713                 const uint8_t *key, const uint8_t key_len,
2714                 uint8_t auth_iv_len, uint8_t auth_len,
2715                 uint8_t cipher_iv_len)
2716 {
2717         uint8_t auth_cipher_key[key_len];
2718         int status;
2719         struct crypto_testsuite_params *ts_params = &testsuite_params;
2720         struct crypto_unittest_params *ut_params = &unittest_params;
2721
2722         memcpy(auth_cipher_key, key, key_len);
2723
2724         /* Setup Authentication Parameters */
2725         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2726         ut_params->auth_xform.auth.op = auth_op;
2727         ut_params->auth_xform.next = &ut_params->cipher_xform;
2728         ut_params->auth_xform.auth.algo = auth_algo;
2729         ut_params->auth_xform.auth.key.length = key_len;
2730         ut_params->auth_xform.auth.key.data = auth_cipher_key;
2731         ut_params->auth_xform.auth.digest_length = auth_len;
2732         /* Auth IV will be after cipher IV */
2733         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2734         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2735
2736         /* Setup Cipher Parameters */
2737         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2738         ut_params->cipher_xform.next = NULL;
2739         ut_params->cipher_xform.cipher.algo = cipher_algo;
2740         ut_params->cipher_xform.cipher.op = cipher_op;
2741         ut_params->cipher_xform.cipher.key.data = auth_cipher_key;
2742         ut_params->cipher_xform.cipher.key.length = key_len;
2743         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2744         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2745
2746         debug_hexdump(stdout, "key:", key, key_len);
2747
2748         /* Create Crypto session*/
2749         ut_params->sess = rte_cryptodev_sym_session_create(
2750                         ts_params->session_mpool);
2751         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2752
2753         if (cipher_op == RTE_CRYPTO_CIPHER_OP_DECRYPT) {
2754                 ut_params->auth_xform.next = NULL;
2755                 ut_params->cipher_xform.next = &ut_params->auth_xform;
2756                 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2757                                 &ut_params->cipher_xform,
2758                                 ts_params->session_priv_mpool);
2759
2760         } else
2761                 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2762                                 &ut_params->auth_xform,
2763                                 ts_params->session_priv_mpool);
2764
2765         if (status == -ENOTSUP)
2766                 return TEST_SKIPPED;
2767
2768         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2769
2770         return 0;
2771 }
2772
2773 static int
2774 create_wireless_algo_hash_operation(const uint8_t *auth_tag,
2775                 unsigned int auth_tag_len,
2776                 const uint8_t *iv, unsigned int iv_len,
2777                 unsigned int data_pad_len,
2778                 enum rte_crypto_auth_operation op,
2779                 unsigned int auth_len, unsigned int auth_offset)
2780 {
2781         struct crypto_testsuite_params *ts_params = &testsuite_params;
2782
2783         struct crypto_unittest_params *ut_params = &unittest_params;
2784
2785         /* Generate Crypto op data structure */
2786         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2787                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2788         TEST_ASSERT_NOT_NULL(ut_params->op,
2789                 "Failed to allocate pktmbuf offload");
2790
2791         /* Set crypto operation data parameters */
2792         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2793
2794         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2795
2796         /* set crypto operation source mbuf */
2797         sym_op->m_src = ut_params->ibuf;
2798
2799         /* iv */
2800         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2801                         iv, iv_len);
2802         /* digest */
2803         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2804                                         ut_params->ibuf, auth_tag_len);
2805
2806         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2807                                 "no room to append auth tag");
2808         ut_params->digest = sym_op->auth.digest.data;
2809         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2810                         ut_params->ibuf, data_pad_len);
2811         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2812                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2813         else
2814                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2815
2816         debug_hexdump(stdout, "digest:",
2817                 sym_op->auth.digest.data,
2818                 auth_tag_len);
2819
2820         sym_op->auth.data.length = auth_len;
2821         sym_op->auth.data.offset = auth_offset;
2822
2823         return 0;
2824 }
2825
2826 static int
2827 create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata,
2828         enum rte_crypto_auth_operation op)
2829 {
2830         struct crypto_testsuite_params *ts_params = &testsuite_params;
2831         struct crypto_unittest_params *ut_params = &unittest_params;
2832
2833         const uint8_t *auth_tag = tdata->digest.data;
2834         const unsigned int auth_tag_len = tdata->digest.len;
2835         unsigned int plaintext_len = ceil_byte_length(tdata->plaintext.len);
2836         unsigned int data_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2837
2838         const uint8_t *cipher_iv = tdata->cipher_iv.data;
2839         const uint8_t cipher_iv_len = tdata->cipher_iv.len;
2840         const uint8_t *auth_iv = tdata->auth_iv.data;
2841         const uint8_t auth_iv_len = tdata->auth_iv.len;
2842         const unsigned int cipher_len = tdata->validCipherLenInBits.len;
2843         const unsigned int auth_len = tdata->validAuthLenInBits.len;
2844
2845         /* Generate Crypto op data structure */
2846         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2847                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2848         TEST_ASSERT_NOT_NULL(ut_params->op,
2849                         "Failed to allocate pktmbuf offload");
2850         /* Set crypto operation data parameters */
2851         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2852
2853         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2854
2855         /* set crypto operation source mbuf */
2856         sym_op->m_src = ut_params->ibuf;
2857
2858         /* digest */
2859         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2860                         ut_params->ibuf, auth_tag_len);
2861
2862         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2863                         "no room to append auth tag");
2864         ut_params->digest = sym_op->auth.digest.data;
2865         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2866                         ut_params->ibuf, data_pad_len);
2867         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2868                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2869         else
2870                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2871
2872         debug_hexdump(stdout, "digest:",
2873                 sym_op->auth.digest.data,
2874                 auth_tag_len);
2875
2876         /* Copy cipher and auth IVs at the end of the crypto operation */
2877         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2878                                                 IV_OFFSET);
2879         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2880         iv_ptr += cipher_iv_len;
2881         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2882
2883         sym_op->cipher.data.length = cipher_len;
2884         sym_op->cipher.data.offset = 0;
2885         sym_op->auth.data.length = auth_len;
2886         sym_op->auth.data.offset = 0;
2887
2888         return 0;
2889 }
2890
2891 static int
2892 create_zuc_cipher_hash_generate_operation(
2893                 const struct wireless_test_data *tdata)
2894 {
2895         return create_wireless_cipher_hash_operation(tdata,
2896                 RTE_CRYPTO_AUTH_OP_GENERATE);
2897 }
2898
2899 static int
2900 create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
2901                 const unsigned auth_tag_len,
2902                 const uint8_t *auth_iv, uint8_t auth_iv_len,
2903                 unsigned data_pad_len,
2904                 enum rte_crypto_auth_operation op,
2905                 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2906                 const unsigned cipher_len, const unsigned cipher_offset,
2907                 const unsigned auth_len, const unsigned auth_offset)
2908 {
2909         struct crypto_testsuite_params *ts_params = &testsuite_params;
2910         struct crypto_unittest_params *ut_params = &unittest_params;
2911
2912         enum rte_crypto_cipher_algorithm cipher_algo =
2913                         ut_params->cipher_xform.cipher.algo;
2914         enum rte_crypto_auth_algorithm auth_algo =
2915                         ut_params->auth_xform.auth.algo;
2916
2917         /* Generate Crypto op data structure */
2918         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2919                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2920         TEST_ASSERT_NOT_NULL(ut_params->op,
2921                         "Failed to allocate pktmbuf offload");
2922         /* Set crypto operation data parameters */
2923         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2924
2925         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2926
2927         /* set crypto operation source mbuf */
2928         sym_op->m_src = ut_params->ibuf;
2929
2930         /* digest */
2931         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2932                         ut_params->ibuf, auth_tag_len);
2933
2934         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2935                         "no room to append auth tag");
2936         ut_params->digest = sym_op->auth.digest.data;
2937
2938         if (rte_pktmbuf_is_contiguous(ut_params->ibuf)) {
2939                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2940                                 ut_params->ibuf, data_pad_len);
2941         } else {
2942                 struct rte_mbuf *m = ut_params->ibuf;
2943                 unsigned int offset = data_pad_len;
2944
2945                 while (offset > m->data_len && m->next != NULL) {
2946                         offset -= m->data_len;
2947                         m = m->next;
2948                 }
2949                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2950                         m, offset);
2951         }
2952
2953         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2954                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2955         else
2956                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2957
2958         debug_hexdump(stdout, "digest:",
2959                 sym_op->auth.digest.data,
2960                 auth_tag_len);
2961
2962         /* Copy cipher and auth IVs at the end of the crypto operation */
2963         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2964                                                 IV_OFFSET);
2965         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2966         iv_ptr += cipher_iv_len;
2967         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2968
2969         if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
2970                 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
2971                 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
2972                 sym_op->cipher.data.length = cipher_len;
2973                 sym_op->cipher.data.offset = cipher_offset;
2974         } else {
2975                 sym_op->cipher.data.length = cipher_len >> 3;
2976                 sym_op->cipher.data.offset = cipher_offset >> 3;
2977         }
2978
2979         if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
2980                 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
2981                 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
2982                 sym_op->auth.data.length = auth_len;
2983                 sym_op->auth.data.offset = auth_offset;
2984         } else {
2985                 sym_op->auth.data.length = auth_len >> 3;
2986                 sym_op->auth.data.offset = auth_offset >> 3;
2987         }
2988
2989         return 0;
2990 }
2991
2992 static int
2993 create_wireless_algo_auth_cipher_operation(
2994                 const uint8_t *auth_tag, unsigned int auth_tag_len,
2995                 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2996                 const uint8_t *auth_iv, uint8_t auth_iv_len,
2997                 unsigned int data_pad_len,
2998                 unsigned int cipher_len, unsigned int cipher_offset,
2999                 unsigned int auth_len, unsigned int auth_offset,
3000                 uint8_t op_mode, uint8_t do_sgl, uint8_t verify)
3001 {
3002         struct crypto_testsuite_params *ts_params = &testsuite_params;
3003         struct crypto_unittest_params *ut_params = &unittest_params;
3004
3005         enum rte_crypto_cipher_algorithm cipher_algo =
3006                         ut_params->cipher_xform.cipher.algo;
3007         enum rte_crypto_auth_algorithm auth_algo =
3008                         ut_params->auth_xform.auth.algo;
3009
3010         /* Generate Crypto op data structure */
3011         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
3012                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
3013         TEST_ASSERT_NOT_NULL(ut_params->op,
3014                         "Failed to allocate pktmbuf offload");
3015
3016         /* Set crypto operation data parameters */
3017         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
3018
3019         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
3020
3021         /* set crypto operation mbufs */
3022         sym_op->m_src = ut_params->ibuf;
3023         if (op_mode == OUT_OF_PLACE)
3024                 sym_op->m_dst = ut_params->obuf;
3025
3026         /* digest */
3027         if (!do_sgl) {
3028                 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(
3029                         (op_mode == IN_PLACE ?
3030                                 ut_params->ibuf : ut_params->obuf),
3031                         uint8_t *, data_pad_len);
3032                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
3033                         (op_mode == IN_PLACE ?
3034                                 ut_params->ibuf : ut_params->obuf),
3035                         data_pad_len);
3036                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
3037         } else {
3038                 uint16_t remaining_off = (auth_offset >> 3) + (auth_len >> 3);
3039                 struct rte_mbuf *sgl_buf = (op_mode == IN_PLACE ?
3040                                 sym_op->m_src : sym_op->m_dst);
3041                 while (remaining_off >= rte_pktmbuf_data_len(sgl_buf)) {
3042                         remaining_off -= rte_pktmbuf_data_len(sgl_buf);
3043                         sgl_buf = sgl_buf->next;
3044                 }
3045                 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(sgl_buf,
3046                                 uint8_t *, remaining_off);
3047                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(sgl_buf,
3048                                 remaining_off);
3049                 memset(sym_op->auth.digest.data, 0, remaining_off);
3050                 while (sgl_buf->next != NULL) {
3051                         memset(rte_pktmbuf_mtod(sgl_buf, uint8_t *),
3052                                 0, rte_pktmbuf_data_len(sgl_buf));
3053                         sgl_buf = sgl_buf->next;
3054                 }
3055         }
3056
3057         /* Copy digest for the verification */
3058         if (verify)
3059                 memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
3060
3061         /* Copy cipher and auth IVs at the end of the crypto operation */
3062         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(
3063                         ut_params->op, uint8_t *, IV_OFFSET);
3064
3065         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
3066         iv_ptr += cipher_iv_len;
3067         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
3068
3069         /* Only copy over the offset data needed from src to dst in OOP,
3070          * if the auth and cipher offsets are not aligned
3071          */
3072         if (op_mode == OUT_OF_PLACE) {
3073                 if (cipher_offset > auth_offset)
3074                         rte_memcpy(
3075                                 rte_pktmbuf_mtod_offset(
3076                                         sym_op->m_dst,
3077                                         uint8_t *, auth_offset >> 3),
3078                                 rte_pktmbuf_mtod_offset(
3079                                         sym_op->m_src,
3080                                         uint8_t *, auth_offset >> 3),
3081                                 ((cipher_offset >> 3) - (auth_offset >> 3)));
3082         }
3083
3084         if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
3085                 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
3086                 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
3087                 sym_op->cipher.data.length = cipher_len;
3088                 sym_op->cipher.data.offset = cipher_offset;
3089         } else {
3090                 sym_op->cipher.data.length = cipher_len >> 3;
3091                 sym_op->cipher.data.offset = cipher_offset >> 3;
3092         }
3093
3094         if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
3095                 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
3096                 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
3097                 sym_op->auth.data.length = auth_len;
3098                 sym_op->auth.data.offset = auth_offset;
3099         } else {
3100                 sym_op->auth.data.length = auth_len >> 3;
3101                 sym_op->auth.data.offset = auth_offset >> 3;
3102         }
3103
3104         return 0;
3105 }
3106
3107 static int
3108 test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
3109 {
3110         struct crypto_testsuite_params *ts_params = &testsuite_params;
3111         struct crypto_unittest_params *ut_params = &unittest_params;
3112
3113         int retval;
3114         unsigned plaintext_pad_len;
3115         unsigned plaintext_len;
3116         uint8_t *plaintext;
3117         struct rte_cryptodev_info dev_info;
3118
3119         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3120         uint64_t feat_flags = dev_info.feature_flags;
3121
3122         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
3123                         ((tdata->validAuthLenInBits.len % 8) != 0)) {
3124                 printf("Device doesn't support NON-Byte Aligned Data.\n");
3125                 return TEST_SKIPPED;
3126         }
3127
3128         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3129                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3130                 printf("Device doesn't support RAW data-path APIs.\n");
3131                 return TEST_SKIPPED;
3132         }
3133
3134         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3135                 return TEST_SKIPPED;
3136
3137         /* Verify the capabilities */
3138         struct rte_cryptodev_sym_capability_idx cap_idx;
3139         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3140         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
3141         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3142                         &cap_idx) == NULL)
3143                 return TEST_SKIPPED;
3144
3145         /* Create SNOW 3G session */
3146         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3147                         tdata->key.data, tdata->key.len,
3148                         tdata->auth_iv.len, tdata->digest.len,
3149                         RTE_CRYPTO_AUTH_OP_GENERATE,
3150                         RTE_CRYPTO_AUTH_SNOW3G_UIA2);
3151         if (retval < 0)
3152                 return retval;
3153
3154         /* alloc mbuf and set payload */
3155         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3156
3157         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3158         rte_pktmbuf_tailroom(ut_params->ibuf));
3159
3160         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3161         /* Append data which is padded to a multiple of */
3162         /* the algorithms block size */
3163         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3164         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3165                                 plaintext_pad_len);
3166         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3167
3168         /* Create SNOW 3G operation */
3169         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
3170                         tdata->auth_iv.data, tdata->auth_iv.len,
3171                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3172                         tdata->validAuthLenInBits.len,
3173                         0);
3174         if (retval < 0)
3175                 return retval;
3176
3177         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3178                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3179                                 ut_params->op, 0, 1, 1, 0);
3180         else
3181                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3182                                 ut_params->op);
3183         ut_params->obuf = ut_params->op->sym->m_src;
3184         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3185         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3186                         + plaintext_pad_len;
3187
3188         /* Validate obuf */
3189         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3190         ut_params->digest,
3191         tdata->digest.data,
3192         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
3193         "SNOW 3G Generated auth tag not as expected");
3194
3195         return 0;
3196 }
3197
3198 static int
3199 test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
3200 {
3201         struct crypto_testsuite_params *ts_params = &testsuite_params;
3202         struct crypto_unittest_params *ut_params = &unittest_params;
3203
3204         int retval;
3205         unsigned plaintext_pad_len;
3206         unsigned plaintext_len;
3207         uint8_t *plaintext;
3208         struct rte_cryptodev_info dev_info;
3209
3210         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3211         uint64_t feat_flags = dev_info.feature_flags;
3212
3213         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
3214                         ((tdata->validAuthLenInBits.len % 8) != 0)) {
3215                 printf("Device doesn't support NON-Byte Aligned Data.\n");
3216                 return TEST_SKIPPED;
3217         }
3218
3219         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3220                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3221                 printf("Device doesn't support RAW data-path APIs.\n");
3222                 return TEST_SKIPPED;
3223         }
3224
3225         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3226                 return TEST_SKIPPED;
3227
3228         /* Verify the capabilities */
3229         struct rte_cryptodev_sym_capability_idx cap_idx;
3230         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3231         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
3232         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3233                         &cap_idx) == NULL)
3234                 return TEST_SKIPPED;
3235
3236         /* Create SNOW 3G session */
3237         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3238                                 tdata->key.data, tdata->key.len,
3239                                 tdata->auth_iv.len, tdata->digest.len,
3240                                 RTE_CRYPTO_AUTH_OP_VERIFY,
3241                                 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
3242         if (retval < 0)
3243                 return retval;
3244         /* alloc mbuf and set payload */
3245         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3246
3247         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3248         rte_pktmbuf_tailroom(ut_params->ibuf));
3249
3250         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3251         /* Append data which is padded to a multiple of */
3252         /* the algorithms block size */
3253         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3254         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3255                                 plaintext_pad_len);
3256         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3257
3258         /* Create SNOW 3G operation */
3259         retval = create_wireless_algo_hash_operation(tdata->digest.data,
3260                         tdata->digest.len,
3261                         tdata->auth_iv.data, tdata->auth_iv.len,
3262                         plaintext_pad_len,
3263                         RTE_CRYPTO_AUTH_OP_VERIFY,
3264                         tdata->validAuthLenInBits.len,
3265                         0);
3266         if (retval < 0)
3267                 return retval;
3268
3269         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3270                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3271                                 ut_params->op, 0, 1, 1, 0);
3272         else
3273                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3274                                 ut_params->op);
3275         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3276         ut_params->obuf = ut_params->op->sym->m_src;
3277         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3278                                 + plaintext_pad_len;
3279
3280         /* Validate obuf */
3281         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
3282                 return 0;
3283         else
3284                 return -1;
3285
3286         return 0;
3287 }
3288
3289 static int
3290 test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
3291 {
3292         struct crypto_testsuite_params *ts_params = &testsuite_params;
3293         struct crypto_unittest_params *ut_params = &unittest_params;
3294
3295         int retval;
3296         unsigned plaintext_pad_len;
3297         unsigned plaintext_len;
3298         uint8_t *plaintext;
3299         struct rte_cryptodev_info dev_info;
3300
3301         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3302         uint64_t feat_flags = dev_info.feature_flags;
3303
3304         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3305                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3306                 printf("Device doesn't support RAW data-path APIs.\n");
3307                 return TEST_SKIPPED;
3308         }
3309
3310         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3311                 return TEST_SKIPPED;
3312
3313         /* Verify the capabilities */
3314         struct rte_cryptodev_sym_capability_idx cap_idx;
3315         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3316         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
3317         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3318                         &cap_idx) == NULL)
3319                 return TEST_SKIPPED;
3320
3321         /* Create KASUMI session */
3322         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3323                         tdata->key.data, tdata->key.len,
3324                         0, tdata->digest.len,
3325                         RTE_CRYPTO_AUTH_OP_GENERATE,
3326                         RTE_CRYPTO_AUTH_KASUMI_F9);
3327         if (retval < 0)
3328                 return retval;
3329
3330         /* alloc mbuf and set payload */
3331         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3332
3333         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3334         rte_pktmbuf_tailroom(ut_params->ibuf));
3335
3336         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3337         /* Append data which is padded to a multiple of */
3338         /* the algorithms block size */
3339         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3340         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3341                                 plaintext_pad_len);
3342         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3343
3344         /* Create KASUMI operation */
3345         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
3346                         NULL, 0,
3347                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3348                         tdata->plaintext.len,
3349                         0);
3350         if (retval < 0)
3351                 return retval;
3352
3353         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3354                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
3355                         ut_params->op);
3356         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3357                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3358                                 ut_params->op, 0, 1, 1, 0);
3359         else
3360                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3361                         ut_params->op);
3362
3363         ut_params->obuf = ut_params->op->sym->m_src;
3364         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3365         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3366                         + plaintext_pad_len;
3367
3368         /* Validate obuf */
3369         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3370         ut_params->digest,
3371         tdata->digest.data,
3372         DIGEST_BYTE_LENGTH_KASUMI_F9,
3373         "KASUMI Generated auth tag not as expected");
3374
3375         return 0;
3376 }
3377
3378 static int
3379 test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
3380 {
3381         struct crypto_testsuite_params *ts_params = &testsuite_params;
3382         struct crypto_unittest_params *ut_params = &unittest_params;
3383
3384         int retval;
3385         unsigned plaintext_pad_len;
3386         unsigned plaintext_len;
3387         uint8_t *plaintext;
3388         struct rte_cryptodev_info dev_info;
3389
3390         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3391         uint64_t feat_flags = dev_info.feature_flags;
3392
3393         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3394                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3395                 printf("Device doesn't support RAW data-path APIs.\n");
3396                 return TEST_SKIPPED;
3397         }
3398
3399         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3400                 return TEST_SKIPPED;
3401
3402         /* Verify the capabilities */
3403         struct rte_cryptodev_sym_capability_idx cap_idx;
3404         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3405         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
3406         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3407                         &cap_idx) == NULL)
3408                 return TEST_SKIPPED;
3409
3410         /* Create KASUMI session */
3411         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3412                                 tdata->key.data, tdata->key.len,
3413                                 0, tdata->digest.len,
3414                                 RTE_CRYPTO_AUTH_OP_VERIFY,
3415                                 RTE_CRYPTO_AUTH_KASUMI_F9);
3416         if (retval < 0)
3417                 return retval;
3418         /* alloc mbuf and set payload */
3419         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3420
3421         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3422         rte_pktmbuf_tailroom(ut_params->ibuf));
3423
3424         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3425         /* Append data which is padded to a multiple */
3426         /* of the algorithms block size */
3427         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3428         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3429                                 plaintext_pad_len);
3430         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3431
3432         /* Create KASUMI operation */
3433         retval = create_wireless_algo_hash_operation(tdata->digest.data,
3434                         tdata->digest.len,
3435                         NULL, 0,
3436                         plaintext_pad_len,
3437                         RTE_CRYPTO_AUTH_OP_VERIFY,
3438                         tdata->plaintext.len,
3439                         0);
3440         if (retval < 0)
3441                 return retval;
3442
3443         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3444                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3445                                 ut_params->op, 0, 1, 1, 0);
3446         else
3447                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3448                                 ut_params->op);
3449         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3450         ut_params->obuf = ut_params->op->sym->m_src;
3451         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3452                                 + plaintext_pad_len;
3453
3454         /* Validate obuf */
3455         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
3456                 return 0;
3457         else
3458                 return -1;
3459
3460         return 0;
3461 }
3462
3463 static int
3464 test_snow3g_hash_generate_test_case_1(void)
3465 {
3466         return test_snow3g_authentication(&snow3g_hash_test_case_1);
3467 }
3468
3469 static int
3470 test_snow3g_hash_generate_test_case_2(void)
3471 {
3472         return test_snow3g_authentication(&snow3g_hash_test_case_2);
3473 }
3474
3475 static int
3476 test_snow3g_hash_generate_test_case_3(void)
3477 {
3478         return test_snow3g_authentication(&snow3g_hash_test_case_3);
3479 }
3480
3481 static int
3482 test_snow3g_hash_generate_test_case_4(void)
3483 {
3484         return test_snow3g_authentication(&snow3g_hash_test_case_4);
3485 }
3486
3487 static int
3488 test_snow3g_hash_generate_test_case_5(void)
3489 {
3490         return test_snow3g_authentication(&snow3g_hash_test_case_5);
3491 }
3492
3493 static int
3494 test_snow3g_hash_generate_test_case_6(void)
3495 {
3496         return test_snow3g_authentication(&snow3g_hash_test_case_6);
3497 }
3498
3499 static int
3500 test_snow3g_hash_verify_test_case_1(void)
3501 {
3502         return test_snow3g_authentication_verify(&snow3g_hash_test_case_1);
3503
3504 }
3505
3506 static int
3507 test_snow3g_hash_verify_test_case_2(void)
3508 {
3509         return test_snow3g_authentication_verify(&snow3g_hash_test_case_2);
3510 }
3511
3512 static int
3513 test_snow3g_hash_verify_test_case_3(void)
3514 {
3515         return test_snow3g_authentication_verify(&snow3g_hash_test_case_3);
3516 }
3517
3518 static int
3519 test_snow3g_hash_verify_test_case_4(void)
3520 {
3521         return test_snow3g_authentication_verify(&snow3g_hash_test_case_4);
3522 }
3523
3524 static int
3525 test_snow3g_hash_verify_test_case_5(void)
3526 {
3527         return test_snow3g_authentication_verify(&snow3g_hash_test_case_5);
3528 }
3529
3530 static int
3531 test_snow3g_hash_verify_test_case_6(void)
3532 {
3533         return test_snow3g_authentication_verify(&snow3g_hash_test_case_6);
3534 }
3535
3536 static int
3537 test_kasumi_hash_generate_test_case_1(void)
3538 {
3539         return test_kasumi_authentication(&kasumi_hash_test_case_1);
3540 }
3541
3542 static int
3543 test_kasumi_hash_generate_test_case_2(void)
3544 {
3545         return test_kasumi_authentication(&kasumi_hash_test_case_2);
3546 }
3547
3548 static int
3549 test_kasumi_hash_generate_test_case_3(void)
3550 {
3551         return test_kasumi_authentication(&kasumi_hash_test_case_3);
3552 }
3553
3554 static int
3555 test_kasumi_hash_generate_test_case_4(void)
3556 {
3557         return test_kasumi_authentication(&kasumi_hash_test_case_4);
3558 }
3559
3560 static int
3561 test_kasumi_hash_generate_test_case_5(void)
3562 {
3563         return test_kasumi_authentication(&kasumi_hash_test_case_5);
3564 }
3565
3566 static int
3567 test_kasumi_hash_generate_test_case_6(void)
3568 {
3569         return test_kasumi_authentication(&kasumi_hash_test_case_6);
3570 }
3571
3572 static int
3573 test_kasumi_hash_verify_test_case_1(void)
3574 {
3575         return test_kasumi_authentication_verify(&kasumi_hash_test_case_1);
3576 }
3577
3578 static int
3579 test_kasumi_hash_verify_test_case_2(void)
3580 {
3581         return test_kasumi_authentication_verify(&kasumi_hash_test_case_2);
3582 }
3583
3584 static int
3585 test_kasumi_hash_verify_test_case_3(void)
3586 {
3587         return test_kasumi_authentication_verify(&kasumi_hash_test_case_3);
3588 }
3589
3590 static int
3591 test_kasumi_hash_verify_test_case_4(void)
3592 {
3593         return test_kasumi_authentication_verify(&kasumi_hash_test_case_4);
3594 }
3595
3596 static int
3597 test_kasumi_hash_verify_test_case_5(void)
3598 {
3599         return test_kasumi_authentication_verify(&kasumi_hash_test_case_5);
3600 }
3601
3602 static int
3603 test_kasumi_encryption(const struct kasumi_test_data *tdata)
3604 {
3605         struct crypto_testsuite_params *ts_params = &testsuite_params;
3606         struct crypto_unittest_params *ut_params = &unittest_params;
3607
3608         int retval;
3609         uint8_t *plaintext, *ciphertext;
3610         unsigned plaintext_pad_len;
3611         unsigned plaintext_len;
3612         struct rte_cryptodev_info dev_info;
3613
3614         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3615         uint64_t feat_flags = dev_info.feature_flags;
3616
3617         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3618                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3619                 printf("Device doesn't support RAW data-path APIs.\n");
3620                 return TEST_SKIPPED;
3621         }
3622
3623         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3624                 return TEST_SKIPPED;
3625
3626         /* Verify the capabilities */
3627         struct rte_cryptodev_sym_capability_idx cap_idx;
3628         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3629         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3630         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3631                         &cap_idx) == NULL)
3632                 return TEST_SKIPPED;
3633
3634         /* Create KASUMI session */
3635         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3636                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3637                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3638                                         tdata->key.data, tdata->key.len,
3639                                         tdata->cipher_iv.len);
3640         if (retval < 0)
3641                 return retval;
3642
3643         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3644
3645         /* Clear mbuf payload */
3646         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3647                rte_pktmbuf_tailroom(ut_params->ibuf));
3648
3649         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3650         /* Append data which is padded to a multiple */
3651         /* of the algorithms block size */
3652         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3653         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3654                                 plaintext_pad_len);
3655         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3656
3657         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3658
3659         /* Create KASUMI operation */
3660         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3661                                 tdata->cipher_iv.len,
3662                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3663                                 tdata->validCipherOffsetInBits.len);
3664         if (retval < 0)
3665                 return retval;
3666
3667         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3668                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3669                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
3670         else
3671                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3672                                 ut_params->op);
3673         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3674
3675         ut_params->obuf = ut_params->op->sym->m_dst;
3676         if (ut_params->obuf)
3677                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3678         else
3679                 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3680
3681         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3682
3683         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3684                                 (tdata->validCipherOffsetInBits.len >> 3);
3685         /* Validate obuf */
3686         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3687                 ciphertext,
3688                 reference_ciphertext,
3689                 tdata->validCipherLenInBits.len,
3690                 "KASUMI Ciphertext data not as expected");
3691         return 0;
3692 }
3693
3694 static int
3695 test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
3696 {
3697         struct crypto_testsuite_params *ts_params = &testsuite_params;
3698         struct crypto_unittest_params *ut_params = &unittest_params;
3699
3700         int retval;
3701
3702         unsigned int plaintext_pad_len;
3703         unsigned int plaintext_len;
3704
3705         uint8_t buffer[10000];
3706         const uint8_t *ciphertext;
3707
3708         struct rte_cryptodev_info dev_info;
3709
3710         /* Verify the capabilities */
3711         struct rte_cryptodev_sym_capability_idx cap_idx;
3712         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3713         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3714         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3715                         &cap_idx) == NULL)
3716                 return TEST_SKIPPED;
3717
3718         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3719
3720         uint64_t feat_flags = dev_info.feature_flags;
3721
3722         if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
3723                 printf("Device doesn't support in-place scatter-gather. "
3724                                 "Test Skipped.\n");
3725                 return TEST_SKIPPED;
3726         }
3727
3728         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3729                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3730                 printf("Device doesn't support RAW data-path APIs.\n");
3731                 return TEST_SKIPPED;
3732         }
3733
3734         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3735                 return TEST_SKIPPED;
3736
3737         /* Create KASUMI session */
3738         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3739                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3740                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3741                                         tdata->key.data, tdata->key.len,
3742                                         tdata->cipher_iv.len);
3743         if (retval < 0)
3744                 return retval;
3745
3746         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3747
3748
3749         /* Append data which is padded to a multiple */
3750         /* of the algorithms block size */
3751         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3752
3753         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3754                         plaintext_pad_len, 10, 0);
3755
3756         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3757
3758         /* Create KASUMI operation */
3759         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3760                                 tdata->cipher_iv.len,
3761                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3762                                 tdata->validCipherOffsetInBits.len);
3763         if (retval < 0)
3764                 return retval;
3765
3766         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3767                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3768                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
3769         else
3770                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3771                                                 ut_params->op);
3772         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3773
3774         ut_params->obuf = ut_params->op->sym->m_dst;
3775
3776         if (ut_params->obuf)
3777                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3778                                 plaintext_len, buffer);
3779         else
3780                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3781                                 tdata->validCipherOffsetInBits.len >> 3,
3782                                 plaintext_len, buffer);
3783
3784         /* Validate obuf */
3785         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3786
3787         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3788                                 (tdata->validCipherOffsetInBits.len >> 3);
3789         /* Validate obuf */
3790         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3791                 ciphertext,
3792                 reference_ciphertext,
3793                 tdata->validCipherLenInBits.len,
3794                 "KASUMI Ciphertext data not as expected");
3795         return 0;
3796 }
3797
3798 static int
3799 test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
3800 {
3801         struct crypto_testsuite_params *ts_params = &testsuite_params;
3802         struct crypto_unittest_params *ut_params = &unittest_params;
3803
3804         int retval;
3805         uint8_t *plaintext, *ciphertext;
3806         unsigned plaintext_pad_len;
3807         unsigned plaintext_len;
3808
3809         /* Verify the capabilities */
3810         struct rte_cryptodev_sym_capability_idx cap_idx;
3811         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3812         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3813         /* Data-path service does not support OOP */
3814         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3815                         &cap_idx) == NULL)
3816                 return TEST_SKIPPED;
3817
3818         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3819                 return TEST_SKIPPED;
3820
3821         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3822                 return TEST_SKIPPED;
3823
3824         /* Create KASUMI session */
3825         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3826                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3827                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3828                                         tdata->key.data, tdata->key.len,
3829                                         tdata->cipher_iv.len);
3830         if (retval < 0)
3831                 return retval;
3832
3833         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3834         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3835
3836         /* Clear mbuf payload */
3837         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3838                rte_pktmbuf_tailroom(ut_params->ibuf));
3839
3840         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3841         /* Append data which is padded to a multiple */
3842         /* of the algorithms block size */
3843         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3844         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3845                                 plaintext_pad_len);
3846         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3847         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3848
3849         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3850
3851         /* Create KASUMI operation */
3852         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3853                                 tdata->cipher_iv.len,
3854                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3855                                 tdata->validCipherOffsetInBits.len);
3856         if (retval < 0)
3857                 return retval;
3858
3859         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3860                                                 ut_params->op);
3861         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3862
3863         ut_params->obuf = ut_params->op->sym->m_dst;
3864         if (ut_params->obuf)
3865                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3866         else
3867                 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3868
3869         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3870
3871         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3872                                 (tdata->validCipherOffsetInBits.len >> 3);
3873         /* Validate obuf */
3874         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3875                 ciphertext,
3876                 reference_ciphertext,
3877                 tdata->validCipherLenInBits.len,
3878                 "KASUMI Ciphertext data not as expected");
3879         return 0;
3880 }
3881
3882 static int
3883 test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
3884 {
3885         struct crypto_testsuite_params *ts_params = &testsuite_params;
3886         struct crypto_unittest_params *ut_params = &unittest_params;
3887
3888         int retval;
3889         unsigned int plaintext_pad_len;
3890         unsigned int plaintext_len;
3891
3892         const uint8_t *ciphertext;
3893         uint8_t buffer[2048];
3894
3895         struct rte_cryptodev_info dev_info;
3896
3897         /* Verify the capabilities */
3898         struct rte_cryptodev_sym_capability_idx cap_idx;
3899         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3900         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3901         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3902                         &cap_idx) == NULL)
3903                 return TEST_SKIPPED;
3904
3905         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3906                 return TEST_SKIPPED;
3907
3908         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3909                 return TEST_SKIPPED;
3910
3911         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3912
3913         uint64_t feat_flags = dev_info.feature_flags;
3914         if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
3915                 printf("Device doesn't support out-of-place scatter-gather "
3916                                 "in both input and output mbufs. "
3917                                 "Test Skipped.\n");
3918                 return TEST_SKIPPED;
3919         }
3920
3921         /* Create KASUMI session */
3922         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3923                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3924                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3925                                         tdata->key.data, tdata->key.len,
3926                                         tdata->cipher_iv.len);
3927         if (retval < 0)
3928                 return retval;
3929
3930         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3931         /* Append data which is padded to a multiple */
3932         /* of the algorithms block size */
3933         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3934
3935         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3936                         plaintext_pad_len, 10, 0);
3937         ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
3938                         plaintext_pad_len, 3, 0);
3939
3940         /* Append data which is padded to a multiple */
3941         /* of the algorithms block size */
3942         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3943
3944         /* Create KASUMI operation */
3945         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3946                                 tdata->cipher_iv.len,
3947                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3948                                 tdata->validCipherOffsetInBits.len);
3949         if (retval < 0)
3950                 return retval;
3951
3952         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3953                                                 ut_params->op);
3954         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3955
3956         ut_params->obuf = ut_params->op->sym->m_dst;
3957         if (ut_params->obuf)
3958                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3959                                 plaintext_pad_len, buffer);
3960         else
3961                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3962                                 tdata->validCipherOffsetInBits.len >> 3,
3963                                 plaintext_pad_len, buffer);
3964
3965         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3966                                 (tdata->validCipherOffsetInBits.len >> 3);
3967         /* Validate obuf */
3968         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3969                 ciphertext,
3970                 reference_ciphertext,
3971                 tdata->validCipherLenInBits.len,
3972                 "KASUMI Ciphertext data not as expected");
3973         return 0;
3974 }
3975
3976
3977 static int
3978 test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
3979 {
3980         struct crypto_testsuite_params *ts_params = &testsuite_params;
3981         struct crypto_unittest_params *ut_params = &unittest_params;
3982
3983         int retval;
3984         uint8_t *ciphertext, *plaintext;
3985         unsigned ciphertext_pad_len;
3986         unsigned ciphertext_len;
3987
3988         /* Verify the capabilities */
3989         struct rte_cryptodev_sym_capability_idx cap_idx;
3990         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3991         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3992         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3993                         &cap_idx) == NULL)
3994                 return TEST_SKIPPED;
3995
3996         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3997                 return TEST_SKIPPED;
3998
3999         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4000                 return TEST_SKIPPED;
4001
4002         /* Create KASUMI session */
4003         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4004                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4005                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
4006                                         tdata->key.data, tdata->key.len,
4007                                         tdata->cipher_iv.len);
4008         if (retval < 0)
4009                 return retval;
4010
4011         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4012         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4013
4014         /* Clear mbuf payload */
4015         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4016                rte_pktmbuf_tailroom(ut_params->ibuf));
4017
4018         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4019         /* Append data which is padded to a multiple */
4020         /* of the algorithms block size */
4021         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
4022         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4023                                 ciphertext_pad_len);
4024         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4025         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4026
4027         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4028
4029         /* Create KASUMI operation */
4030         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4031                                 tdata->cipher_iv.len,
4032                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
4033                                 tdata->validCipherOffsetInBits.len);
4034         if (retval < 0)
4035                 return retval;
4036
4037         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4038                                                 ut_params->op);
4039         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4040
4041         ut_params->obuf = ut_params->op->sym->m_dst;
4042         if (ut_params->obuf)
4043                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4044         else
4045                 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
4046
4047         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4048
4049         const uint8_t *reference_plaintext = tdata->plaintext.data +
4050                                 (tdata->validCipherOffsetInBits.len >> 3);
4051         /* Validate obuf */
4052         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4053                 plaintext,
4054                 reference_plaintext,
4055                 tdata->validCipherLenInBits.len,
4056                 "KASUMI Plaintext data not as expected");
4057         return 0;
4058 }
4059
4060 static int
4061 test_kasumi_decryption(const struct kasumi_test_data *tdata)
4062 {
4063         struct crypto_testsuite_params *ts_params = &testsuite_params;
4064         struct crypto_unittest_params *ut_params = &unittest_params;
4065
4066         int retval;
4067         uint8_t *ciphertext, *plaintext;
4068         unsigned ciphertext_pad_len;
4069         unsigned ciphertext_len;
4070         struct rte_cryptodev_info dev_info;
4071
4072         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4073         uint64_t feat_flags = dev_info.feature_flags;
4074
4075         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4076                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4077                 printf("Device doesn't support RAW data-path APIs.\n");
4078                 return TEST_SKIPPED;
4079         }
4080
4081         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4082                 return TEST_SKIPPED;
4083
4084         /* Verify the capabilities */
4085         struct rte_cryptodev_sym_capability_idx cap_idx;
4086         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4087         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
4088         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4089                         &cap_idx) == NULL)
4090                 return TEST_SKIPPED;
4091
4092         /* Create KASUMI session */
4093         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4094                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4095                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
4096                                         tdata->key.data, tdata->key.len,
4097                                         tdata->cipher_iv.len);
4098         if (retval < 0)
4099                 return retval;
4100
4101         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4102
4103         /* Clear mbuf payload */
4104         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4105                rte_pktmbuf_tailroom(ut_params->ibuf));
4106
4107         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4108         /* Append data which is padded to a multiple */
4109         /* of the algorithms block size */
4110         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
4111         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4112                                 ciphertext_pad_len);
4113         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4114
4115         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4116
4117         /* Create KASUMI operation */
4118         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4119                         tdata->cipher_iv.len,
4120                         RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
4121                         tdata->validCipherOffsetInBits.len);
4122         if (retval < 0)
4123                 return retval;
4124
4125         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4126                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4127                                 ut_params->op, 1, 0, 1, 0);
4128         else
4129                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4130                                                 ut_params->op);
4131         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4132
4133         ut_params->obuf = ut_params->op->sym->m_dst;
4134         if (ut_params->obuf)
4135                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4136         else
4137                 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
4138
4139         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4140
4141         const uint8_t *reference_plaintext = tdata->plaintext.data +
4142                                 (tdata->validCipherOffsetInBits.len >> 3);
4143         /* Validate obuf */
4144         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4145                 plaintext,
4146                 reference_plaintext,
4147                 tdata->validCipherLenInBits.len,
4148                 "KASUMI Plaintext data not as expected");
4149         return 0;
4150 }
4151
4152 static int
4153 test_snow3g_encryption(const struct snow3g_test_data *tdata)
4154 {
4155         struct crypto_testsuite_params *ts_params = &testsuite_params;
4156         struct crypto_unittest_params *ut_params = &unittest_params;
4157
4158         int retval;
4159         uint8_t *plaintext, *ciphertext;
4160         unsigned plaintext_pad_len;
4161         unsigned plaintext_len;
4162         struct rte_cryptodev_info dev_info;
4163
4164         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4165         uint64_t feat_flags = dev_info.feature_flags;
4166
4167         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4168                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4169                 printf("Device doesn't support RAW data-path APIs.\n");
4170                 return TEST_SKIPPED;
4171         }
4172
4173         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4174                 return TEST_SKIPPED;
4175
4176         /* Verify the capabilities */
4177         struct rte_cryptodev_sym_capability_idx cap_idx;
4178         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4179         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4180         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4181                         &cap_idx) == NULL)
4182                 return TEST_SKIPPED;
4183
4184         /* Create SNOW 3G session */
4185         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4186                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4187                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4188                                         tdata->key.data, tdata->key.len,
4189                                         tdata->cipher_iv.len);
4190         if (retval < 0)
4191                 return retval;
4192
4193         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4194
4195         /* Clear mbuf payload */
4196         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4197                rte_pktmbuf_tailroom(ut_params->ibuf));
4198
4199         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4200         /* Append data which is padded to a multiple of */
4201         /* the algorithms block size */
4202         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4203         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4204                                 plaintext_pad_len);
4205         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4206
4207         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4208
4209         /* Create SNOW 3G operation */
4210         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4211                                         tdata->cipher_iv.len,
4212                                         tdata->validCipherLenInBits.len,
4213                                         0);
4214         if (retval < 0)
4215                 return retval;
4216
4217         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4218                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4219                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4220         else
4221                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4222                                                 ut_params->op);
4223         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4224
4225         ut_params->obuf = ut_params->op->sym->m_dst;
4226         if (ut_params->obuf)
4227                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4228         else
4229                 ciphertext = plaintext;
4230
4231         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4232
4233         /* Validate obuf */
4234         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4235                 ciphertext,
4236                 tdata->ciphertext.data,
4237                 tdata->validDataLenInBits.len,
4238                 "SNOW 3G Ciphertext data not as expected");
4239         return 0;
4240 }
4241
4242
4243 static int
4244 test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
4245 {
4246         struct crypto_testsuite_params *ts_params = &testsuite_params;
4247         struct crypto_unittest_params *ut_params = &unittest_params;
4248         uint8_t *plaintext, *ciphertext;
4249
4250         int retval;
4251         unsigned plaintext_pad_len;
4252         unsigned plaintext_len;
4253         struct rte_cryptodev_info dev_info;
4254
4255         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4256         uint64_t feat_flags = dev_info.feature_flags;
4257
4258         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4259                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4260                 printf("Device does not support RAW data-path APIs.\n");
4261                 return -ENOTSUP;
4262         }
4263
4264         /* Verify the capabilities */
4265         struct rte_cryptodev_sym_capability_idx cap_idx;
4266         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4267         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4268         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4269                         &cap_idx) == NULL)
4270                 return TEST_SKIPPED;
4271
4272         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4273                 return TEST_SKIPPED;
4274
4275         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4276                 return TEST_SKIPPED;
4277
4278         /* Create SNOW 3G session */
4279         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4280                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4281                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4282                                         tdata->key.data, tdata->key.len,
4283                                         tdata->cipher_iv.len);
4284         if (retval < 0)
4285                 return retval;
4286
4287         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4288         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4289
4290         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4291                         "Failed to allocate input buffer in mempool");
4292         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4293                         "Failed to allocate output buffer in mempool");
4294
4295         /* Clear mbuf payload */
4296         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4297                rte_pktmbuf_tailroom(ut_params->ibuf));
4298
4299         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4300         /* Append data which is padded to a multiple of */
4301         /* the algorithms block size */
4302         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4303         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4304                                 plaintext_pad_len);
4305         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4306         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4307
4308         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4309
4310         /* Create SNOW 3G operation */
4311         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4312                                         tdata->cipher_iv.len,
4313                                         tdata->validCipherLenInBits.len,
4314                                         0);
4315         if (retval < 0)
4316                 return retval;
4317
4318         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4319                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4320                         ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4321         else
4322                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4323                                                 ut_params->op);
4324         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4325
4326         ut_params->obuf = ut_params->op->sym->m_dst;
4327         if (ut_params->obuf)
4328                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4329         else
4330                 ciphertext = plaintext;
4331
4332         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4333
4334         /* Validate obuf */
4335         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4336                 ciphertext,
4337                 tdata->ciphertext.data,
4338                 tdata->validDataLenInBits.len,
4339                 "SNOW 3G Ciphertext data not as expected");
4340         return 0;
4341 }
4342
4343 static int
4344 test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
4345 {
4346         struct crypto_testsuite_params *ts_params = &testsuite_params;
4347         struct crypto_unittest_params *ut_params = &unittest_params;
4348
4349         int retval;
4350         unsigned int plaintext_pad_len;
4351         unsigned int plaintext_len;
4352         uint8_t buffer[10000];
4353         const uint8_t *ciphertext;
4354
4355         struct rte_cryptodev_info dev_info;
4356
4357         /* Verify the capabilities */
4358         struct rte_cryptodev_sym_capability_idx cap_idx;
4359         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4360         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4361         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4362                         &cap_idx) == NULL)
4363                 return TEST_SKIPPED;
4364
4365         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4366                 return TEST_SKIPPED;
4367
4368         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4369                 return TEST_SKIPPED;
4370
4371         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4372
4373         uint64_t feat_flags = dev_info.feature_flags;
4374
4375         if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
4376                 printf("Device doesn't support out-of-place scatter-gather "
4377                                 "in both input and output mbufs. "
4378                                 "Test Skipped.\n");
4379                 return TEST_SKIPPED;
4380         }
4381
4382         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4383                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4384                 printf("Device does not support RAW data-path APIs.\n");
4385                 return -ENOTSUP;
4386         }
4387
4388         /* Create SNOW 3G session */
4389         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4390                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4391                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4392                                         tdata->key.data, tdata->key.len,
4393                                         tdata->cipher_iv.len);
4394         if (retval < 0)
4395                 return retval;
4396
4397         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4398         /* Append data which is padded to a multiple of */
4399         /* the algorithms block size */
4400         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4401
4402         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
4403                         plaintext_pad_len, 10, 0);
4404         ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
4405                         plaintext_pad_len, 3, 0);
4406
4407         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4408                         "Failed to allocate input buffer in mempool");
4409         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4410                         "Failed to allocate output buffer in mempool");
4411
4412         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
4413
4414         /* Create SNOW 3G operation */
4415         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4416                                         tdata->cipher_iv.len,
4417                                         tdata->validCipherLenInBits.len,
4418                                         0);
4419         if (retval < 0)
4420                 return retval;
4421
4422         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4423                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4424                         ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4425         else
4426                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4427                                                 ut_params->op);
4428         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4429
4430         ut_params->obuf = ut_params->op->sym->m_dst;
4431         if (ut_params->obuf)
4432                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
4433                                 plaintext_len, buffer);
4434         else
4435                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
4436                                 plaintext_len, buffer);
4437
4438         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4439
4440         /* Validate obuf */
4441         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4442                 ciphertext,
4443                 tdata->ciphertext.data,
4444                 tdata->validDataLenInBits.len,
4445                 "SNOW 3G Ciphertext data not as expected");
4446
4447         return 0;
4448 }
4449
4450 /* Shift right a buffer by "offset" bits, "offset" < 8 */
4451 static void
4452 buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset)
4453 {
4454         uint8_t curr_byte, prev_byte;
4455         uint32_t length_in_bytes = ceil_byte_length(length + offset);
4456         uint8_t lower_byte_mask = (1 << offset) - 1;
4457         unsigned i;
4458
4459         prev_byte = buffer[0];
4460         buffer[0] >>= offset;
4461
4462         for (i = 1; i < length_in_bytes; i++) {
4463                 curr_byte = buffer[i];
4464                 buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) |
4465                                 (curr_byte >> offset);
4466                 prev_byte = curr_byte;
4467         }
4468 }
4469
4470 static int
4471 test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
4472 {
4473         struct crypto_testsuite_params *ts_params = &testsuite_params;
4474         struct crypto_unittest_params *ut_params = &unittest_params;
4475         uint8_t *plaintext, *ciphertext;
4476         int retval;
4477         uint32_t plaintext_len;
4478         uint32_t plaintext_pad_len;
4479         uint8_t extra_offset = 4;
4480         uint8_t *expected_ciphertext_shifted;
4481         struct rte_cryptodev_info dev_info;
4482
4483         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4484         uint64_t feat_flags = dev_info.feature_flags;
4485
4486         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
4487                         ((tdata->validDataLenInBits.len % 8) != 0)) {
4488                 printf("Device doesn't support NON-Byte Aligned Data.\n");
4489                 return TEST_SKIPPED;
4490         }
4491
4492         /* Verify the capabilities */
4493         struct rte_cryptodev_sym_capability_idx cap_idx;
4494         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4495         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4496         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4497                         &cap_idx) == NULL)
4498                 return TEST_SKIPPED;
4499
4500         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4501                 return TEST_SKIPPED;
4502
4503         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4504                 return TEST_SKIPPED;
4505
4506         /* Create SNOW 3G session */
4507         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4508                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4509                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4510                                         tdata->key.data, tdata->key.len,
4511                                         tdata->cipher_iv.len);
4512         if (retval < 0)
4513                 return retval;
4514
4515         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4516         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4517
4518         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4519                         "Failed to allocate input buffer in mempool");
4520         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4521                         "Failed to allocate output buffer in mempool");
4522
4523         /* Clear mbuf payload */
4524         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4525                rte_pktmbuf_tailroom(ut_params->ibuf));
4526
4527         plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset);
4528         /*
4529          * Append data which is padded to a
4530          * multiple of the algorithms block size
4531          */
4532         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4533
4534         plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf,
4535                                                 plaintext_pad_len);
4536
4537         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4538
4539         memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3));
4540         buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset);
4541
4542 #ifdef RTE_APP_TEST_DEBUG
4543         rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
4544 #endif
4545         /* Create SNOW 3G operation */
4546         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4547                                         tdata->cipher_iv.len,
4548                                         tdata->validCipherLenInBits.len,
4549                                         extra_offset);
4550         if (retval < 0)
4551                 return retval;
4552
4553         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4554                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4555                         ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4556         else
4557                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4558                                                 ut_params->op);
4559         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4560
4561         ut_params->obuf = ut_params->op->sym->m_dst;
4562         if (ut_params->obuf)
4563                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4564         else
4565                 ciphertext = plaintext;
4566
4567 #ifdef RTE_APP_TEST_DEBUG
4568         rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4569 #endif
4570
4571         expected_ciphertext_shifted = rte_malloc(NULL, plaintext_len, 8);
4572
4573         TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted,
4574                         "failed to reserve memory for ciphertext shifted\n");
4575
4576         memcpy(expected_ciphertext_shifted, tdata->ciphertext.data,
4577                         ceil_byte_length(tdata->ciphertext.len));
4578         buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len,
4579                         extra_offset);
4580         /* Validate obuf */
4581         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
4582                 ciphertext,
4583                 expected_ciphertext_shifted,
4584                 tdata->validDataLenInBits.len,
4585                 extra_offset,
4586                 "SNOW 3G Ciphertext data not as expected");
4587         return 0;
4588 }
4589
4590 static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
4591 {
4592         struct crypto_testsuite_params *ts_params = &testsuite_params;
4593         struct crypto_unittest_params *ut_params = &unittest_params;
4594
4595         int retval;
4596
4597         uint8_t *plaintext, *ciphertext;
4598         unsigned ciphertext_pad_len;
4599         unsigned ciphertext_len;
4600         struct rte_cryptodev_info dev_info;
4601
4602         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4603         uint64_t feat_flags = dev_info.feature_flags;
4604
4605         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4606                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4607                 printf("Device doesn't support RAW data-path APIs.\n");
4608                 return TEST_SKIPPED;
4609         }
4610
4611         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4612                 return TEST_SKIPPED;
4613
4614         /* Verify the capabilities */
4615         struct rte_cryptodev_sym_capability_idx cap_idx;
4616         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4617         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4618         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4619                         &cap_idx) == NULL)
4620                 return TEST_SKIPPED;
4621
4622         /* Create SNOW 3G session */
4623         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4624                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4625                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4626                                         tdata->key.data, tdata->key.len,
4627                                         tdata->cipher_iv.len);
4628         if (retval < 0)
4629                 return retval;
4630
4631         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4632
4633         /* Clear mbuf payload */
4634         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4635                rte_pktmbuf_tailroom(ut_params->ibuf));
4636
4637         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4638         /* Append data which is padded to a multiple of */
4639         /* the algorithms block size */
4640         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4641         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4642                                 ciphertext_pad_len);
4643         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4644
4645         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4646
4647         /* Create SNOW 3G operation */
4648         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4649                                         tdata->cipher_iv.len,
4650                                         tdata->validCipherLenInBits.len,
4651                                         tdata->cipher.offset_bits);
4652         if (retval < 0)
4653                 return retval;
4654
4655         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4656                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4657                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4658         else
4659                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4660                                                 ut_params->op);
4661         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4662         ut_params->obuf = ut_params->op->sym->m_dst;
4663         if (ut_params->obuf)
4664                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4665         else
4666                 plaintext = ciphertext;
4667
4668         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4669
4670         /* Validate obuf */
4671         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4672                                 tdata->plaintext.data,
4673                                 tdata->validDataLenInBits.len,
4674                                 "SNOW 3G Plaintext data not as expected");
4675         return 0;
4676 }
4677
4678 static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
4679 {
4680         struct crypto_testsuite_params *ts_params = &testsuite_params;
4681         struct crypto_unittest_params *ut_params = &unittest_params;
4682
4683         int retval;
4684
4685         uint8_t *plaintext, *ciphertext;
4686         unsigned ciphertext_pad_len;
4687         unsigned ciphertext_len;
4688         struct rte_cryptodev_info dev_info;
4689
4690         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4691         uint64_t feat_flags = dev_info.feature_flags;
4692
4693         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4694                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4695                 printf("Device does not support RAW data-path APIs.\n");
4696                 return -ENOTSUP;
4697         }
4698         /* Verify the capabilities */
4699         struct rte_cryptodev_sym_capability_idx cap_idx;
4700         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4701         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4702         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4703                         &cap_idx) == NULL)
4704                 return TEST_SKIPPED;
4705
4706         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4707                 return TEST_SKIPPED;
4708
4709         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4710                 return TEST_SKIPPED;
4711
4712         /* Create SNOW 3G session */
4713         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4714                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4715                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4716                                         tdata->key.data, tdata->key.len,
4717                                         tdata->cipher_iv.len);
4718         if (retval < 0)
4719                 return retval;
4720
4721         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4722         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4723
4724         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4725                         "Failed to allocate input buffer");
4726         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4727                         "Failed to allocate output buffer");
4728
4729         /* Clear mbuf payload */
4730         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4731                rte_pktmbuf_tailroom(ut_params->ibuf));
4732
4733         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
4734                        rte_pktmbuf_tailroom(ut_params->obuf));
4735
4736         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4737         /* Append data which is padded to a multiple of */
4738         /* the algorithms block size */
4739         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4740         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4741                                 ciphertext_pad_len);
4742         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4743         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4744
4745         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4746
4747         /* Create SNOW 3G operation */
4748         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4749                                         tdata->cipher_iv.len,
4750                                         tdata->validCipherLenInBits.len,
4751                                         0);
4752         if (retval < 0)
4753                 return retval;
4754
4755         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4756                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4757                         ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4758         else
4759                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4760                                                 ut_params->op);
4761         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4762         ut_params->obuf = ut_params->op->sym->m_dst;
4763         if (ut_params->obuf)
4764                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4765         else
4766                 plaintext = ciphertext;
4767
4768         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4769
4770         /* Validate obuf */
4771         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4772                                 tdata->plaintext.data,
4773                                 tdata->validDataLenInBits.len,
4774                                 "SNOW 3G Plaintext data not as expected");
4775         return 0;
4776 }
4777
4778 static int
4779 test_zuc_cipher_auth(const struct wireless_test_data *tdata)
4780 {
4781         struct crypto_testsuite_params *ts_params = &testsuite_params;
4782         struct crypto_unittest_params *ut_params = &unittest_params;
4783
4784         int retval;
4785
4786         uint8_t *plaintext, *ciphertext;
4787         unsigned int plaintext_pad_len;
4788         unsigned int plaintext_len;
4789
4790         struct rte_cryptodev_info dev_info;
4791         struct rte_cryptodev_sym_capability_idx cap_idx;
4792
4793         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4794         uint64_t feat_flags = dev_info.feature_flags;
4795
4796         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
4797                         ((tdata->validAuthLenInBits.len % 8 != 0) ||
4798                         (tdata->validDataLenInBits.len % 8 != 0))) {
4799                 printf("Device doesn't support NON-Byte Aligned Data.\n");
4800                 return TEST_SKIPPED;
4801         }
4802
4803         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4804                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4805                 printf("Device doesn't support RAW data-path APIs.\n");
4806                 return TEST_SKIPPED;
4807         }
4808
4809         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4810                 return TEST_SKIPPED;
4811
4812         /* Check if device supports ZUC EEA3 */
4813         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4814         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
4815
4816         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4817                         &cap_idx) == NULL)
4818                 return TEST_SKIPPED;
4819
4820         /* Check if device supports ZUC EIA3 */
4821         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4822         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
4823
4824         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4825                         &cap_idx) == NULL)
4826                 return TEST_SKIPPED;
4827
4828         /* Create ZUC session */
4829         retval = create_zuc_cipher_auth_encrypt_generate_session(
4830                         ts_params->valid_devs[0],
4831                         tdata);
4832         if (retval != 0)
4833                 return retval;
4834         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4835
4836         /* clear mbuf payload */
4837         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4838                         rte_pktmbuf_tailroom(ut_params->ibuf));
4839
4840         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4841         /* Append data which is padded to a multiple of */
4842         /* the algorithms block size */
4843         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4844         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4845                                 plaintext_pad_len);
4846         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4847
4848         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4849
4850         /* Create ZUC operation */
4851         retval = create_zuc_cipher_hash_generate_operation(tdata);
4852         if (retval < 0)
4853                 return retval;
4854
4855         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4856                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4857                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4858         else
4859                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4860                         ut_params->op);
4861         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4862         ut_params->obuf = ut_params->op->sym->m_src;
4863         if (ut_params->obuf)
4864                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4865         else
4866                 ciphertext = plaintext;
4867
4868         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4869         /* Validate obuf */
4870         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4871                         ciphertext,
4872                         tdata->ciphertext.data,
4873                         tdata->validDataLenInBits.len,
4874                         "ZUC Ciphertext data not as expected");
4875
4876         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4877             + plaintext_pad_len;
4878
4879         /* Validate obuf */
4880         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4881                         ut_params->digest,
4882                         tdata->digest.data,
4883                         4,
4884                         "ZUC Generated auth tag not as expected");
4885         return 0;
4886 }
4887
4888 static int
4889 test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
4890 {
4891         struct crypto_testsuite_params *ts_params = &testsuite_params;
4892         struct crypto_unittest_params *ut_params = &unittest_params;
4893
4894         int retval;
4895
4896         uint8_t *plaintext, *ciphertext;
4897         unsigned plaintext_pad_len;
4898         unsigned plaintext_len;
4899         struct rte_cryptodev_info dev_info;
4900
4901         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4902         uint64_t feat_flags = dev_info.feature_flags;
4903
4904         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4905                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4906                 printf("Device doesn't support RAW data-path APIs.\n");
4907                 return TEST_SKIPPED;
4908         }
4909
4910         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4911                 return TEST_SKIPPED;
4912
4913         /* Verify the capabilities */
4914         struct rte_cryptodev_sym_capability_idx cap_idx;
4915         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4916         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
4917         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4918                         &cap_idx) == NULL)
4919                 return TEST_SKIPPED;
4920         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4921         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4922         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4923                         &cap_idx) == NULL)
4924                 return TEST_SKIPPED;
4925
4926         /* Create SNOW 3G session */
4927         retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0],
4928                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4929                         RTE_CRYPTO_AUTH_OP_GENERATE,
4930                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4931                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4932                         tdata->key.data, tdata->key.len,
4933                         tdata->auth_iv.len, tdata->digest.len,
4934                         tdata->cipher_iv.len);
4935         if (retval != 0)
4936                 return retval;
4937         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4938
4939         /* clear mbuf payload */
4940         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4941                         rte_pktmbuf_tailroom(ut_params->ibuf));
4942
4943         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4944         /* Append data which is padded to a multiple of */
4945         /* the algorithms block size */
4946         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4947         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4948                                 plaintext_pad_len);
4949         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4950
4951         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4952
4953         /* Create SNOW 3G operation */
4954         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
4955                         tdata->digest.len, tdata->auth_iv.data,
4956                         tdata->auth_iv.len,
4957                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
4958                         tdata->cipher_iv.data, tdata->cipher_iv.len,
4959                         tdata->validCipherLenInBits.len,
4960                         0,
4961                         tdata->validAuthLenInBits.len,
4962                         0
4963                         );
4964         if (retval < 0)
4965                 return retval;
4966
4967         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4968                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4969                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4970         else
4971                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4972                         ut_params->op);
4973         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4974         ut_params->obuf = ut_params->op->sym->m_src;
4975         if (ut_params->obuf)
4976                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4977         else
4978                 ciphertext = plaintext;
4979
4980         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4981         /* Validate obuf */
4982         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4983                         ciphertext,
4984                         tdata->ciphertext.data,
4985                         tdata->validDataLenInBits.len,
4986                         "SNOW 3G Ciphertext data not as expected");
4987
4988         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4989             + plaintext_pad_len;
4990
4991         /* Validate obuf */
4992         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4993                         ut_params->digest,
4994                         tdata->digest.data,
4995                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4996                         "SNOW 3G Generated auth tag not as expected");
4997         return 0;
4998 }
4999
5000 static int
5001 test_snow3g_auth_cipher(const struct snow3g_test_data *tdata,
5002         uint8_t op_mode, uint8_t verify)
5003 {
5004         struct crypto_testsuite_params *ts_params = &testsuite_params;
5005         struct crypto_unittest_params *ut_params = &unittest_params;
5006
5007         int retval;
5008
5009         uint8_t *plaintext = NULL, *ciphertext = NULL;
5010         unsigned int plaintext_pad_len;
5011         unsigned int plaintext_len;
5012         unsigned int ciphertext_pad_len;
5013         unsigned int ciphertext_len;
5014
5015         struct rte_cryptodev_info dev_info;
5016
5017         /* Verify the capabilities */
5018         struct rte_cryptodev_sym_capability_idx cap_idx;
5019         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5020         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
5021         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5022                         &cap_idx) == NULL)
5023                 return TEST_SKIPPED;
5024         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5025         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
5026         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5027                         &cap_idx) == NULL)
5028                 return TEST_SKIPPED;
5029
5030         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5031                 return TEST_SKIPPED;
5032
5033         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5034
5035         uint64_t feat_flags = dev_info.feature_flags;
5036
5037         if (op_mode == OUT_OF_PLACE) {
5038                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5039                         printf("Device doesn't support digest encrypted.\n");
5040                         return TEST_SKIPPED;
5041                 }
5042                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5043                         return TEST_SKIPPED;
5044         }
5045
5046         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5047                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5048                 printf("Device doesn't support RAW data-path APIs.\n");
5049                 return TEST_SKIPPED;
5050         }
5051
5052         /* Create SNOW 3G session */
5053         retval = create_wireless_algo_auth_cipher_session(
5054                         ts_params->valid_devs[0],
5055                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5056                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5057                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5058                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5059                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
5060                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
5061                         tdata->key.data, tdata->key.len,
5062                         tdata->auth_iv.len, tdata->digest.len,
5063                         tdata->cipher_iv.len);
5064         if (retval != 0)
5065                 return retval;
5066
5067         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5068         if (op_mode == OUT_OF_PLACE)
5069                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5070
5071         /* clear mbuf payload */
5072         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5073                 rte_pktmbuf_tailroom(ut_params->ibuf));
5074         if (op_mode == OUT_OF_PLACE)
5075                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5076                         rte_pktmbuf_tailroom(ut_params->obuf));
5077
5078         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5079         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5080         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5081         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5082
5083         if (verify) {
5084                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5085                                         ciphertext_pad_len);
5086                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
5087                 if (op_mode == OUT_OF_PLACE)
5088                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
5089                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5090                         ciphertext_len);
5091         } else {
5092                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5093                                         plaintext_pad_len);
5094                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5095                 if (op_mode == OUT_OF_PLACE)
5096                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
5097                 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5098         }
5099
5100         /* Create SNOW 3G operation */
5101         retval = create_wireless_algo_auth_cipher_operation(
5102                 tdata->digest.data, tdata->digest.len,
5103                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5104                 tdata->auth_iv.data, tdata->auth_iv.len,
5105                 (tdata->digest.offset_bytes == 0 ?
5106                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5107                         : tdata->digest.offset_bytes),
5108                 tdata->validCipherLenInBits.len,
5109                 tdata->cipher.offset_bits,
5110                 tdata->validAuthLenInBits.len,
5111                 tdata->auth.offset_bits,
5112                 op_mode, 0, verify);
5113
5114         if (retval < 0)
5115                 return retval;
5116
5117         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5118                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5119                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5120         else
5121                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5122                         ut_params->op);
5123
5124         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5125
5126         ut_params->obuf = (op_mode == IN_PLACE ?
5127                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5128
5129         if (verify) {
5130                 if (ut_params->obuf)
5131                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5132                                                         uint8_t *);
5133                 else
5134                         plaintext = ciphertext +
5135                                 (tdata->cipher.offset_bits >> 3);
5136
5137                 debug_hexdump(stdout, "plaintext:", plaintext,
5138                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5139                 debug_hexdump(stdout, "plaintext expected:",
5140                         tdata->plaintext.data,
5141                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5142         } else {
5143                 if (ut_params->obuf)
5144                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5145                                                         uint8_t *);
5146                 else
5147                         ciphertext = plaintext;
5148
5149                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5150                         ciphertext_len);
5151                 debug_hexdump(stdout, "ciphertext expected:",
5152                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5153
5154                 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5155                         + (tdata->digest.offset_bytes == 0 ?
5156                 plaintext_pad_len : tdata->digest.offset_bytes);
5157
5158                 debug_hexdump(stdout, "digest:", ut_params->digest,
5159                         tdata->digest.len);
5160                 debug_hexdump(stdout, "digest expected:", tdata->digest.data,
5161                                 tdata->digest.len);
5162         }
5163
5164         /* Validate obuf */
5165         if (verify) {
5166                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5167                         plaintext,
5168                         tdata->plaintext.data,
5169                         (tdata->plaintext.len - tdata->cipher.offset_bits -
5170                          (tdata->digest.len << 3)),
5171                         tdata->cipher.offset_bits,
5172                         "SNOW 3G Plaintext data not as expected");
5173         } else {
5174                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5175                         ciphertext,
5176                         tdata->ciphertext.data,
5177                         (tdata->validDataLenInBits.len -
5178                          tdata->cipher.offset_bits),
5179                         tdata->cipher.offset_bits,
5180                         "SNOW 3G Ciphertext data not as expected");
5181
5182                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5183                         ut_params->digest,
5184                         tdata->digest.data,
5185                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5186                         "SNOW 3G Generated auth tag not as expected");
5187         }
5188         return 0;
5189 }
5190
5191 static int
5192 test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata,
5193         uint8_t op_mode, uint8_t verify)
5194 {
5195         struct crypto_testsuite_params *ts_params = &testsuite_params;
5196         struct crypto_unittest_params *ut_params = &unittest_params;
5197
5198         int retval;
5199
5200         const uint8_t *plaintext = NULL;
5201         const uint8_t *ciphertext = NULL;
5202         const uint8_t *digest = NULL;
5203         unsigned int plaintext_pad_len;
5204         unsigned int plaintext_len;
5205         unsigned int ciphertext_pad_len;
5206         unsigned int ciphertext_len;
5207         uint8_t buffer[10000];
5208         uint8_t digest_buffer[10000];
5209
5210         struct rte_cryptodev_info dev_info;
5211
5212         /* Verify the capabilities */
5213         struct rte_cryptodev_sym_capability_idx cap_idx;
5214         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5215         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
5216         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5217                         &cap_idx) == NULL)
5218                 return TEST_SKIPPED;
5219         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5220         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
5221         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5222                         &cap_idx) == NULL)
5223                 return TEST_SKIPPED;
5224
5225         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5226                 return TEST_SKIPPED;
5227
5228         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5229
5230         uint64_t feat_flags = dev_info.feature_flags;
5231
5232         if (op_mode == IN_PLACE) {
5233                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5234                         printf("Device doesn't support in-place scatter-gather "
5235                                         "in both input and output mbufs.\n");
5236                         return TEST_SKIPPED;
5237                 }
5238                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5239                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5240                         printf("Device doesn't support RAW data-path APIs.\n");
5241                         return TEST_SKIPPED;
5242                 }
5243         } else {
5244                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5245                         return TEST_SKIPPED;
5246                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5247                         printf("Device doesn't support out-of-place scatter-gather "
5248                                         "in both input and output mbufs.\n");
5249                         return TEST_SKIPPED;
5250                 }
5251                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5252                         printf("Device doesn't support digest encrypted.\n");
5253                         return TEST_SKIPPED;
5254                 }
5255         }
5256
5257         /* Create SNOW 3G session */
5258         retval = create_wireless_algo_auth_cipher_session(
5259                         ts_params->valid_devs[0],
5260                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5261                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5262                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5263                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5264                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
5265                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
5266                         tdata->key.data, tdata->key.len,
5267                         tdata->auth_iv.len, tdata->digest.len,
5268                         tdata->cipher_iv.len);
5269
5270         if (retval != 0)
5271                 return retval;
5272
5273         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5274         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5275         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5276         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5277
5278         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5279                         plaintext_pad_len, 15, 0);
5280         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5281                         "Failed to allocate input buffer in mempool");
5282
5283         if (op_mode == OUT_OF_PLACE) {
5284                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5285                                 plaintext_pad_len, 15, 0);
5286                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5287                                 "Failed to allocate output buffer in mempool");
5288         }
5289
5290         if (verify) {
5291                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
5292                         tdata->ciphertext.data);
5293                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5294                                         ciphertext_len, buffer);
5295                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5296                         ciphertext_len);
5297         } else {
5298                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5299                         tdata->plaintext.data);
5300                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5301                                         plaintext_len, buffer);
5302                 debug_hexdump(stdout, "plaintext:", plaintext,
5303                         plaintext_len);
5304         }
5305         memset(buffer, 0, sizeof(buffer));
5306
5307         /* Create SNOW 3G operation */
5308         retval = create_wireless_algo_auth_cipher_operation(
5309                 tdata->digest.data, tdata->digest.len,
5310                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5311                 tdata->auth_iv.data, tdata->auth_iv.len,
5312                 (tdata->digest.offset_bytes == 0 ?
5313                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5314                         : tdata->digest.offset_bytes),
5315                 tdata->validCipherLenInBits.len,
5316                 tdata->cipher.offset_bits,
5317                 tdata->validAuthLenInBits.len,
5318                 tdata->auth.offset_bits,
5319                 op_mode, 1, verify);
5320
5321         if (retval < 0)
5322                 return retval;
5323
5324         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5325                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5326                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5327         else
5328                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5329                         ut_params->op);
5330
5331         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5332
5333         ut_params->obuf = (op_mode == IN_PLACE ?
5334                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5335
5336         if (verify) {
5337                 if (ut_params->obuf)
5338                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
5339                                         plaintext_len, buffer);
5340                 else
5341                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5342                                         plaintext_len, buffer);
5343
5344                 debug_hexdump(stdout, "plaintext:", plaintext,
5345                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5346                 debug_hexdump(stdout, "plaintext expected:",
5347                         tdata->plaintext.data,
5348                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5349         } else {
5350                 if (ut_params->obuf)
5351                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
5352                                         ciphertext_len, buffer);
5353                 else
5354                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5355                                         ciphertext_len, buffer);
5356
5357                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5358                         ciphertext_len);
5359                 debug_hexdump(stdout, "ciphertext expected:",
5360                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5361
5362                 if (ut_params->obuf)
5363                         digest = rte_pktmbuf_read(ut_params->obuf,
5364                                 (tdata->digest.offset_bytes == 0 ?
5365                                 plaintext_pad_len : tdata->digest.offset_bytes),
5366                                 tdata->digest.len, digest_buffer);
5367                 else
5368                         digest = rte_pktmbuf_read(ut_params->ibuf,
5369                                 (tdata->digest.offset_bytes == 0 ?
5370                                 plaintext_pad_len : tdata->digest.offset_bytes),
5371                                 tdata->digest.len, digest_buffer);
5372
5373                 debug_hexdump(stdout, "digest:", digest,
5374                         tdata->digest.len);
5375                 debug_hexdump(stdout, "digest expected:",
5376                         tdata->digest.data, tdata->digest.len);
5377         }
5378
5379         /* Validate obuf */
5380         if (verify) {
5381                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5382                         plaintext,
5383                         tdata->plaintext.data,
5384                         (tdata->plaintext.len - tdata->cipher.offset_bits -
5385                          (tdata->digest.len << 3)),
5386                         tdata->cipher.offset_bits,
5387                         "SNOW 3G Plaintext data not as expected");
5388         } else {
5389                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5390                         ciphertext,
5391                         tdata->ciphertext.data,
5392                         (tdata->validDataLenInBits.len -
5393                          tdata->cipher.offset_bits),
5394                         tdata->cipher.offset_bits,
5395                         "SNOW 3G Ciphertext data not as expected");
5396
5397                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5398                         digest,
5399                         tdata->digest.data,
5400                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5401                         "SNOW 3G Generated auth tag not as expected");
5402         }
5403         return 0;
5404 }
5405
5406 static int
5407 test_kasumi_auth_cipher(const struct kasumi_test_data *tdata,
5408         uint8_t op_mode, uint8_t verify)
5409 {
5410         struct crypto_testsuite_params *ts_params = &testsuite_params;
5411         struct crypto_unittest_params *ut_params = &unittest_params;
5412
5413         int retval;
5414
5415         uint8_t *plaintext = NULL, *ciphertext = NULL;
5416         unsigned int plaintext_pad_len;
5417         unsigned int plaintext_len;
5418         unsigned int ciphertext_pad_len;
5419         unsigned int ciphertext_len;
5420
5421         struct rte_cryptodev_info dev_info;
5422
5423         /* Verify the capabilities */
5424         struct rte_cryptodev_sym_capability_idx cap_idx;
5425         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5426         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5427         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5428                         &cap_idx) == NULL)
5429                 return TEST_SKIPPED;
5430         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5431         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5432         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5433                         &cap_idx) == NULL)
5434                 return TEST_SKIPPED;
5435
5436         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5437
5438         uint64_t feat_flags = dev_info.feature_flags;
5439
5440         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5441                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5442                 printf("Device doesn't support RAW data-path APIs.\n");
5443                 return TEST_SKIPPED;
5444         }
5445
5446         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5447                 return TEST_SKIPPED;
5448
5449         if (op_mode == OUT_OF_PLACE) {
5450                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5451                         return TEST_SKIPPED;
5452                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5453                         printf("Device doesn't support digest encrypted.\n");
5454                         return TEST_SKIPPED;
5455                 }
5456         }
5457
5458         /* Create KASUMI session */
5459         retval = create_wireless_algo_auth_cipher_session(
5460                         ts_params->valid_devs[0],
5461                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5462                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5463                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5464                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5465                         RTE_CRYPTO_AUTH_KASUMI_F9,
5466                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5467                         tdata->key.data, tdata->key.len,
5468                         0, tdata->digest.len,
5469                         tdata->cipher_iv.len);
5470
5471         if (retval != 0)
5472                 return retval;
5473
5474         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5475         if (op_mode == OUT_OF_PLACE)
5476                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5477
5478         /* clear mbuf payload */
5479         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5480                 rte_pktmbuf_tailroom(ut_params->ibuf));
5481         if (op_mode == OUT_OF_PLACE)
5482                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5483                         rte_pktmbuf_tailroom(ut_params->obuf));
5484
5485         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5486         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5487         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5488         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5489
5490         if (verify) {
5491                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5492                                         ciphertext_pad_len);
5493                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
5494                 if (op_mode == OUT_OF_PLACE)
5495                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
5496                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5497                         ciphertext_len);
5498         } else {
5499                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5500                                         plaintext_pad_len);
5501                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5502                 if (op_mode == OUT_OF_PLACE)
5503                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
5504                 debug_hexdump(stdout, "plaintext:", plaintext,
5505                         plaintext_len);
5506         }
5507
5508         /* Create KASUMI operation */
5509         retval = create_wireless_algo_auth_cipher_operation(
5510                 tdata->digest.data, tdata->digest.len,
5511                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5512                 NULL, 0,
5513                 (tdata->digest.offset_bytes == 0 ?
5514                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5515                         : tdata->digest.offset_bytes),
5516                 tdata->validCipherLenInBits.len,
5517                 tdata->validCipherOffsetInBits.len,
5518                 tdata->validAuthLenInBits.len,
5519                 0,
5520                 op_mode, 0, verify);
5521
5522         if (retval < 0)
5523                 return retval;
5524
5525         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5526                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5527                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5528         else
5529                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5530                         ut_params->op);
5531
5532         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5533
5534         ut_params->obuf = (op_mode == IN_PLACE ?
5535                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5536
5537
5538         if (verify) {
5539                 if (ut_params->obuf)
5540                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5541                                                         uint8_t *);
5542                 else
5543                         plaintext = ciphertext;
5544
5545                 debug_hexdump(stdout, "plaintext:", plaintext,
5546                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5547                 debug_hexdump(stdout, "plaintext expected:",
5548                         tdata->plaintext.data,
5549                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5550         } else {
5551                 if (ut_params->obuf)
5552                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5553                                                         uint8_t *);
5554                 else
5555                         ciphertext = plaintext;
5556
5557                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5558                         ciphertext_len);
5559                 debug_hexdump(stdout, "ciphertext expected:",
5560                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5561
5562                 ut_params->digest = rte_pktmbuf_mtod(
5563                         ut_params->obuf, uint8_t *) +
5564                         (tdata->digest.offset_bytes == 0 ?
5565                         plaintext_pad_len : tdata->digest.offset_bytes);
5566
5567                 debug_hexdump(stdout, "digest:", ut_params->digest,
5568                         tdata->digest.len);
5569                 debug_hexdump(stdout, "digest expected:",
5570                         tdata->digest.data, tdata->digest.len);
5571         }
5572
5573         /* Validate obuf */
5574         if (verify) {
5575                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5576                         plaintext,
5577                         tdata->plaintext.data,
5578                         tdata->plaintext.len >> 3,
5579                         "KASUMI Plaintext data not as expected");
5580         } else {
5581                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5582                         ciphertext,
5583                         tdata->ciphertext.data,
5584                         tdata->ciphertext.len >> 3,
5585                         "KASUMI Ciphertext data not as expected");
5586
5587                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5588                         ut_params->digest,
5589                         tdata->digest.data,
5590                         DIGEST_BYTE_LENGTH_KASUMI_F9,
5591                         "KASUMI Generated auth tag not as expected");
5592         }
5593         return 0;
5594 }
5595
5596 static int
5597 test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata,
5598         uint8_t op_mode, uint8_t verify)
5599 {
5600         struct crypto_testsuite_params *ts_params = &testsuite_params;
5601         struct crypto_unittest_params *ut_params = &unittest_params;
5602
5603         int retval;
5604
5605         const uint8_t *plaintext = NULL;
5606         const uint8_t *ciphertext = NULL;
5607         const uint8_t *digest = NULL;
5608         unsigned int plaintext_pad_len;
5609         unsigned int plaintext_len;
5610         unsigned int ciphertext_pad_len;
5611         unsigned int ciphertext_len;
5612         uint8_t buffer[10000];
5613         uint8_t digest_buffer[10000];
5614
5615         struct rte_cryptodev_info dev_info;
5616
5617         /* Verify the capabilities */
5618         struct rte_cryptodev_sym_capability_idx cap_idx;
5619         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5620         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5621         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5622                         &cap_idx) == NULL)
5623                 return TEST_SKIPPED;
5624         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5625         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5626         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5627                         &cap_idx) == NULL)
5628                 return TEST_SKIPPED;
5629
5630         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5631                 return TEST_SKIPPED;
5632
5633         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5634
5635         uint64_t feat_flags = dev_info.feature_flags;
5636
5637         if (op_mode == IN_PLACE) {
5638                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5639                         printf("Device doesn't support in-place scatter-gather "
5640                                         "in both input and output mbufs.\n");
5641                         return TEST_SKIPPED;
5642                 }
5643                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5644                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5645                         printf("Device doesn't support RAW data-path APIs.\n");
5646                         return TEST_SKIPPED;
5647                 }
5648         } else {
5649                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5650                         return TEST_SKIPPED;
5651                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5652                         printf("Device doesn't support out-of-place scatter-gather "
5653                                         "in both input and output mbufs.\n");
5654                         return TEST_SKIPPED;
5655                 }
5656                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5657                         printf("Device doesn't support digest encrypted.\n");
5658                         return TEST_SKIPPED;
5659                 }
5660         }
5661
5662         /* Create KASUMI session */
5663         retval = create_wireless_algo_auth_cipher_session(
5664                         ts_params->valid_devs[0],
5665                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5666                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5667                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5668                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5669                         RTE_CRYPTO_AUTH_KASUMI_F9,
5670                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5671                         tdata->key.data, tdata->key.len,
5672                         0, tdata->digest.len,
5673                         tdata->cipher_iv.len);
5674
5675         if (retval != 0)
5676                 return retval;
5677
5678         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5679         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5680         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5681         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5682
5683         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5684                         plaintext_pad_len, 15, 0);
5685         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5686                         "Failed to allocate input buffer in mempool");
5687
5688         if (op_mode == OUT_OF_PLACE) {
5689                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5690                                 plaintext_pad_len, 15, 0);
5691                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5692                                 "Failed to allocate output buffer in mempool");
5693         }
5694
5695         if (verify) {
5696                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
5697                         tdata->ciphertext.data);
5698                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5699                                         ciphertext_len, buffer);
5700                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5701                         ciphertext_len);
5702         } else {
5703                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5704                         tdata->plaintext.data);
5705                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5706                                         plaintext_len, buffer);
5707                 debug_hexdump(stdout, "plaintext:", plaintext,
5708                         plaintext_len);
5709         }
5710         memset(buffer, 0, sizeof(buffer));
5711
5712         /* Create KASUMI operation */
5713         retval = create_wireless_algo_auth_cipher_operation(
5714                 tdata->digest.data, tdata->digest.len,
5715                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5716                 NULL, 0,
5717                 (tdata->digest.offset_bytes == 0 ?
5718                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5719                         : tdata->digest.offset_bytes),
5720                 tdata->validCipherLenInBits.len,
5721                 tdata->validCipherOffsetInBits.len,
5722                 tdata->validAuthLenInBits.len,
5723                 0,
5724                 op_mode, 1, verify);
5725
5726         if (retval < 0)
5727                 return retval;
5728
5729         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5730                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5731                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5732         else
5733                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5734                         ut_params->op);
5735
5736         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5737
5738         ut_params->obuf = (op_mode == IN_PLACE ?
5739                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5740
5741         if (verify) {
5742                 if (ut_params->obuf)
5743                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
5744                                         plaintext_len, buffer);
5745                 else
5746                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5747                                         plaintext_len, buffer);
5748
5749                 debug_hexdump(stdout, "plaintext:", plaintext,
5750                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5751                 debug_hexdump(stdout, "plaintext expected:",
5752                         tdata->plaintext.data,
5753                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5754         } else {
5755                 if (ut_params->obuf)
5756                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
5757                                         ciphertext_len, buffer);
5758                 else
5759                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5760                                         ciphertext_len, buffer);
5761
5762                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5763                         ciphertext_len);
5764                 debug_hexdump(stdout, "ciphertext expected:",
5765                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5766
5767                 if (ut_params->obuf)
5768                         digest = rte_pktmbuf_read(ut_params->obuf,
5769                                 (tdata->digest.offset_bytes == 0 ?
5770                                 plaintext_pad_len : tdata->digest.offset_bytes),
5771                                 tdata->digest.len, digest_buffer);
5772                 else
5773                         digest = rte_pktmbuf_read(ut_params->ibuf,
5774                                 (tdata->digest.offset_bytes == 0 ?
5775                                 plaintext_pad_len : tdata->digest.offset_bytes),
5776                                 tdata->digest.len, digest_buffer);
5777
5778                 debug_hexdump(stdout, "digest:", digest,
5779                         tdata->digest.len);
5780                 debug_hexdump(stdout, "digest expected:",
5781                         tdata->digest.data, tdata->digest.len);
5782         }
5783
5784         /* Validate obuf */
5785         if (verify) {
5786                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5787                         plaintext,
5788                         tdata->plaintext.data,
5789                         tdata->plaintext.len >> 3,
5790                         "KASUMI Plaintext data not as expected");
5791         } else {
5792                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5793                         ciphertext,
5794                         tdata->ciphertext.data,
5795                         tdata->validDataLenInBits.len,
5796                         "KASUMI Ciphertext data not as expected");
5797
5798                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5799                         digest,
5800                         tdata->digest.data,
5801                         DIGEST_BYTE_LENGTH_KASUMI_F9,
5802                         "KASUMI Generated auth tag not as expected");
5803         }
5804         return 0;
5805 }
5806
5807 static int
5808 test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
5809 {
5810         struct crypto_testsuite_params *ts_params = &testsuite_params;
5811         struct crypto_unittest_params *ut_params = &unittest_params;
5812
5813         int retval;
5814
5815         uint8_t *plaintext, *ciphertext;
5816         unsigned plaintext_pad_len;
5817         unsigned plaintext_len;
5818         struct rte_cryptodev_info dev_info;
5819
5820         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5821         uint64_t feat_flags = dev_info.feature_flags;
5822
5823         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5824                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5825                 printf("Device doesn't support RAW data-path APIs.\n");
5826                 return TEST_SKIPPED;
5827         }
5828
5829         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5830                 return TEST_SKIPPED;
5831
5832         /* Verify the capabilities */
5833         struct rte_cryptodev_sym_capability_idx cap_idx;
5834         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5835         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5836         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5837                         &cap_idx) == NULL)
5838                 return TEST_SKIPPED;
5839         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5840         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5841         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5842                         &cap_idx) == NULL)
5843                 return TEST_SKIPPED;
5844
5845         /* Create KASUMI session */
5846         retval = create_wireless_algo_cipher_auth_session(
5847                         ts_params->valid_devs[0],
5848                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5849                         RTE_CRYPTO_AUTH_OP_GENERATE,
5850                         RTE_CRYPTO_AUTH_KASUMI_F9,
5851                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5852                         tdata->key.data, tdata->key.len,
5853                         0, tdata->digest.len,
5854                         tdata->cipher_iv.len);
5855         if (retval != 0)
5856                 return retval;
5857
5858         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5859
5860         /* clear mbuf payload */
5861         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5862                         rte_pktmbuf_tailroom(ut_params->ibuf));
5863
5864         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5865         /* Append data which is padded to a multiple of */
5866         /* the algorithms block size */
5867         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5868         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5869                                 plaintext_pad_len);
5870         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5871
5872         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5873
5874         /* Create KASUMI operation */
5875         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
5876                                 tdata->digest.len, NULL, 0,
5877                                 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
5878                                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5879                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
5880                                 tdata->validCipherOffsetInBits.len,
5881                                 tdata->validAuthLenInBits.len,
5882                                 0
5883                                 );
5884         if (retval < 0)
5885                 return retval;
5886
5887         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5888                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5889                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5890         else
5891                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5892                         ut_params->op);
5893         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5894
5895         if (ut_params->op->sym->m_dst)
5896                 ut_params->obuf = ut_params->op->sym->m_dst;
5897         else
5898                 ut_params->obuf = ut_params->op->sym->m_src;
5899
5900         ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
5901                                 tdata->validCipherOffsetInBits.len >> 3);
5902
5903         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5904                         + plaintext_pad_len;
5905
5906         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
5907                                 (tdata->validCipherOffsetInBits.len >> 3);
5908         /* Validate obuf */
5909         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5910                 ciphertext,
5911                 reference_ciphertext,
5912                 tdata->validCipherLenInBits.len,
5913                 "KASUMI Ciphertext data not as expected");
5914
5915         /* Validate obuf */
5916         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5917                 ut_params->digest,
5918                 tdata->digest.data,
5919                 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5920                 "KASUMI Generated auth tag not as expected");
5921         return 0;
5922 }
5923
5924 static int
5925 check_cipher_capability(const struct crypto_testsuite_params *ts_params,
5926                         const enum rte_crypto_cipher_algorithm cipher_algo,
5927                         const uint16_t key_size, const uint16_t iv_size)
5928 {
5929         struct rte_cryptodev_sym_capability_idx cap_idx;
5930         const struct rte_cryptodev_symmetric_capability *cap;
5931
5932         /* Check if device supports the algorithm */
5933         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5934         cap_idx.algo.cipher = cipher_algo;
5935
5936         cap = rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5937                         &cap_idx);
5938
5939         if (cap == NULL)
5940                 return -1;
5941
5942         /* Check if device supports key size and IV size */
5943         if (rte_cryptodev_sym_capability_check_cipher(cap, key_size,
5944                         iv_size) < 0) {
5945                 return -1;
5946         }
5947
5948         return 0;
5949 }
5950
5951 static int
5952 check_auth_capability(const struct crypto_testsuite_params *ts_params,
5953                         const enum rte_crypto_auth_algorithm auth_algo,
5954                         const uint16_t key_size, const uint16_t iv_size,
5955                         const uint16_t tag_size)
5956 {
5957         struct rte_cryptodev_sym_capability_idx cap_idx;
5958         const struct rte_cryptodev_symmetric_capability *cap;
5959
5960         /* Check if device supports the algorithm */
5961         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5962         cap_idx.algo.auth = auth_algo;
5963
5964         cap = rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5965                         &cap_idx);
5966
5967         if (cap == NULL)
5968                 return -1;
5969
5970         /* Check if device supports key size and IV size */
5971         if (rte_cryptodev_sym_capability_check_auth(cap, key_size,
5972                         tag_size, iv_size) < 0) {
5973                 return -1;
5974         }
5975
5976         return 0;
5977 }
5978
5979 static int
5980 test_zuc_encryption(const struct wireless_test_data *tdata)
5981 {
5982         struct crypto_testsuite_params *ts_params = &testsuite_params;
5983         struct crypto_unittest_params *ut_params = &unittest_params;
5984
5985         int retval;
5986         uint8_t *plaintext, *ciphertext;
5987         unsigned plaintext_pad_len;
5988         unsigned plaintext_len;
5989         struct rte_cryptodev_info dev_info;
5990
5991         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5992         uint64_t feat_flags = dev_info.feature_flags;
5993
5994         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5995                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5996                 printf("Device doesn't support RAW data-path APIs.\n");
5997                 return TEST_SKIPPED;
5998         }
5999
6000         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
6001                 return TEST_SKIPPED;
6002
6003         /* Check if device supports ZUC EEA3 */
6004         if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
6005                         tdata->key.len, tdata->cipher_iv.len) < 0)
6006                 return TEST_SKIPPED;
6007
6008         /* Create ZUC session */
6009         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
6010                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
6011                                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
6012                                         tdata->key.data, tdata->key.len,
6013                                         tdata->cipher_iv.len);
6014         if (retval != 0)
6015                 return retval;
6016
6017         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6018
6019         /* Clear mbuf payload */
6020         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6021                rte_pktmbuf_tailroom(ut_params->ibuf));
6022
6023         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6024         /* Append data which is padded to a multiple */
6025         /* of the algorithms block size */
6026         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
6027         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6028                                 plaintext_pad_len);
6029         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6030
6031         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
6032
6033         /* Create ZUC operation */
6034         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
6035                                         tdata->cipher_iv.len,
6036                                         tdata->plaintext.len,
6037                                         0);
6038         if (retval < 0)
6039                 return retval;
6040
6041         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6042                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6043                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
6044         else
6045                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6046                                                 ut_params->op);
6047         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6048
6049         ut_params->obuf = ut_params->op->sym->m_dst;
6050         if (ut_params->obuf)
6051                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
6052         else
6053                 ciphertext = plaintext;
6054
6055         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
6056
6057         /* Validate obuf */
6058         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6059                 ciphertext,
6060                 tdata->ciphertext.data,
6061                 tdata->validCipherLenInBits.len,
6062                 "ZUC Ciphertext data not as expected");
6063         return 0;
6064 }
6065
6066 static int
6067 test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
6068 {
6069         struct crypto_testsuite_params *ts_params = &testsuite_params;
6070         struct crypto_unittest_params *ut_params = &unittest_params;
6071
6072         int retval;
6073
6074         unsigned int plaintext_pad_len;
6075         unsigned int plaintext_len;
6076         const uint8_t *ciphertext;
6077         uint8_t ciphertext_buffer[2048];
6078         struct rte_cryptodev_info dev_info;
6079
6080         /* Check if device supports ZUC EEA3 */
6081         if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
6082                         tdata->key.len, tdata->cipher_iv.len) < 0)
6083                 return TEST_SKIPPED;
6084
6085         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
6086                 return TEST_SKIPPED;
6087
6088         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6089
6090         uint64_t feat_flags = dev_info.feature_flags;
6091
6092         if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6093                 printf("Device doesn't support in-place scatter-gather. "
6094                                 "Test Skipped.\n");
6095                 return TEST_SKIPPED;
6096         }
6097
6098         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6099                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6100                 printf("Device doesn't support RAW data-path APIs.\n");
6101                 return TEST_SKIPPED;
6102         }
6103
6104         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6105
6106         /* Append data which is padded to a multiple */
6107         /* of the algorithms block size */
6108         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
6109
6110         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
6111                         plaintext_pad_len, 10, 0);
6112
6113         pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
6114                         tdata->plaintext.data);
6115
6116         /* Create ZUC session */
6117         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
6118                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
6119                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
6120                         tdata->key.data, tdata->key.len,
6121                         tdata->cipher_iv.len);
6122         if (retval < 0)
6123                 return retval;
6124
6125         /* Clear mbuf payload */
6126
6127         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
6128
6129         /* Create ZUC operation */
6130         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
6131                         tdata->cipher_iv.len, tdata->plaintext.len,
6132                         0);
6133         if (retval < 0)
6134                 return retval;
6135
6136         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6137                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6138                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
6139         else
6140                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6141                                                 ut_params->op);
6142         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6143
6144         ut_params->obuf = ut_params->op->sym->m_dst;
6145         if (ut_params->obuf)
6146                 ciphertext = rte_pktmbuf_read(ut_params->obuf,
6147                         0, plaintext_len, ciphertext_buffer);
6148         else
6149                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
6150                         0, plaintext_len, ciphertext_buffer);
6151
6152         /* Validate obuf */
6153         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
6154
6155         /* Validate obuf */
6156         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6157                 ciphertext,
6158                 tdata->ciphertext.data,
6159                 tdata->validCipherLenInBits.len,
6160                 "ZUC Ciphertext data not as expected");
6161
6162         return 0;
6163 }
6164
6165 static int
6166 test_zuc_authentication(const struct wireless_test_data *tdata)
6167 {
6168         struct crypto_testsuite_params *ts_params = &testsuite_params;
6169         struct crypto_unittest_params *ut_params = &unittest_params;
6170
6171         int retval;
6172         unsigned plaintext_pad_len;
6173         unsigned plaintext_len;
6174         uint8_t *plaintext;
6175
6176         struct rte_cryptodev_info dev_info;
6177
6178         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6179         uint64_t feat_flags = dev_info.feature_flags;
6180
6181         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
6182                         (tdata->validAuthLenInBits.len % 8 != 0)) {
6183                 printf("Device doesn't support NON-Byte Aligned Data.\n");
6184                 return TEST_SKIPPED;
6185         }
6186
6187         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6188                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6189                 printf("Device doesn't support RAW data-path APIs.\n");
6190                 return TEST_SKIPPED;
6191         }
6192
6193         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
6194                 return TEST_SKIPPED;
6195
6196         /* Check if device supports ZUC EIA3 */
6197         if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3,
6198                         tdata->key.len, tdata->auth_iv.len,
6199                         tdata->digest.len) < 0)
6200                 return TEST_SKIPPED;
6201
6202         /* Create ZUC session */
6203         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
6204                         tdata->key.data, tdata->key.len,
6205                         tdata->auth_iv.len, tdata->digest.len,
6206                         RTE_CRYPTO_AUTH_OP_GENERATE,
6207                         RTE_CRYPTO_AUTH_ZUC_EIA3);
6208         if (retval != 0)
6209                 return retval;
6210
6211         /* alloc mbuf and set payload */
6212         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6213
6214         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6215         rte_pktmbuf_tailroom(ut_params->ibuf));
6216
6217         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6218         /* Append data which is padded to a multiple of */
6219         /* the algorithms block size */
6220         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
6221         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6222                                 plaintext_pad_len);
6223         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6224
6225         /* Create ZUC operation */
6226         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
6227                         tdata->auth_iv.data, tdata->auth_iv.len,
6228                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
6229                         tdata->validAuthLenInBits.len,
6230                         0);
6231         if (retval < 0)
6232                 return retval;
6233
6234         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6235                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6236                                 ut_params->op, 0, 1, 1, 0);
6237         else
6238                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6239                                 ut_params->op);
6240         ut_params->obuf = ut_params->op->sym->m_src;
6241         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6242         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
6243                         + plaintext_pad_len;
6244
6245         /* Validate obuf */
6246         TEST_ASSERT_BUFFERS_ARE_EQUAL(
6247         ut_params->digest,
6248         tdata->digest.data,
6249         tdata->digest.len,
6250         "ZUC Generated auth tag not as expected");
6251
6252         return 0;
6253 }
6254
6255 static int
6256 test_zuc_auth_cipher(const struct wireless_test_data *tdata,
6257         uint8_t op_mode, uint8_t verify)
6258 {
6259         struct crypto_testsuite_params *ts_params = &testsuite_params;
6260         struct crypto_unittest_params *ut_params = &unittest_params;
6261
6262         int retval;
6263
6264         uint8_t *plaintext = NULL, *ciphertext = NULL;
6265         unsigned int plaintext_pad_len;
6266         unsigned int plaintext_len;
6267         unsigned int ciphertext_pad_len;
6268         unsigned int ciphertext_len;
6269
6270         struct rte_cryptodev_info dev_info;
6271
6272         /* Check if device supports ZUC EEA3 */
6273         if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
6274                         tdata->key.len, tdata->cipher_iv.len) < 0)
6275                 return TEST_SKIPPED;
6276
6277         /* Check if device supports ZUC EIA3 */
6278         if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3,
6279                         tdata->key.len, tdata->auth_iv.len,
6280                         tdata->digest.len) < 0)
6281                 return TEST_SKIPPED;
6282
6283         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6284
6285         uint64_t feat_flags = dev_info.feature_flags;
6286
6287         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6288                 printf("Device doesn't support digest encrypted.\n");
6289                 return TEST_SKIPPED;
6290         }
6291         if (op_mode == IN_PLACE) {
6292                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6293                         printf("Device doesn't support in-place scatter-gather "
6294                                         "in both input and output mbufs.\n");
6295                         return TEST_SKIPPED;
6296                 }
6297
6298                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6299                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6300                         printf("Device doesn't support RAW data-path APIs.\n");
6301                         return TEST_SKIPPED;
6302                 }
6303         } else {
6304                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6305                         return TEST_SKIPPED;
6306                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
6307                         printf("Device doesn't support out-of-place scatter-gather "
6308                                         "in both input and output mbufs.\n");
6309                         return TEST_SKIPPED;
6310                 }
6311         }
6312
6313         /* Create ZUC session */
6314         retval = create_wireless_algo_auth_cipher_session(
6315                         ts_params->valid_devs[0],
6316                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
6317                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
6318                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
6319                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
6320                         RTE_CRYPTO_AUTH_ZUC_EIA3,
6321                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
6322                         tdata->key.data, tdata->key.len,
6323                         tdata->auth_iv.len, tdata->digest.len,
6324                         tdata->cipher_iv.len);
6325
6326         if (retval != 0)
6327                 return retval;
6328
6329         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6330         if (op_mode == OUT_OF_PLACE)
6331                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6332
6333         /* clear mbuf payload */
6334         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6335                 rte_pktmbuf_tailroom(ut_params->ibuf));
6336         if (op_mode == OUT_OF_PLACE)
6337                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
6338                         rte_pktmbuf_tailroom(ut_params->obuf));
6339
6340         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
6341         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6342         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6343         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6344
6345         if (verify) {
6346                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6347                                         ciphertext_pad_len);
6348                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
6349                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6350                         ciphertext_len);
6351         } else {
6352                 /* make sure enough space to cover partial digest verify case */
6353                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6354                                         ciphertext_pad_len);
6355                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6356                 debug_hexdump(stdout, "plaintext:", plaintext,
6357                         plaintext_len);
6358         }
6359
6360         if (op_mode == OUT_OF_PLACE)
6361                 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
6362
6363         /* Create ZUC operation */
6364         retval = create_wireless_algo_auth_cipher_operation(
6365                 tdata->digest.data, tdata->digest.len,
6366                 tdata->cipher_iv.data, tdata->cipher_iv.len,
6367                 tdata->auth_iv.data, tdata->auth_iv.len,
6368                 (tdata->digest.offset_bytes == 0 ?
6369                 (verify ? ciphertext_pad_len : plaintext_pad_len)
6370                         : tdata->digest.offset_bytes),
6371                 tdata->validCipherLenInBits.len,
6372                 tdata->validCipherOffsetInBits.len,
6373                 tdata->validAuthLenInBits.len,
6374                 0,
6375                 op_mode, 0, verify);
6376
6377         if (retval < 0)
6378                 return retval;
6379
6380         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6381                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6382                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
6383         else
6384                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6385                         ut_params->op);
6386
6387         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6388
6389         ut_params->obuf = (op_mode == IN_PLACE ?
6390                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6391
6392
6393         if (verify) {
6394                 if (ut_params->obuf)
6395                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
6396                                                         uint8_t *);
6397                 else
6398                         plaintext = ciphertext;
6399
6400                 debug_hexdump(stdout, "plaintext:", plaintext,
6401                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6402                 debug_hexdump(stdout, "plaintext expected:",
6403                         tdata->plaintext.data,
6404                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6405         } else {
6406                 if (ut_params->obuf)
6407                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
6408                                                         uint8_t *);
6409                 else
6410                         ciphertext = plaintext;
6411
6412                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6413                         ciphertext_len);
6414                 debug_hexdump(stdout, "ciphertext expected:",
6415                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
6416
6417                 ut_params->digest = rte_pktmbuf_mtod(
6418                         ut_params->obuf, uint8_t *) +
6419                         (tdata->digest.offset_bytes == 0 ?
6420                         plaintext_pad_len : tdata->digest.offset_bytes);
6421
6422                 debug_hexdump(stdout, "digest:", ut_params->digest,
6423                         tdata->digest.len);
6424                 debug_hexdump(stdout, "digest expected:",
6425                         tdata->digest.data, tdata->digest.len);
6426         }
6427
6428         /* Validate obuf */
6429         if (verify) {
6430                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6431                         plaintext,
6432                         tdata->plaintext.data,
6433                         tdata->plaintext.len >> 3,
6434                         "ZUC Plaintext data not as expected");
6435         } else {
6436                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6437                         ciphertext,
6438                         tdata->ciphertext.data,
6439                         tdata->ciphertext.len >> 3,
6440                         "ZUC Ciphertext data not as expected");
6441
6442                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6443                         ut_params->digest,
6444                         tdata->digest.data,
6445                         DIGEST_BYTE_LENGTH_KASUMI_F9,
6446                         "ZUC Generated auth tag not as expected");
6447         }
6448         return 0;
6449 }
6450
6451 static int
6452 test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata,
6453         uint8_t op_mode, uint8_t verify)
6454 {
6455         struct crypto_testsuite_params *ts_params = &testsuite_params;
6456         struct crypto_unittest_params *ut_params = &unittest_params;
6457
6458         int retval;
6459
6460         const uint8_t *plaintext = NULL;
6461         const uint8_t *ciphertext = NULL;
6462         const uint8_t *digest = NULL;
6463         unsigned int plaintext_pad_len;
6464         unsigned int plaintext_len;
6465         unsigned int ciphertext_pad_len;
6466         unsigned int ciphertext_len;
6467         uint8_t buffer[10000];
6468         uint8_t digest_buffer[10000];
6469
6470         struct rte_cryptodev_info dev_info;
6471
6472         /* Check if device supports ZUC EEA3 */
6473         if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
6474                         tdata->key.len, tdata->cipher_iv.len) < 0)
6475                 return TEST_SKIPPED;
6476
6477         /* Check if device supports ZUC EIA3 */
6478         if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3,
6479                         tdata->key.len, tdata->auth_iv.len,
6480                         tdata->digest.len) < 0)
6481                 return TEST_SKIPPED;
6482
6483         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6484
6485         uint64_t feat_flags = dev_info.feature_flags;
6486
6487         if (op_mode == IN_PLACE) {
6488                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6489                         printf("Device doesn't support in-place scatter-gather "
6490                                         "in both input and output mbufs.\n");
6491                         return TEST_SKIPPED;
6492                 }
6493
6494                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6495                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6496                         printf("Device doesn't support RAW data-path APIs.\n");
6497                         return TEST_SKIPPED;
6498                 }
6499         } else {
6500                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6501                         return TEST_SKIPPED;
6502                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
6503                         printf("Device doesn't support out-of-place scatter-gather "
6504                                         "in both input and output mbufs.\n");
6505                         return TEST_SKIPPED;
6506                 }
6507                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6508                         printf("Device doesn't support digest encrypted.\n");
6509                         return TEST_SKIPPED;
6510                 }
6511         }
6512
6513         /* Create ZUC session */
6514         retval = create_wireless_algo_auth_cipher_session(
6515                         ts_params->valid_devs[0],
6516                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
6517                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
6518                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
6519                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
6520                         RTE_CRYPTO_AUTH_ZUC_EIA3,
6521                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
6522                         tdata->key.data, tdata->key.len,
6523                         tdata->auth_iv.len, tdata->digest.len,
6524                         tdata->cipher_iv.len);
6525
6526         if (retval != 0)
6527                 return retval;
6528
6529         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
6530         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6531         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6532         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6533
6534         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
6535                         plaintext_pad_len, 15, 0);
6536         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
6537                         "Failed to allocate input buffer in mempool");
6538
6539         if (op_mode == OUT_OF_PLACE) {
6540                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
6541                                 plaintext_pad_len, 15, 0);
6542                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
6543                                 "Failed to allocate output buffer in mempool");
6544         }
6545
6546         if (verify) {
6547                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
6548                         tdata->ciphertext.data);
6549                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6550                                         ciphertext_len, buffer);
6551                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6552                         ciphertext_len);
6553         } else {
6554                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
6555                         tdata->plaintext.data);
6556                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6557                                         plaintext_len, buffer);
6558                 debug_hexdump(stdout, "plaintext:", plaintext,
6559                         plaintext_len);
6560         }
6561         memset(buffer, 0, sizeof(buffer));
6562
6563         /* Create ZUC operation */
6564         retval = create_wireless_algo_auth_cipher_operation(
6565                 tdata->digest.data, tdata->digest.len,
6566                 tdata->cipher_iv.data, tdata->cipher_iv.len,
6567                 NULL, 0,
6568                 (tdata->digest.offset_bytes == 0 ?
6569                 (verify ? ciphertext_pad_len : plaintext_pad_len)
6570                         : tdata->digest.offset_bytes),
6571                 tdata->validCipherLenInBits.len,
6572                 tdata->validCipherOffsetInBits.len,
6573                 tdata->validAuthLenInBits.len,
6574                 0,
6575                 op_mode, 1, verify);
6576
6577         if (retval < 0)
6578                 return retval;
6579
6580         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6581                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6582                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
6583         else
6584                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6585                         ut_params->op);
6586
6587         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6588
6589         ut_params->obuf = (op_mode == IN_PLACE ?
6590                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6591
6592         if (verify) {
6593                 if (ut_params->obuf)
6594                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
6595                                         plaintext_len, buffer);
6596                 else
6597                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6598                                         plaintext_len, buffer);
6599
6600                 debug_hexdump(stdout, "plaintext:", plaintext,
6601                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6602                 debug_hexdump(stdout, "plaintext expected:",
6603                         tdata->plaintext.data,
6604                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6605         } else {
6606                 if (ut_params->obuf)
6607                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
6608                                         ciphertext_len, buffer);
6609                 else
6610                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6611                                         ciphertext_len, buffer);
6612
6613                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6614                         ciphertext_len);
6615                 debug_hexdump(stdout, "ciphertext expected:",
6616                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
6617
6618                 if (ut_params->obuf)
6619                         digest = rte_pktmbuf_read(ut_params->obuf,
6620                                 (tdata->digest.offset_bytes == 0 ?
6621                                 plaintext_pad_len : tdata->digest.offset_bytes),
6622                                 tdata->digest.len, digest_buffer);
6623                 else
6624                         digest = rte_pktmbuf_read(ut_params->ibuf,
6625                                 (tdata->digest.offset_bytes == 0 ?
6626                                 plaintext_pad_len : tdata->digest.offset_bytes),
6627                                 tdata->digest.len, digest_buffer);
6628
6629                 debug_hexdump(stdout, "digest:", digest,
6630                         tdata->digest.len);
6631                 debug_hexdump(stdout, "digest expected:",
6632                         tdata->digest.data, tdata->digest.len);
6633         }
6634
6635         /* Validate obuf */
6636         if (verify) {
6637                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6638                         plaintext,
6639                         tdata->plaintext.data,
6640                         tdata->plaintext.len >> 3,
6641                         "ZUC Plaintext data not as expected");
6642         } else {
6643                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6644                         ciphertext,
6645                         tdata->ciphertext.data,
6646                         tdata->validDataLenInBits.len,
6647                         "ZUC Ciphertext data not as expected");
6648
6649                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6650                         digest,
6651                         tdata->digest.data,
6652                         DIGEST_BYTE_LENGTH_KASUMI_F9,
6653                         "ZUC Generated auth tag not as expected");
6654         }
6655         return 0;
6656 }
6657
6658 static int
6659 test_kasumi_encryption_test_case_1(void)
6660 {
6661         return test_kasumi_encryption(&kasumi_test_case_1);
6662 }
6663
6664 static int
6665 test_kasumi_encryption_test_case_1_sgl(void)
6666 {
6667         return test_kasumi_encryption_sgl(&kasumi_test_case_1);
6668 }
6669
6670 static int
6671 test_kasumi_encryption_test_case_1_oop(void)
6672 {
6673         return test_kasumi_encryption_oop(&kasumi_test_case_1);
6674 }
6675
6676 static int
6677 test_kasumi_encryption_test_case_1_oop_sgl(void)
6678 {
6679         return test_kasumi_encryption_oop_sgl(&kasumi_test_case_1);
6680 }
6681
6682 static int
6683 test_kasumi_encryption_test_case_2(void)
6684 {
6685         return test_kasumi_encryption(&kasumi_test_case_2);
6686 }
6687
6688 static int
6689 test_kasumi_encryption_test_case_3(void)
6690 {
6691         return test_kasumi_encryption(&kasumi_test_case_3);
6692 }
6693
6694 static int
6695 test_kasumi_encryption_test_case_4(void)
6696 {
6697         return test_kasumi_encryption(&kasumi_test_case_4);
6698 }
6699
6700 static int
6701 test_kasumi_encryption_test_case_5(void)
6702 {
6703         return test_kasumi_encryption(&kasumi_test_case_5);
6704 }
6705
6706 static int
6707 test_kasumi_decryption_test_case_1(void)
6708 {
6709         return test_kasumi_decryption(&kasumi_test_case_1);
6710 }
6711
6712 static int
6713 test_kasumi_decryption_test_case_1_oop(void)
6714 {
6715         return test_kasumi_decryption_oop(&kasumi_test_case_1);
6716 }
6717
6718 static int
6719 test_kasumi_decryption_test_case_2(void)
6720 {
6721         return test_kasumi_decryption(&kasumi_test_case_2);
6722 }
6723
6724 static int
6725 test_kasumi_decryption_test_case_3(void)
6726 {
6727         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6728         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6729                 return TEST_SKIPPED;
6730         return test_kasumi_decryption(&kasumi_test_case_3);
6731 }
6732
6733 static int
6734 test_kasumi_decryption_test_case_4(void)
6735 {
6736         return test_kasumi_decryption(&kasumi_test_case_4);
6737 }
6738
6739 static int
6740 test_kasumi_decryption_test_case_5(void)
6741 {
6742         return test_kasumi_decryption(&kasumi_test_case_5);
6743 }
6744 static int
6745 test_snow3g_encryption_test_case_1(void)
6746 {
6747         return test_snow3g_encryption(&snow3g_test_case_1);
6748 }
6749
6750 static int
6751 test_snow3g_encryption_test_case_1_oop(void)
6752 {
6753         return test_snow3g_encryption_oop(&snow3g_test_case_1);
6754 }
6755
6756 static int
6757 test_snow3g_encryption_test_case_1_oop_sgl(void)
6758 {
6759         return test_snow3g_encryption_oop_sgl(&snow3g_test_case_1);
6760 }
6761
6762
6763 static int
6764 test_snow3g_encryption_test_case_1_offset_oop(void)
6765 {
6766         return test_snow3g_encryption_offset_oop(&snow3g_test_case_1);
6767 }
6768
6769 static int
6770 test_snow3g_encryption_test_case_2(void)
6771 {
6772         return test_snow3g_encryption(&snow3g_test_case_2);
6773 }
6774
6775 static int
6776 test_snow3g_encryption_test_case_3(void)
6777 {
6778         return test_snow3g_encryption(&snow3g_test_case_3);
6779 }
6780
6781 static int
6782 test_snow3g_encryption_test_case_4(void)
6783 {
6784         return test_snow3g_encryption(&snow3g_test_case_4);
6785 }
6786
6787 static int
6788 test_snow3g_encryption_test_case_5(void)
6789 {
6790         return test_snow3g_encryption(&snow3g_test_case_5);
6791 }
6792
6793 static int
6794 test_snow3g_decryption_test_case_1(void)
6795 {
6796         return test_snow3g_decryption(&snow3g_test_case_1);
6797 }
6798
6799 static int
6800 test_snow3g_decryption_test_case_1_oop(void)
6801 {
6802         return test_snow3g_decryption_oop(&snow3g_test_case_1);
6803 }
6804
6805 static int
6806 test_snow3g_decryption_test_case_2(void)
6807 {
6808         return test_snow3g_decryption(&snow3g_test_case_2);
6809 }
6810
6811 static int
6812 test_snow3g_decryption_test_case_3(void)
6813 {
6814         return test_snow3g_decryption(&snow3g_test_case_3);
6815 }
6816
6817 static int
6818 test_snow3g_decryption_test_case_4(void)
6819 {
6820         return test_snow3g_decryption(&snow3g_test_case_4);
6821 }
6822
6823 static int
6824 test_snow3g_decryption_test_case_5(void)
6825 {
6826         return test_snow3g_decryption(&snow3g_test_case_5);
6827 }
6828
6829 /*
6830  * Function prepares snow3g_hash_test_data from snow3g_test_data.
6831  * Pattern digest from snow3g_test_data must be allocated as
6832  * 4 last bytes in plaintext.
6833  */
6834 static void
6835 snow3g_hash_test_vector_setup(const struct snow3g_test_data *pattern,
6836                 struct snow3g_hash_test_data *output)
6837 {
6838         if ((pattern != NULL) && (output != NULL)) {
6839                 output->key.len = pattern->key.len;
6840
6841                 memcpy(output->key.data,
6842                 pattern->key.data, pattern->key.len);
6843
6844                 output->auth_iv.len = pattern->auth_iv.len;
6845
6846                 memcpy(output->auth_iv.data,
6847                 pattern->auth_iv.data, pattern->auth_iv.len);
6848
6849                 output->plaintext.len = pattern->plaintext.len;
6850
6851                 memcpy(output->plaintext.data,
6852                 pattern->plaintext.data, pattern->plaintext.len >> 3);
6853
6854                 output->digest.len = pattern->digest.len;
6855
6856                 memcpy(output->digest.data,
6857                 &pattern->plaintext.data[pattern->digest.offset_bytes],
6858                 pattern->digest.len);
6859
6860                 output->validAuthLenInBits.len =
6861                 pattern->validAuthLenInBits.len;
6862         }
6863 }
6864
6865 /*
6866  * Test case verify computed cipher and digest from snow3g_test_case_7 data.
6867  */
6868 static int
6869 test_snow3g_decryption_with_digest_test_case_1(void)
6870 {
6871         struct snow3g_hash_test_data snow3g_hash_data;
6872         struct rte_cryptodev_info dev_info;
6873         struct crypto_testsuite_params *ts_params = &testsuite_params;
6874
6875         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6876         uint64_t feat_flags = dev_info.feature_flags;
6877
6878         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6879                 printf("Device doesn't support encrypted digest operations.\n");
6880                 return TEST_SKIPPED;
6881         }
6882
6883         /*
6884          * Function prepare data for hash verification test case.
6885          * Digest is allocated in 4 last bytes in plaintext, pattern.
6886          */
6887         snow3g_hash_test_vector_setup(&snow3g_test_case_7, &snow3g_hash_data);
6888
6889         return test_snow3g_decryption(&snow3g_test_case_7) &
6890                         test_snow3g_authentication_verify(&snow3g_hash_data);
6891 }
6892
6893 static int
6894 test_snow3g_cipher_auth_test_case_1(void)
6895 {
6896         return test_snow3g_cipher_auth(&snow3g_test_case_3);
6897 }
6898
6899 static int
6900 test_snow3g_auth_cipher_test_case_1(void)
6901 {
6902         return test_snow3g_auth_cipher(
6903                 &snow3g_auth_cipher_test_case_1, IN_PLACE, 0);
6904 }
6905
6906 static int
6907 test_snow3g_auth_cipher_test_case_2(void)
6908 {
6909         return test_snow3g_auth_cipher(
6910                 &snow3g_auth_cipher_test_case_2, IN_PLACE, 0);
6911 }
6912
6913 static int
6914 test_snow3g_auth_cipher_test_case_2_oop(void)
6915 {
6916         return test_snow3g_auth_cipher(
6917                 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
6918 }
6919
6920 static int
6921 test_snow3g_auth_cipher_part_digest_enc(void)
6922 {
6923         return test_snow3g_auth_cipher(
6924                 &snow3g_auth_cipher_partial_digest_encryption,
6925                         IN_PLACE, 0);
6926 }
6927
6928 static int
6929 test_snow3g_auth_cipher_part_digest_enc_oop(void)
6930 {
6931         return test_snow3g_auth_cipher(
6932                 &snow3g_auth_cipher_partial_digest_encryption,
6933                         OUT_OF_PLACE, 0);
6934 }
6935
6936 static int
6937 test_snow3g_auth_cipher_test_case_3_sgl(void)
6938 {
6939         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6940         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6941                 return TEST_SKIPPED;
6942         return test_snow3g_auth_cipher_sgl(
6943                 &snow3g_auth_cipher_test_case_3, IN_PLACE, 0);
6944 }
6945
6946 static int
6947 test_snow3g_auth_cipher_test_case_3_oop_sgl(void)
6948 {
6949         return test_snow3g_auth_cipher_sgl(
6950                 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 0);
6951 }
6952
6953 static int
6954 test_snow3g_auth_cipher_part_digest_enc_sgl(void)
6955 {
6956         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6957         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6958                 return TEST_SKIPPED;
6959         return test_snow3g_auth_cipher_sgl(
6960                 &snow3g_auth_cipher_partial_digest_encryption,
6961                         IN_PLACE, 0);
6962 }
6963
6964 static int
6965 test_snow3g_auth_cipher_part_digest_enc_oop_sgl(void)
6966 {
6967         return test_snow3g_auth_cipher_sgl(
6968                 &snow3g_auth_cipher_partial_digest_encryption,
6969                         OUT_OF_PLACE, 0);
6970 }
6971
6972 static int
6973 test_snow3g_auth_cipher_verify_test_case_1(void)
6974 {
6975         return test_snow3g_auth_cipher(
6976                 &snow3g_auth_cipher_test_case_1, IN_PLACE, 1);
6977 }
6978
6979 static int
6980 test_snow3g_auth_cipher_verify_test_case_2(void)
6981 {
6982         return test_snow3g_auth_cipher(
6983                 &snow3g_auth_cipher_test_case_2, IN_PLACE, 1);
6984 }
6985
6986 static int
6987 test_snow3g_auth_cipher_verify_test_case_2_oop(void)
6988 {
6989         return test_snow3g_auth_cipher(
6990                 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
6991 }
6992
6993 static int
6994 test_snow3g_auth_cipher_verify_part_digest_enc(void)
6995 {
6996         return test_snow3g_auth_cipher(
6997                 &snow3g_auth_cipher_partial_digest_encryption,
6998                         IN_PLACE, 1);
6999 }
7000
7001 static int
7002 test_snow3g_auth_cipher_verify_part_digest_enc_oop(void)
7003 {
7004         return test_snow3g_auth_cipher(
7005                 &snow3g_auth_cipher_partial_digest_encryption,
7006                         OUT_OF_PLACE, 1);
7007 }
7008
7009 static int
7010 test_snow3g_auth_cipher_verify_test_case_3_sgl(void)
7011 {
7012         return test_snow3g_auth_cipher_sgl(
7013                 &snow3g_auth_cipher_test_case_3, IN_PLACE, 1);
7014 }
7015
7016 static int
7017 test_snow3g_auth_cipher_verify_test_case_3_oop_sgl(void)
7018 {
7019         return test_snow3g_auth_cipher_sgl(
7020                 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 1);
7021 }
7022
7023 static int
7024 test_snow3g_auth_cipher_verify_part_digest_enc_sgl(void)
7025 {
7026         return test_snow3g_auth_cipher_sgl(
7027                 &snow3g_auth_cipher_partial_digest_encryption,
7028                         IN_PLACE, 1);
7029 }
7030
7031 static int
7032 test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl(void)
7033 {
7034         return test_snow3g_auth_cipher_sgl(
7035                 &snow3g_auth_cipher_partial_digest_encryption,
7036                         OUT_OF_PLACE, 1);
7037 }
7038
7039 static int
7040 test_snow3g_auth_cipher_with_digest_test_case_1(void)
7041 {
7042         return test_snow3g_auth_cipher(
7043                 &snow3g_test_case_7, IN_PLACE, 0);
7044 }
7045
7046 static int
7047 test_kasumi_auth_cipher_test_case_1(void)
7048 {
7049         return test_kasumi_auth_cipher(
7050                 &kasumi_test_case_3, IN_PLACE, 0);
7051 }
7052
7053 static int
7054 test_kasumi_auth_cipher_test_case_2(void)
7055 {
7056         return test_kasumi_auth_cipher(
7057                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
7058 }
7059
7060 static int
7061 test_kasumi_auth_cipher_test_case_2_oop(void)
7062 {
7063         return test_kasumi_auth_cipher(
7064                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
7065 }
7066
7067 static int
7068 test_kasumi_auth_cipher_test_case_2_sgl(void)
7069 {
7070         return test_kasumi_auth_cipher_sgl(
7071                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
7072 }
7073
7074 static int
7075 test_kasumi_auth_cipher_test_case_2_oop_sgl(void)
7076 {
7077         return test_kasumi_auth_cipher_sgl(
7078                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
7079 }
7080
7081 static int
7082 test_kasumi_auth_cipher_verify_test_case_1(void)
7083 {
7084         return test_kasumi_auth_cipher(
7085                 &kasumi_test_case_3, IN_PLACE, 1);
7086 }
7087
7088 static int
7089 test_kasumi_auth_cipher_verify_test_case_2(void)
7090 {
7091         return test_kasumi_auth_cipher(
7092                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
7093 }
7094
7095 static int
7096 test_kasumi_auth_cipher_verify_test_case_2_oop(void)
7097 {
7098         return test_kasumi_auth_cipher(
7099                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
7100 }
7101
7102 static int
7103 test_kasumi_auth_cipher_verify_test_case_2_sgl(void)
7104 {
7105         return test_kasumi_auth_cipher_sgl(
7106                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
7107 }
7108
7109 static int
7110 test_kasumi_auth_cipher_verify_test_case_2_oop_sgl(void)
7111 {
7112         return test_kasumi_auth_cipher_sgl(
7113                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
7114 }
7115
7116 static int
7117 test_kasumi_cipher_auth_test_case_1(void)
7118 {
7119         return test_kasumi_cipher_auth(&kasumi_test_case_6);
7120 }
7121
7122 static int
7123 test_zuc_encryption_test_case_1(void)
7124 {
7125         return test_zuc_encryption(&zuc_test_case_cipher_193b);
7126 }
7127
7128 static int
7129 test_zuc_encryption_test_case_2(void)
7130 {
7131         return test_zuc_encryption(&zuc_test_case_cipher_800b);
7132 }
7133
7134 static int
7135 test_zuc_encryption_test_case_3(void)
7136 {
7137         return test_zuc_encryption(&zuc_test_case_cipher_1570b);
7138 }
7139
7140 static int
7141 test_zuc_encryption_test_case_4(void)
7142 {
7143         return test_zuc_encryption(&zuc_test_case_cipher_2798b);
7144 }
7145
7146 static int
7147 test_zuc_encryption_test_case_5(void)
7148 {
7149         return test_zuc_encryption(&zuc_test_case_cipher_4019b);
7150 }
7151
7152 static int
7153 test_zuc_encryption_test_case_6_sgl(void)
7154 {
7155         return test_zuc_encryption_sgl(&zuc_test_case_cipher_193b);
7156 }
7157
7158 static int
7159 test_zuc_hash_generate_test_case_1(void)
7160 {
7161         return test_zuc_authentication(&zuc_test_case_auth_1b);
7162 }
7163
7164 static int
7165 test_zuc_hash_generate_test_case_2(void)
7166 {
7167         return test_zuc_authentication(&zuc_test_case_auth_90b);
7168 }
7169
7170 static int
7171 test_zuc_hash_generate_test_case_3(void)
7172 {
7173         return test_zuc_authentication(&zuc_test_case_auth_577b);
7174 }
7175
7176 static int
7177 test_zuc_hash_generate_test_case_4(void)
7178 {
7179         return test_zuc_authentication(&zuc_test_case_auth_2079b);
7180 }
7181
7182 static int
7183 test_zuc_hash_generate_test_case_5(void)
7184 {
7185         return test_zuc_authentication(&zuc_test_auth_5670b);
7186 }
7187
7188 static int
7189 test_zuc_hash_generate_test_case_6(void)
7190 {
7191         return test_zuc_authentication(&zuc_test_case_auth_128b);
7192 }
7193
7194 static int
7195 test_zuc_hash_generate_test_case_7(void)
7196 {
7197         return test_zuc_authentication(&zuc_test_case_auth_2080b);
7198 }
7199
7200 static int
7201 test_zuc_hash_generate_test_case_8(void)
7202 {
7203         return test_zuc_authentication(&zuc_test_case_auth_584b);
7204 }
7205
7206 static int
7207 test_zuc_hash_generate_test_case_9(void)
7208 {
7209         return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_32b);
7210 }
7211
7212 static int
7213 test_zuc_hash_generate_test_case_10(void)
7214 {
7215         return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_64b);
7216 }
7217
7218 static int
7219 test_zuc_hash_generate_test_case_11(void)
7220 {
7221         return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_128b);
7222 }
7223
7224 static int
7225 test_zuc_cipher_auth_test_case_1(void)
7226 {
7227         return test_zuc_cipher_auth(&zuc_test_case_cipher_200b_auth_200b);
7228 }
7229
7230 static int
7231 test_zuc_cipher_auth_test_case_2(void)
7232 {
7233         return test_zuc_cipher_auth(&zuc_test_case_cipher_800b_auth_120b);
7234 }
7235
7236 static int
7237 test_zuc_auth_cipher_test_case_1(void)
7238 {
7239         return test_zuc_auth_cipher(
7240                 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
7241 }
7242
7243 static int
7244 test_zuc_auth_cipher_test_case_1_oop(void)
7245 {
7246         return test_zuc_auth_cipher(
7247                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
7248 }
7249
7250 static int
7251 test_zuc_auth_cipher_test_case_1_sgl(void)
7252 {
7253         return test_zuc_auth_cipher_sgl(
7254                 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
7255 }
7256
7257 static int
7258 test_zuc_auth_cipher_test_case_1_oop_sgl(void)
7259 {
7260         return test_zuc_auth_cipher_sgl(
7261                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
7262 }
7263
7264 static int
7265 test_zuc_auth_cipher_verify_test_case_1(void)
7266 {
7267         return test_zuc_auth_cipher(
7268                 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
7269 }
7270
7271 static int
7272 test_zuc_auth_cipher_verify_test_case_1_oop(void)
7273 {
7274         return test_zuc_auth_cipher(
7275                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
7276 }
7277
7278 static int
7279 test_zuc_auth_cipher_verify_test_case_1_sgl(void)
7280 {
7281         return test_zuc_auth_cipher_sgl(
7282                 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
7283 }
7284
7285 static int
7286 test_zuc_auth_cipher_verify_test_case_1_oop_sgl(void)
7287 {
7288         return test_zuc_auth_cipher_sgl(
7289                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
7290 }
7291
7292 static int
7293 test_zuc256_encryption_test_case_1(void)
7294 {
7295         return test_zuc_encryption(&zuc256_test_case_cipher_1);
7296 }
7297
7298 static int
7299 test_zuc256_encryption_test_case_2(void)
7300 {
7301         return test_zuc_encryption(&zuc256_test_case_cipher_2);
7302 }
7303
7304 static int
7305 test_zuc256_authentication_test_case_1(void)
7306 {
7307         return test_zuc_authentication(&zuc256_test_case_auth_1);
7308 }
7309
7310 static int
7311 test_zuc256_authentication_test_case_2(void)
7312 {
7313         return test_zuc_authentication(&zuc256_test_case_auth_2);
7314 }
7315
7316 static int
7317 test_mixed_check_if_unsupported(const struct mixed_cipher_auth_test_data *tdata)
7318 {
7319         uint8_t dev_id = testsuite_params.valid_devs[0];
7320
7321         struct rte_cryptodev_sym_capability_idx cap_idx;
7322
7323         /* Check if device supports particular cipher algorithm */
7324         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
7325         cap_idx.algo.cipher = tdata->cipher_algo;
7326         if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
7327                 return TEST_SKIPPED;
7328
7329         /* Check if device supports particular hash algorithm */
7330         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
7331         cap_idx.algo.auth = tdata->auth_algo;
7332         if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
7333                 return TEST_SKIPPED;
7334
7335         return 0;
7336 }
7337
7338 static int
7339 test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata,
7340         uint8_t op_mode, uint8_t verify)
7341 {
7342         struct crypto_testsuite_params *ts_params = &testsuite_params;
7343         struct crypto_unittest_params *ut_params = &unittest_params;
7344
7345         int retval;
7346
7347         uint8_t *plaintext = NULL, *ciphertext = NULL;
7348         unsigned int plaintext_pad_len;
7349         unsigned int plaintext_len;
7350         unsigned int ciphertext_pad_len;
7351         unsigned int ciphertext_len;
7352
7353         struct rte_cryptodev_info dev_info;
7354         struct rte_crypto_op *op;
7355
7356         /* Check if device supports particular algorithms separately */
7357         if (test_mixed_check_if_unsupported(tdata))
7358                 return TEST_SKIPPED;
7359         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
7360                 return TEST_SKIPPED;
7361
7362         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
7363
7364         uint64_t feat_flags = dev_info.feature_flags;
7365
7366         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
7367                 printf("Device doesn't support digest encrypted.\n");
7368                 return TEST_SKIPPED;
7369         }
7370
7371         /* Create the session */
7372         if (verify)
7373                 retval = create_wireless_algo_cipher_auth_session(
7374                                 ts_params->valid_devs[0],
7375                                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
7376                                 RTE_CRYPTO_AUTH_OP_VERIFY,
7377                                 tdata->auth_algo,
7378                                 tdata->cipher_algo,
7379                                 tdata->auth_key.data, tdata->auth_key.len,
7380                                 tdata->auth_iv.len, tdata->digest_enc.len,
7381                                 tdata->cipher_iv.len);
7382         else
7383                 retval = create_wireless_algo_auth_cipher_session(
7384                                 ts_params->valid_devs[0],
7385                                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7386                                 RTE_CRYPTO_AUTH_OP_GENERATE,
7387                                 tdata->auth_algo,
7388                                 tdata->cipher_algo,
7389                                 tdata->auth_key.data, tdata->auth_key.len,
7390                                 tdata->auth_iv.len, tdata->digest_enc.len,
7391                                 tdata->cipher_iv.len);
7392         if (retval != 0)
7393                 return retval;
7394
7395         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7396         if (op_mode == OUT_OF_PLACE)
7397                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7398
7399         /* clear mbuf payload */
7400         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7401                 rte_pktmbuf_tailroom(ut_params->ibuf));
7402         if (op_mode == OUT_OF_PLACE) {
7403
7404                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
7405                                 rte_pktmbuf_tailroom(ut_params->obuf));
7406         }
7407
7408         ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
7409         plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
7410         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
7411         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
7412
7413         if (verify) {
7414                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7415                                 ciphertext_pad_len);
7416                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
7417                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7418                                 ciphertext_len);
7419         } else {
7420                 /* make sure enough space to cover partial digest verify case */
7421                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7422                                 ciphertext_pad_len);
7423                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
7424                 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
7425         }
7426
7427         if (op_mode == OUT_OF_PLACE)
7428                 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
7429
7430         /* Create the operation */
7431         retval = create_wireless_algo_auth_cipher_operation(
7432                         tdata->digest_enc.data, tdata->digest_enc.len,
7433                         tdata->cipher_iv.data, tdata->cipher_iv.len,
7434                         tdata->auth_iv.data, tdata->auth_iv.len,
7435                         (tdata->digest_enc.offset == 0 ?
7436                                 plaintext_pad_len
7437                                 : tdata->digest_enc.offset),
7438                         tdata->validCipherLen.len_bits,
7439                         tdata->cipher.offset_bits,
7440                         tdata->validAuthLen.len_bits,
7441                         tdata->auth.offset_bits,
7442                         op_mode, 0, verify);
7443
7444         if (retval < 0)
7445                 return retval;
7446
7447         op = process_crypto_request(ts_params->valid_devs[0], ut_params->op);
7448
7449         /* Check if the op failed because the device doesn't */
7450         /* support this particular combination of algorithms */
7451         if (op == NULL && ut_params->op->status ==
7452                         RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
7453                 printf("Device doesn't support this mixed combination. "
7454                                 "Test Skipped.\n");
7455                 return TEST_SKIPPED;
7456         }
7457         ut_params->op = op;
7458
7459         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
7460
7461         ut_params->obuf = (op_mode == IN_PLACE ?
7462                         ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
7463
7464         if (verify) {
7465                 if (ut_params->obuf)
7466                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
7467                                                         uint8_t *);
7468                 else
7469                         plaintext = ciphertext +
7470                                         (tdata->cipher.offset_bits >> 3);
7471
7472                 debug_hexdump(stdout, "plaintext:", plaintext,
7473                                 tdata->plaintext.len_bits >> 3);
7474                 debug_hexdump(stdout, "plaintext expected:",
7475                                 tdata->plaintext.data,
7476                                 tdata->plaintext.len_bits >> 3);
7477         } else {
7478                 if (ut_params->obuf)
7479                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
7480                                         uint8_t *);
7481                 else
7482                         ciphertext = plaintext;
7483
7484                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7485                                 ciphertext_len);
7486                 debug_hexdump(stdout, "ciphertext expected:",
7487                                 tdata->ciphertext.data,
7488                                 tdata->ciphertext.len_bits >> 3);
7489
7490                 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
7491                                 + (tdata->digest_enc.offset == 0 ?
7492                 plaintext_pad_len : tdata->digest_enc.offset);
7493
7494                 debug_hexdump(stdout, "digest:", ut_params->digest,
7495                                 tdata->digest_enc.len);
7496                 debug_hexdump(stdout, "digest expected:",
7497                                 tdata->digest_enc.data,
7498                                 tdata->digest_enc.len);
7499         }
7500
7501         if (!verify) {
7502                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7503                                 ut_params->digest,
7504                                 tdata->digest_enc.data,
7505                                 tdata->digest_enc.len,
7506                                 "Generated auth tag not as expected");
7507         }
7508
7509         if (tdata->cipher_algo != RTE_CRYPTO_CIPHER_NULL) {
7510                 if (verify) {
7511                         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7512                                         plaintext,
7513                                         tdata->plaintext.data,
7514                                         tdata->plaintext.len_bits >> 3,
7515                                         "Plaintext data not as expected");
7516                 } else {
7517                         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7518                                         ciphertext,
7519                                         tdata->ciphertext.data,
7520                                         tdata->validDataLen.len_bits,
7521                                         "Ciphertext data not as expected");
7522                 }
7523         }
7524
7525         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7526                         "crypto op processing failed");
7527
7528         return 0;
7529 }
7530
7531 static int
7532 test_mixed_auth_cipher_sgl(const struct mixed_cipher_auth_test_data *tdata,
7533         uint8_t op_mode, uint8_t verify)
7534 {
7535         struct crypto_testsuite_params *ts_params = &testsuite_params;
7536         struct crypto_unittest_params *ut_params = &unittest_params;
7537
7538         int retval;
7539
7540         const uint8_t *plaintext = NULL;
7541         const uint8_t *ciphertext = NULL;
7542         const uint8_t *digest = NULL;
7543         unsigned int plaintext_pad_len;
7544         unsigned int plaintext_len;
7545         unsigned int ciphertext_pad_len;
7546         unsigned int ciphertext_len;
7547         uint8_t buffer[10000];
7548         uint8_t digest_buffer[10000];
7549
7550         struct rte_cryptodev_info dev_info;
7551         struct rte_crypto_op *op;
7552
7553         /* Check if device supports particular algorithms */
7554         if (test_mixed_check_if_unsupported(tdata))
7555                 return TEST_SKIPPED;
7556         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
7557                 return TEST_SKIPPED;
7558
7559         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
7560
7561         uint64_t feat_flags = dev_info.feature_flags;
7562
7563         if (op_mode == IN_PLACE) {
7564                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
7565                         printf("Device doesn't support in-place scatter-gather "
7566                                         "in both input and output mbufs.\n");
7567                         return TEST_SKIPPED;
7568                 }
7569         } else {
7570                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
7571                         printf("Device doesn't support out-of-place scatter-gather "
7572                                         "in both input and output mbufs.\n");
7573                         return TEST_SKIPPED;
7574                 }
7575                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
7576                         printf("Device doesn't support digest encrypted.\n");
7577                         return TEST_SKIPPED;
7578                 }
7579         }
7580
7581         /* Create the session */
7582         if (verify)
7583                 retval = create_wireless_algo_cipher_auth_session(
7584                                 ts_params->valid_devs[0],
7585                                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
7586                                 RTE_CRYPTO_AUTH_OP_VERIFY,
7587                                 tdata->auth_algo,
7588                                 tdata->cipher_algo,
7589                                 tdata->auth_key.data, tdata->auth_key.len,
7590                                 tdata->auth_iv.len, tdata->digest_enc.len,
7591                                 tdata->cipher_iv.len);
7592         else
7593                 retval = create_wireless_algo_auth_cipher_session(
7594                                 ts_params->valid_devs[0],
7595                                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7596                                 RTE_CRYPTO_AUTH_OP_GENERATE,
7597                                 tdata->auth_algo,
7598                                 tdata->cipher_algo,
7599                                 tdata->auth_key.data, tdata->auth_key.len,
7600                                 tdata->auth_iv.len, tdata->digest_enc.len,
7601                                 tdata->cipher_iv.len);
7602         if (retval != 0)
7603                 return retval;
7604
7605         ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
7606         plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
7607         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
7608         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
7609
7610         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
7611                         ciphertext_pad_len, 15, 0);
7612         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
7613                         "Failed to allocate input buffer in mempool");
7614
7615         if (op_mode == OUT_OF_PLACE) {
7616                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
7617                                 plaintext_pad_len, 15, 0);
7618                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
7619                                 "Failed to allocate output buffer in mempool");
7620         }
7621
7622         if (verify) {
7623                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
7624                         tdata->ciphertext.data);
7625                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
7626                                         ciphertext_len, buffer);
7627                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7628                         ciphertext_len);
7629         } else {
7630                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
7631                         tdata->plaintext.data);
7632                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
7633                                         plaintext_len, buffer);
7634                 debug_hexdump(stdout, "plaintext:", plaintext,
7635                         plaintext_len);
7636         }
7637         memset(buffer, 0, sizeof(buffer));
7638
7639         /* Create the operation */
7640         retval = create_wireless_algo_auth_cipher_operation(
7641                         tdata->digest_enc.data, tdata->digest_enc.len,
7642                         tdata->cipher_iv.data, tdata->cipher_iv.len,
7643                         tdata->auth_iv.data, tdata->auth_iv.len,
7644                         (tdata->digest_enc.offset == 0 ?
7645                                 plaintext_pad_len
7646                                 : tdata->digest_enc.offset),
7647                         tdata->validCipherLen.len_bits,
7648                         tdata->cipher.offset_bits,
7649                         tdata->validAuthLen.len_bits,
7650                         tdata->auth.offset_bits,
7651                         op_mode, 1, verify);
7652
7653         if (retval < 0)
7654                 return retval;
7655
7656         op = process_crypto_request(ts_params->valid_devs[0], ut_params->op);
7657
7658         /* Check if the op failed because the device doesn't */
7659         /* support this particular combination of algorithms */
7660         if (op == NULL && ut_params->op->status ==
7661                         RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
7662                 printf("Device doesn't support this mixed combination. "
7663                                 "Test Skipped.\n");
7664                 return TEST_SKIPPED;
7665         }
7666         ut_params->op = op;
7667
7668         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
7669
7670         ut_params->obuf = (op_mode == IN_PLACE ?
7671                         ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
7672
7673         if (verify) {
7674                 if (ut_params->obuf)
7675                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
7676                                         plaintext_len, buffer);
7677                 else
7678                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
7679                                         plaintext_len, buffer);
7680
7681                 debug_hexdump(stdout, "plaintext:", plaintext,
7682                                 (tdata->plaintext.len_bits >> 3) -
7683                                 tdata->digest_enc.len);
7684                 debug_hexdump(stdout, "plaintext expected:",
7685                                 tdata->plaintext.data,
7686                                 (tdata->plaintext.len_bits >> 3) -
7687                                 tdata->digest_enc.len);
7688         } else {
7689                 if (ut_params->obuf)
7690                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
7691                                         ciphertext_len, buffer);
7692                 else
7693                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
7694                                         ciphertext_len, buffer);
7695
7696                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7697                         ciphertext_len);
7698                 debug_hexdump(stdout, "ciphertext expected:",
7699                         tdata->ciphertext.data,
7700                         tdata->ciphertext.len_bits >> 3);
7701
7702                 if (ut_params->obuf)
7703                         digest = rte_pktmbuf_read(ut_params->obuf,
7704                                         (tdata->digest_enc.offset == 0 ?
7705                                                 plaintext_pad_len :
7706                                                 tdata->digest_enc.offset),
7707                                         tdata->digest_enc.len, digest_buffer);
7708                 else
7709                         digest = rte_pktmbuf_read(ut_params->ibuf,
7710                                         (tdata->digest_enc.offset == 0 ?
7711                                                 plaintext_pad_len :
7712                                                 tdata->digest_enc.offset),
7713                                         tdata->digest_enc.len, digest_buffer);
7714
7715                 debug_hexdump(stdout, "digest:", digest,
7716                                 tdata->digest_enc.len);
7717                 debug_hexdump(stdout, "digest expected:",
7718                                 tdata->digest_enc.data, tdata->digest_enc.len);
7719         }
7720
7721         if (!verify) {
7722                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7723                                 digest,
7724                                 tdata->digest_enc.data,
7725                                 tdata->digest_enc.len,
7726                                 "Generated auth tag not as expected");
7727         }
7728
7729         if (tdata->cipher_algo != RTE_CRYPTO_CIPHER_NULL) {
7730                 if (verify) {
7731                         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7732                                         plaintext,
7733                                         tdata->plaintext.data,
7734                                         tdata->plaintext.len_bits >> 3,
7735                                         "Plaintext data not as expected");
7736                 } else {
7737                         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7738                                         ciphertext,
7739                                         tdata->ciphertext.data,
7740                                         tdata->validDataLen.len_bits,
7741                                         "Ciphertext data not as expected");
7742                 }
7743         }
7744
7745         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7746                         "crypto op processing failed");
7747
7748         return 0;
7749 }
7750
7751 /** AUTH AES CMAC + CIPHER AES CTR */
7752
7753 static int
7754 test_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7755 {
7756         return test_mixed_auth_cipher(
7757                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7758 }
7759
7760 static int
7761 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7762 {
7763         return test_mixed_auth_cipher(
7764                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7765 }
7766
7767 static int
7768 test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7769 {
7770         return test_mixed_auth_cipher_sgl(
7771                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7772 }
7773
7774 static int
7775 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7776 {
7777         return test_mixed_auth_cipher_sgl(
7778                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7779 }
7780
7781 static int
7782 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7783 {
7784         return test_mixed_auth_cipher(
7785                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7786 }
7787
7788 static int
7789 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7790 {
7791         return test_mixed_auth_cipher(
7792                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7793 }
7794
7795 static int
7796 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7797 {
7798         return test_mixed_auth_cipher_sgl(
7799                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7800 }
7801
7802 static int
7803 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7804 {
7805         return test_mixed_auth_cipher_sgl(
7806                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7807 }
7808
7809 /** MIXED AUTH + CIPHER */
7810
7811 static int
7812 test_auth_zuc_cipher_snow_test_case_1(void)
7813 {
7814         return test_mixed_auth_cipher(
7815                 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7816 }
7817
7818 static int
7819 test_verify_auth_zuc_cipher_snow_test_case_1(void)
7820 {
7821         return test_mixed_auth_cipher(
7822                 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7823 }
7824
7825 static int
7826 test_auth_aes_cmac_cipher_snow_test_case_1(void)
7827 {
7828         return test_mixed_auth_cipher(
7829                 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7830 }
7831
7832 static int
7833 test_verify_auth_aes_cmac_cipher_snow_test_case_1(void)
7834 {
7835         return test_mixed_auth_cipher(
7836                 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7837 }
7838
7839 static int
7840 test_auth_zuc_cipher_aes_ctr_test_case_1(void)
7841 {
7842         return test_mixed_auth_cipher(
7843                 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7844 }
7845
7846 static int
7847 test_verify_auth_zuc_cipher_aes_ctr_test_case_1(void)
7848 {
7849         return test_mixed_auth_cipher(
7850                 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7851 }
7852
7853 static int
7854 test_auth_snow_cipher_aes_ctr_test_case_1(void)
7855 {
7856         return test_mixed_auth_cipher(
7857                 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7858 }
7859
7860 static int
7861 test_verify_auth_snow_cipher_aes_ctr_test_case_1(void)
7862 {
7863         return test_mixed_auth_cipher(
7864                 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7865 }
7866
7867 static int
7868 test_auth_snow_cipher_zuc_test_case_1(void)
7869 {
7870         return test_mixed_auth_cipher(
7871                 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7872 }
7873
7874 static int
7875 test_verify_auth_snow_cipher_zuc_test_case_1(void)
7876 {
7877         return test_mixed_auth_cipher(
7878                 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7879 }
7880
7881 static int
7882 test_auth_aes_cmac_cipher_zuc_test_case_1(void)
7883 {
7884         return test_mixed_auth_cipher(
7885                 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7886 }
7887
7888 static int
7889 test_verify_auth_aes_cmac_cipher_zuc_test_case_1(void)
7890 {
7891         return test_mixed_auth_cipher(
7892                 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7893 }
7894
7895 static int
7896 test_auth_null_cipher_snow_test_case_1(void)
7897 {
7898         return test_mixed_auth_cipher(
7899                 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7900 }
7901
7902 static int
7903 test_verify_auth_null_cipher_snow_test_case_1(void)
7904 {
7905         return test_mixed_auth_cipher(
7906                 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7907 }
7908
7909 static int
7910 test_auth_null_cipher_zuc_test_case_1(void)
7911 {
7912         return test_mixed_auth_cipher(
7913                 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7914 }
7915
7916 static int
7917 test_verify_auth_null_cipher_zuc_test_case_1(void)
7918 {
7919         return test_mixed_auth_cipher(
7920                 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7921 }
7922
7923 static int
7924 test_auth_snow_cipher_null_test_case_1(void)
7925 {
7926         return test_mixed_auth_cipher(
7927                 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7928 }
7929
7930 static int
7931 test_verify_auth_snow_cipher_null_test_case_1(void)
7932 {
7933         return test_mixed_auth_cipher(
7934                 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7935 }
7936
7937 static int
7938 test_auth_zuc_cipher_null_test_case_1(void)
7939 {
7940         return test_mixed_auth_cipher(
7941                 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7942 }
7943
7944 static int
7945 test_verify_auth_zuc_cipher_null_test_case_1(void)
7946 {
7947         return test_mixed_auth_cipher(
7948                 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7949 }
7950
7951 static int
7952 test_auth_null_cipher_aes_ctr_test_case_1(void)
7953 {
7954         return test_mixed_auth_cipher(
7955                 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7956 }
7957
7958 static int
7959 test_verify_auth_null_cipher_aes_ctr_test_case_1(void)
7960 {
7961         return test_mixed_auth_cipher(
7962                 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7963 }
7964
7965 static int
7966 test_auth_aes_cmac_cipher_null_test_case_1(void)
7967 {
7968         return test_mixed_auth_cipher(
7969                 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7970 }
7971
7972 static int
7973 test_verify_auth_aes_cmac_cipher_null_test_case_1(void)
7974 {
7975         return test_mixed_auth_cipher(
7976                 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7977 }
7978
7979 /* ***** AEAD algorithm Tests ***** */
7980
7981 static int
7982 create_aead_session(uint8_t dev_id, enum rte_crypto_aead_algorithm algo,
7983                 enum rte_crypto_aead_operation op,
7984                 const uint8_t *key, const uint8_t key_len,
7985                 const uint16_t aad_len, const uint8_t auth_len,
7986                 uint8_t iv_len)
7987 {
7988         uint8_t aead_key[key_len];
7989         int status;
7990
7991         struct crypto_testsuite_params *ts_params = &testsuite_params;
7992         struct crypto_unittest_params *ut_params = &unittest_params;
7993
7994         memcpy(aead_key, key, key_len);
7995
7996         /* Setup AEAD Parameters */
7997         ut_params->aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD;
7998         ut_params->aead_xform.next = NULL;
7999         ut_params->aead_xform.aead.algo = algo;
8000         ut_params->aead_xform.aead.op = op;
8001         ut_params->aead_xform.aead.key.data = aead_key;
8002         ut_params->aead_xform.aead.key.length = key_len;
8003         ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
8004         ut_params->aead_xform.aead.iv.length = iv_len;
8005         ut_params->aead_xform.aead.digest_length = auth_len;
8006         ut_params->aead_xform.aead.aad_length = aad_len;
8007
8008         debug_hexdump(stdout, "key:", key, key_len);
8009
8010         /* Create Crypto session*/
8011         ut_params->sess = rte_cryptodev_sym_session_create(
8012                         ts_params->session_mpool);
8013         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
8014
8015         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
8016                         &ut_params->aead_xform,
8017                         ts_params->session_priv_mpool);
8018
8019         return status;
8020 }
8021
8022 static int
8023 create_aead_xform(struct rte_crypto_op *op,
8024                 enum rte_crypto_aead_algorithm algo,
8025                 enum rte_crypto_aead_operation aead_op,
8026                 uint8_t *key, const uint8_t key_len,
8027                 const uint8_t aad_len, const uint8_t auth_len,
8028                 uint8_t iv_len)
8029 {
8030         TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 1),
8031                         "failed to allocate space for crypto transform");
8032
8033         struct rte_crypto_sym_op *sym_op = op->sym;
8034
8035         /* Setup AEAD Parameters */
8036         sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_AEAD;
8037         sym_op->xform->next = NULL;
8038         sym_op->xform->aead.algo = algo;
8039         sym_op->xform->aead.op = aead_op;
8040         sym_op->xform->aead.key.data = key;
8041         sym_op->xform->aead.key.length = key_len;
8042         sym_op->xform->aead.iv.offset = IV_OFFSET;
8043         sym_op->xform->aead.iv.length = iv_len;
8044         sym_op->xform->aead.digest_length = auth_len;
8045         sym_op->xform->aead.aad_length = aad_len;
8046
8047         debug_hexdump(stdout, "key:", key, key_len);
8048
8049         return 0;
8050 }
8051
8052 static int
8053 create_aead_operation(enum rte_crypto_aead_operation op,
8054                 const struct aead_test_data *tdata)
8055 {
8056         struct crypto_testsuite_params *ts_params = &testsuite_params;
8057         struct crypto_unittest_params *ut_params = &unittest_params;
8058
8059         uint8_t *plaintext, *ciphertext;
8060         unsigned int aad_pad_len, plaintext_pad_len;
8061
8062         /* Generate Crypto op data structure */
8063         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8064                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8065         TEST_ASSERT_NOT_NULL(ut_params->op,
8066                         "Failed to allocate symmetric crypto operation struct");
8067
8068         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
8069
8070         /* Append aad data */
8071         if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
8072                 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len + 18, 16);
8073                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8074                                 aad_pad_len);
8075                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
8076                                 "no room to append aad");
8077
8078                 sym_op->aead.aad.phys_addr =
8079                                 rte_pktmbuf_iova(ut_params->ibuf);
8080                 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
8081                 memcpy(sym_op->aead.aad.data + 18, tdata->aad.data, tdata->aad.len);
8082                 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
8083                         tdata->aad.len);
8084
8085                 /* Append IV at the end of the crypto operation*/
8086                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
8087                                 uint8_t *, IV_OFFSET);
8088
8089                 /* Copy IV 1 byte after the IV pointer, according to the API */
8090                 rte_memcpy(iv_ptr + 1, tdata->iv.data, tdata->iv.len);
8091                 debug_hexdump(stdout, "iv:", iv_ptr,
8092                         tdata->iv.len);
8093         } else {
8094                 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
8095                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8096                                 aad_pad_len);
8097                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
8098                                 "no room to append aad");
8099
8100                 sym_op->aead.aad.phys_addr =
8101                                 rte_pktmbuf_iova(ut_params->ibuf);
8102                 memcpy(sym_op->aead.aad.data, tdata->aad.data, tdata->aad.len);
8103                 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
8104                         tdata->aad.len);
8105
8106                 /* Append IV at the end of the crypto operation*/
8107                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
8108                                 uint8_t *, IV_OFFSET);
8109
8110                 if (tdata->iv.len == 0) {
8111                         rte_memcpy(iv_ptr, tdata->iv.data, AES_GCM_J0_LENGTH);
8112                         debug_hexdump(stdout, "iv:", iv_ptr,
8113                                 AES_GCM_J0_LENGTH);
8114                 } else {
8115                         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
8116                         debug_hexdump(stdout, "iv:", iv_ptr,
8117                                 tdata->iv.len);
8118                 }
8119         }
8120
8121         /* Append plaintext/ciphertext */
8122         if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
8123                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
8124                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8125                                 plaintext_pad_len);
8126                 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
8127
8128                 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
8129                 debug_hexdump(stdout, "plaintext:", plaintext,
8130                                 tdata->plaintext.len);
8131
8132                 if (ut_params->obuf) {
8133                         ciphertext = (uint8_t *)rte_pktmbuf_append(
8134                                         ut_params->obuf,
8135                                         plaintext_pad_len + aad_pad_len);
8136                         TEST_ASSERT_NOT_NULL(ciphertext,
8137                                         "no room to append ciphertext");
8138
8139                         memset(ciphertext + aad_pad_len, 0,
8140                                         tdata->ciphertext.len);
8141                 }
8142         } else {
8143                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16);
8144                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8145                                 plaintext_pad_len);
8146                 TEST_ASSERT_NOT_NULL(ciphertext,
8147                                 "no room to append ciphertext");
8148
8149                 memcpy(ciphertext, tdata->ciphertext.data,
8150                                 tdata->ciphertext.len);
8151                 debug_hexdump(stdout, "ciphertext:", ciphertext,
8152                                 tdata->ciphertext.len);
8153
8154                 if (ut_params->obuf) {
8155                         plaintext = (uint8_t *)rte_pktmbuf_append(
8156                                         ut_params->obuf,
8157                                         plaintext_pad_len + aad_pad_len);
8158                         TEST_ASSERT_NOT_NULL(plaintext,
8159                                         "no room to append plaintext");
8160
8161                         memset(plaintext + aad_pad_len, 0,
8162                                         tdata->plaintext.len);
8163                 }
8164         }
8165
8166         /* Append digest data */
8167         if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
8168                 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
8169                                 ut_params->obuf ? ut_params->obuf :
8170                                                 ut_params->ibuf,
8171                                                 tdata->auth_tag.len);
8172                 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
8173                                 "no room to append digest");
8174                 memset(sym_op->aead.digest.data, 0, tdata->auth_tag.len);
8175                 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
8176                                 ut_params->obuf ? ut_params->obuf :
8177                                                 ut_params->ibuf,
8178                                                 plaintext_pad_len +
8179                                                 aad_pad_len);
8180         } else {
8181                 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
8182                                 ut_params->ibuf, tdata->auth_tag.len);
8183                 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
8184                                 "no room to append digest");
8185                 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
8186                                 ut_params->ibuf,
8187                                 plaintext_pad_len + aad_pad_len);
8188
8189                 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
8190                         tdata->auth_tag.len);
8191                 debug_hexdump(stdout, "digest:",
8192                         sym_op->aead.digest.data,
8193                         tdata->auth_tag.len);
8194         }
8195
8196         sym_op->aead.data.length = tdata->plaintext.len;
8197         sym_op->aead.data.offset = aad_pad_len;
8198
8199         return 0;
8200 }
8201
8202 static int
8203 test_authenticated_encryption(const struct aead_test_data *tdata)
8204 {
8205         struct crypto_testsuite_params *ts_params = &testsuite_params;
8206         struct crypto_unittest_params *ut_params = &unittest_params;
8207
8208         int retval;
8209         uint8_t *ciphertext, *auth_tag;
8210         uint16_t plaintext_pad_len;
8211         uint32_t i;
8212         struct rte_cryptodev_info dev_info;
8213
8214         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8215         uint64_t feat_flags = dev_info.feature_flags;
8216
8217         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
8218                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
8219                 printf("Device doesn't support RAW data-path APIs.\n");
8220                 return TEST_SKIPPED;
8221         }
8222
8223         /* Verify the capabilities */
8224         struct rte_cryptodev_sym_capability_idx cap_idx;
8225         const struct rte_cryptodev_symmetric_capability *capability;
8226         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
8227         cap_idx.algo.aead = tdata->algo;
8228         capability = rte_cryptodev_sym_capability_get(
8229                         ts_params->valid_devs[0], &cap_idx);
8230         if (capability == NULL)
8231                 return TEST_SKIPPED;
8232         if (rte_cryptodev_sym_capability_check_aead(
8233                         capability, tdata->key.len, tdata->auth_tag.len,
8234                         tdata->aad.len, tdata->iv.len))
8235                 return TEST_SKIPPED;
8236
8237         /* Create AEAD session */
8238         retval = create_aead_session(ts_params->valid_devs[0],
8239                         tdata->algo,
8240                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
8241                         tdata->key.data, tdata->key.len,
8242                         tdata->aad.len, tdata->auth_tag.len,
8243                         tdata->iv.len);
8244         if (retval < 0)
8245                 return retval;
8246
8247         if (tdata->aad.len > MBUF_SIZE) {
8248                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
8249                 /* Populate full size of add data */
8250                 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
8251                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
8252         } else
8253                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8254
8255         /* clear mbuf payload */
8256         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8257                         rte_pktmbuf_tailroom(ut_params->ibuf));
8258
8259         /* Create AEAD operation */
8260         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
8261         if (retval < 0)
8262                 return retval;
8263
8264         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
8265
8266         ut_params->op->sym->m_src = ut_params->ibuf;
8267
8268         /* Process crypto operation */
8269         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
8270                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
8271         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
8272                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
8273                                 ut_params->op, 0, 0, 0, 0);
8274         else
8275                 TEST_ASSERT_NOT_NULL(
8276                         process_crypto_request(ts_params->valid_devs[0],
8277                         ut_params->op), "failed to process sym crypto op");
8278
8279         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8280                         "crypto op processing failed");
8281
8282         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
8283
8284         if (ut_params->op->sym->m_dst) {
8285                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8286                                 uint8_t *);
8287                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
8288                                 uint8_t *, plaintext_pad_len);
8289         } else {
8290                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
8291                                 uint8_t *,
8292                                 ut_params->op->sym->cipher.data.offset);
8293                 auth_tag = ciphertext + plaintext_pad_len;
8294         }
8295
8296         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
8297         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
8298
8299         /* Validate obuf */
8300         TEST_ASSERT_BUFFERS_ARE_EQUAL(
8301                         ciphertext,
8302                         tdata->ciphertext.data,
8303                         tdata->ciphertext.len,
8304                         "Ciphertext data not as expected");
8305
8306         TEST_ASSERT_BUFFERS_ARE_EQUAL(
8307                         auth_tag,
8308                         tdata->auth_tag.data,
8309                         tdata->auth_tag.len,
8310                         "Generated auth tag not as expected");
8311
8312         return 0;
8313
8314 }
8315
8316 #ifdef RTE_LIB_SECURITY
8317 static int
8318 security_proto_supported(enum rte_security_session_action_type action,
8319         enum rte_security_session_protocol proto)
8320 {
8321         struct crypto_testsuite_params *ts_params = &testsuite_params;
8322
8323         const struct rte_security_capability *capabilities;
8324         const struct rte_security_capability *capability;
8325         uint16_t i = 0;
8326
8327         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8328                                 rte_cryptodev_get_sec_ctx(
8329                                 ts_params->valid_devs[0]);
8330
8331
8332         capabilities = rte_security_capabilities_get(ctx);
8333
8334         if (capabilities == NULL)
8335                 return -ENOTSUP;
8336
8337         while ((capability = &capabilities[i++])->action !=
8338                         RTE_SECURITY_ACTION_TYPE_NONE) {
8339                 if (capability->action == action &&
8340                                 capability->protocol == proto)
8341                         return 0;
8342         }
8343
8344         return -ENOTSUP;
8345 }
8346
8347 /* Basic algorithm run function for async inplace mode.
8348  * Creates a session from input parameters and runs one operation
8349  * on input_vec. Checks the output of the crypto operation against
8350  * output_vec.
8351  */
8352 static int test_pdcp_proto(int i, int oop, enum rte_crypto_cipher_operation opc,
8353                            enum rte_crypto_auth_operation opa,
8354                            const uint8_t *input_vec, unsigned int input_vec_len,
8355                            const uint8_t *output_vec,
8356                            unsigned int output_vec_len,
8357                            enum rte_crypto_cipher_algorithm cipher_alg,
8358                            const uint8_t *cipher_key, uint32_t cipher_key_len,
8359                            enum rte_crypto_auth_algorithm auth_alg,
8360                            const uint8_t *auth_key, uint32_t auth_key_len,
8361                            uint8_t bearer, enum rte_security_pdcp_domain domain,
8362                            uint8_t packet_direction, uint8_t sn_size,
8363                            uint32_t hfn, uint32_t hfn_threshold, uint8_t sdap)
8364 {
8365         struct crypto_testsuite_params *ts_params = &testsuite_params;
8366         struct crypto_unittest_params *ut_params = &unittest_params;
8367         uint8_t *plaintext;
8368         int ret = TEST_SUCCESS;
8369         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8370                                 rte_cryptodev_get_sec_ctx(
8371                                 ts_params->valid_devs[0]);
8372
8373         /* Verify the capabilities */
8374         struct rte_security_capability_idx sec_cap_idx;
8375
8376         sec_cap_idx.action = ut_params->type;
8377         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
8378         sec_cap_idx.pdcp.domain = domain;
8379         if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
8380                 return TEST_SKIPPED;
8381
8382         /* Generate test mbuf data */
8383         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8384
8385         /* clear mbuf payload */
8386         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8387                         rte_pktmbuf_tailroom(ut_params->ibuf));
8388
8389         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8390                                                   input_vec_len);
8391         memcpy(plaintext, input_vec, input_vec_len);
8392
8393         /* Out of place support */
8394         if (oop) {
8395                 /*
8396                  * For out-op-place we need to alloc another mbuf
8397                  */
8398                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8399                 rte_pktmbuf_append(ut_params->obuf, output_vec_len);
8400         }
8401
8402         /* Setup Cipher Parameters */
8403         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8404         ut_params->cipher_xform.cipher.algo = cipher_alg;
8405         ut_params->cipher_xform.cipher.op = opc;
8406         ut_params->cipher_xform.cipher.key.data = cipher_key;
8407         ut_params->cipher_xform.cipher.key.length = cipher_key_len;
8408         ut_params->cipher_xform.cipher.iv.length =
8409                                 packet_direction ? 4 : 0;
8410         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
8411
8412         /* Setup HMAC Parameters if ICV header is required */
8413         if (auth_alg != 0) {
8414                 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8415                 ut_params->auth_xform.next = NULL;
8416                 ut_params->auth_xform.auth.algo = auth_alg;
8417                 ut_params->auth_xform.auth.op = opa;
8418                 ut_params->auth_xform.auth.key.data = auth_key;
8419                 ut_params->auth_xform.auth.key.length = auth_key_len;
8420
8421                 ut_params->cipher_xform.next = &ut_params->auth_xform;
8422         } else {
8423                 ut_params->cipher_xform.next = NULL;
8424         }
8425
8426         struct rte_security_session_conf sess_conf = {
8427                 .action_type = ut_params->type,
8428                 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
8429                 {.pdcp = {
8430                         .bearer = bearer,
8431                         .domain = domain,
8432                         .pkt_dir = packet_direction,
8433                         .sn_size = sn_size,
8434                         .hfn = packet_direction ? 0 : hfn,
8435                         /**
8436                          * hfn can be set as pdcp_test_hfn[i]
8437                          * if hfn_ovrd is not set. Here, PDCP
8438                          * packet direction is just used to
8439                          * run half of the cases with session
8440                          * HFN and other half with per packet
8441                          * HFN.
8442                          */
8443                         .hfn_threshold = hfn_threshold,
8444                         .hfn_ovrd = packet_direction ? 1 : 0,
8445                         .sdap_enabled = sdap,
8446                 } },
8447                 .crypto_xform = &ut_params->cipher_xform
8448         };
8449
8450         /* Create security session */
8451         ut_params->sec_session = rte_security_session_create(ctx,
8452                                 &sess_conf, ts_params->session_mpool,
8453                                 ts_params->session_priv_mpool);
8454
8455         if (!ut_params->sec_session) {
8456                 printf("TestCase %s()-%d line %d failed %s: ",
8457                         __func__, i, __LINE__, "Failed to allocate session");
8458                 ret = TEST_FAILED;
8459                 goto on_err;
8460         }
8461
8462         /* Generate crypto op data structure */
8463         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8464                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8465         if (!ut_params->op) {
8466                 printf("TestCase %s()-%d line %d failed %s: ",
8467                         __func__, i, __LINE__,
8468                         "Failed to allocate symmetric crypto operation struct");
8469                 ret = TEST_FAILED;
8470                 goto on_err;
8471         }
8472
8473         uint32_t *per_pkt_hfn = rte_crypto_op_ctod_offset(ut_params->op,
8474                                         uint32_t *, IV_OFFSET);
8475         *per_pkt_hfn = packet_direction ? hfn : 0;
8476
8477         rte_security_attach_session(ut_params->op, ut_params->sec_session);
8478
8479         /* set crypto operation source mbuf */
8480         ut_params->op->sym->m_src = ut_params->ibuf;
8481         if (oop)
8482                 ut_params->op->sym->m_dst = ut_params->obuf;
8483
8484         /* Process crypto operation */
8485         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op)
8486                 == NULL) {
8487                 printf("TestCase %s()-%d line %d failed %s: ",
8488                         __func__, i, __LINE__,
8489                         "failed to process sym crypto op");
8490                 ret = TEST_FAILED;
8491                 goto on_err;
8492         }
8493
8494         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8495                 printf("TestCase %s()-%d line %d failed %s: ",
8496                         __func__, i, __LINE__, "crypto op processing failed");
8497                 ret = TEST_FAILED;
8498                 goto on_err;
8499         }
8500
8501         /* Validate obuf */
8502         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
8503                         uint8_t *);
8504         if (oop) {
8505                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8506                                 uint8_t *);
8507         }
8508
8509         if (memcmp(ciphertext, output_vec, output_vec_len)) {
8510                 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8511                 rte_hexdump(stdout, "encrypted", ciphertext, output_vec_len);
8512                 rte_hexdump(stdout, "reference", output_vec, output_vec_len);
8513                 ret = TEST_FAILED;
8514                 goto on_err;
8515         }
8516
8517 on_err:
8518         rte_crypto_op_free(ut_params->op);
8519         ut_params->op = NULL;
8520
8521         if (ut_params->sec_session)
8522                 rte_security_session_destroy(ctx, ut_params->sec_session);
8523         ut_params->sec_session = NULL;
8524
8525         rte_pktmbuf_free(ut_params->ibuf);
8526         ut_params->ibuf = NULL;
8527         if (oop) {
8528                 rte_pktmbuf_free(ut_params->obuf);
8529                 ut_params->obuf = NULL;
8530         }
8531
8532         return ret;
8533 }
8534
8535 static int
8536 test_pdcp_proto_SGL(int i, int oop,
8537         enum rte_crypto_cipher_operation opc,
8538         enum rte_crypto_auth_operation opa,
8539         uint8_t *input_vec,
8540         unsigned int input_vec_len,
8541         uint8_t *output_vec,
8542         unsigned int output_vec_len,
8543         uint32_t fragsz,
8544         uint32_t fragsz_oop)
8545 {
8546         struct crypto_testsuite_params *ts_params = &testsuite_params;
8547         struct crypto_unittest_params *ut_params = &unittest_params;
8548         uint8_t *plaintext;
8549         struct rte_mbuf *buf, *buf_oop = NULL;
8550         int ret = TEST_SUCCESS;
8551         int to_trn = 0;
8552         int to_trn_tbl[16];
8553         int segs = 1;
8554         unsigned int trn_data = 0;
8555         struct rte_cryptodev_info dev_info;
8556         uint64_t feat_flags;
8557         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8558                                 rte_cryptodev_get_sec_ctx(
8559                                 ts_params->valid_devs[0]);
8560         struct rte_mbuf *temp_mbuf;
8561
8562         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8563         feat_flags = dev_info.feature_flags;
8564
8565         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
8566                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
8567                 printf("Device does not support RAW data-path APIs.\n");
8568                 return -ENOTSUP;
8569         }
8570         /* Verify the capabilities */
8571         struct rte_security_capability_idx sec_cap_idx;
8572
8573         sec_cap_idx.action = ut_params->type;
8574         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
8575         sec_cap_idx.pdcp.domain = pdcp_test_params[i].domain;
8576         if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
8577                 return TEST_SKIPPED;
8578
8579         if (fragsz > input_vec_len)
8580                 fragsz = input_vec_len;
8581
8582         uint16_t plaintext_len = fragsz;
8583         uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
8584
8585         if (fragsz_oop > output_vec_len)
8586                 frag_size_oop = output_vec_len;
8587
8588         int ecx = 0;
8589         if (input_vec_len % fragsz != 0) {
8590                 if (input_vec_len / fragsz + 1 > 16)
8591                         return 1;
8592         } else if (input_vec_len / fragsz > 16)
8593                 return 1;
8594
8595         /* Out of place support */
8596         if (oop) {
8597                 /*
8598                  * For out-op-place we need to alloc another mbuf
8599                  */
8600                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8601                 rte_pktmbuf_append(ut_params->obuf, frag_size_oop);
8602                 buf_oop = ut_params->obuf;
8603         }
8604
8605         /* Generate test mbuf data */
8606         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8607
8608         /* clear mbuf payload */
8609         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8610                         rte_pktmbuf_tailroom(ut_params->ibuf));
8611
8612         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8613                                                   plaintext_len);
8614         memcpy(plaintext, input_vec, plaintext_len);
8615         trn_data += plaintext_len;
8616
8617         buf = ut_params->ibuf;
8618
8619         /*
8620          * Loop until no more fragments
8621          */
8622
8623         while (trn_data < input_vec_len) {
8624                 ++segs;
8625                 to_trn = (input_vec_len - trn_data < fragsz) ?
8626                                 (input_vec_len - trn_data) : fragsz;
8627
8628                 to_trn_tbl[ecx++] = to_trn;
8629
8630                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8631                 buf = buf->next;
8632
8633                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
8634                                 rte_pktmbuf_tailroom(buf));
8635
8636                 /* OOP */
8637                 if (oop && !fragsz_oop) {
8638                         buf_oop->next =
8639                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
8640                         buf_oop = buf_oop->next;
8641                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8642                                         0, rte_pktmbuf_tailroom(buf_oop));
8643                         rte_pktmbuf_append(buf_oop, to_trn);
8644                 }
8645
8646                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
8647                                 to_trn);
8648
8649                 memcpy(plaintext, input_vec + trn_data, to_trn);
8650                 trn_data += to_trn;
8651         }
8652
8653         ut_params->ibuf->nb_segs = segs;
8654
8655         segs = 1;
8656         if (fragsz_oop && oop) {
8657                 to_trn = 0;
8658                 ecx = 0;
8659
8660                 trn_data = frag_size_oop;
8661                 while (trn_data < output_vec_len) {
8662                         ++segs;
8663                         to_trn =
8664                                 (output_vec_len - trn_data <
8665                                                 frag_size_oop) ?
8666                                 (output_vec_len - trn_data) :
8667                                                 frag_size_oop;
8668
8669                         to_trn_tbl[ecx++] = to_trn;
8670
8671                         buf_oop->next =
8672                                 rte_pktmbuf_alloc(ts_params->mbuf_pool);
8673                         buf_oop = buf_oop->next;
8674                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8675                                         0, rte_pktmbuf_tailroom(buf_oop));
8676                         rte_pktmbuf_append(buf_oop, to_trn);
8677
8678                         trn_data += to_trn;
8679                 }
8680                 ut_params->obuf->nb_segs = segs;
8681         }
8682
8683         /* Setup Cipher Parameters */
8684         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8685         ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg;
8686         ut_params->cipher_xform.cipher.op = opc;
8687         ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i];
8688         ut_params->cipher_xform.cipher.key.length =
8689                                         pdcp_test_params[i].cipher_key_len;
8690         ut_params->cipher_xform.cipher.iv.length = 0;
8691
8692         /* Setup HMAC Parameters if ICV header is required */
8693         if (pdcp_test_params[i].auth_alg != 0) {
8694                 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8695                 ut_params->auth_xform.next = NULL;
8696                 ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg;
8697                 ut_params->auth_xform.auth.op = opa;
8698                 ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i];
8699                 ut_params->auth_xform.auth.key.length =
8700                                         pdcp_test_params[i].auth_key_len;
8701
8702                 ut_params->cipher_xform.next = &ut_params->auth_xform;
8703         } else {
8704                 ut_params->cipher_xform.next = NULL;
8705         }
8706
8707         struct rte_security_session_conf sess_conf = {
8708                 .action_type = ut_params->type,
8709                 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
8710                 {.pdcp = {
8711                         .bearer = pdcp_test_bearer[i],
8712                         .domain = pdcp_test_params[i].domain,
8713                         .pkt_dir = pdcp_test_packet_direction[i],
8714                         .sn_size = pdcp_test_data_sn_size[i],
8715                         .hfn = pdcp_test_hfn[i],
8716                         .hfn_threshold = pdcp_test_hfn_threshold[i],
8717                         .hfn_ovrd = 0,
8718                 } },
8719                 .crypto_xform = &ut_params->cipher_xform
8720         };
8721
8722         /* Create security session */
8723         ut_params->sec_session = rte_security_session_create(ctx,
8724                                 &sess_conf, ts_params->session_mpool,
8725                                 ts_params->session_priv_mpool);
8726
8727         if (!ut_params->sec_session) {
8728                 printf("TestCase %s()-%d line %d failed %s: ",
8729                         __func__, i, __LINE__, "Failed to allocate session");
8730                 ret = TEST_FAILED;
8731                 goto on_err;
8732         }
8733
8734         /* Generate crypto op data structure */
8735         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8736                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8737         if (!ut_params->op) {
8738                 printf("TestCase %s()-%d line %d failed %s: ",
8739                         __func__, i, __LINE__,
8740                         "Failed to allocate symmetric crypto operation struct");
8741                 ret = TEST_FAILED;
8742                 goto on_err;
8743         }
8744
8745         rte_security_attach_session(ut_params->op, ut_params->sec_session);
8746
8747         /* set crypto operation source mbuf */
8748         ut_params->op->sym->m_src = ut_params->ibuf;
8749         if (oop)
8750                 ut_params->op->sym->m_dst = ut_params->obuf;
8751
8752         /* Process crypto operation */
8753         temp_mbuf = ut_params->op->sym->m_src;
8754         if (global_api_test_type == CRYPTODEV_RAW_API_TEST) {
8755                 /* filling lengths */
8756                 while (temp_mbuf) {
8757                         ut_params->op->sym->cipher.data.length
8758                                 += temp_mbuf->pkt_len;
8759                         ut_params->op->sym->auth.data.length
8760                                 += temp_mbuf->pkt_len;
8761                         temp_mbuf = temp_mbuf->next;
8762                 }
8763                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
8764                         ut_params->op, 1, 1, 0, 0);
8765         } else {
8766                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
8767                                                         ut_params->op);
8768         }
8769         if (ut_params->op == NULL) {
8770                 printf("TestCase %s()-%d line %d failed %s: ",
8771                         __func__, i, __LINE__,
8772                         "failed to process sym crypto op");
8773                 ret = TEST_FAILED;
8774                 goto on_err;
8775         }
8776
8777         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8778                 printf("TestCase %s()-%d line %d failed %s: ",
8779                         __func__, i, __LINE__, "crypto op processing failed");
8780                 ret = TEST_FAILED;
8781                 goto on_err;
8782         }
8783
8784         /* Validate obuf */
8785         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
8786                         uint8_t *);
8787         if (oop) {
8788                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8789                                 uint8_t *);
8790         }
8791         if (fragsz_oop)
8792                 fragsz = frag_size_oop;
8793         if (memcmp(ciphertext, output_vec, fragsz)) {
8794                 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8795                 rte_hexdump(stdout, "encrypted", ciphertext, fragsz);
8796                 rte_hexdump(stdout, "reference", output_vec, fragsz);
8797                 ret = TEST_FAILED;
8798                 goto on_err;
8799         }
8800
8801         buf = ut_params->op->sym->m_src->next;
8802         if (oop)
8803                 buf = ut_params->op->sym->m_dst->next;
8804
8805         unsigned int off = fragsz;
8806
8807         ecx = 0;
8808         while (buf) {
8809                 ciphertext = rte_pktmbuf_mtod(buf,
8810                                 uint8_t *);
8811                 if (memcmp(ciphertext, output_vec + off, to_trn_tbl[ecx])) {
8812                         printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8813                         rte_hexdump(stdout, "encrypted", ciphertext, to_trn_tbl[ecx]);
8814                         rte_hexdump(stdout, "reference", output_vec + off,
8815                                         to_trn_tbl[ecx]);
8816                         ret = TEST_FAILED;
8817                         goto on_err;
8818                 }
8819                 off += to_trn_tbl[ecx++];
8820                 buf = buf->next;
8821         }
8822 on_err:
8823         rte_crypto_op_free(ut_params->op);
8824         ut_params->op = NULL;
8825
8826         if (ut_params->sec_session)
8827                 rte_security_session_destroy(ctx, ut_params->sec_session);
8828         ut_params->sec_session = NULL;
8829
8830         rte_pktmbuf_free(ut_params->ibuf);
8831         ut_params->ibuf = NULL;
8832         if (oop) {
8833                 rte_pktmbuf_free(ut_params->obuf);
8834                 ut_params->obuf = NULL;
8835         }
8836
8837         return ret;
8838 }
8839
8840 int
8841 test_pdcp_proto_cplane_encap(int i)
8842 {
8843         return test_pdcp_proto(
8844                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8845                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8846                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8847                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8848                 pdcp_test_params[i].cipher_key_len,
8849                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8850                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8851                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8852                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8853                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8854 }
8855
8856 int
8857 test_pdcp_proto_uplane_encap(int i)
8858 {
8859         return test_pdcp_proto(
8860                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8861                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8862                 pdcp_test_data_out[i], pdcp_test_data_in_len[i],
8863                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8864                 pdcp_test_params[i].cipher_key_len,
8865                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8866                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8867                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8868                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8869                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8870 }
8871
8872 int
8873 test_pdcp_proto_uplane_encap_with_int(int i)
8874 {
8875         return test_pdcp_proto(
8876                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8877                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8878                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8879                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8880                 pdcp_test_params[i].cipher_key_len,
8881                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8882                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8883                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8884                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8885                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8886 }
8887
8888 int
8889 test_pdcp_proto_cplane_decap(int i)
8890 {
8891         return test_pdcp_proto(
8892                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8893                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8894                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8895                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8896                 pdcp_test_params[i].cipher_key_len,
8897                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8898                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8899                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8900                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8901                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8902 }
8903
8904 int
8905 test_pdcp_proto_uplane_decap(int i)
8906 {
8907         return test_pdcp_proto(
8908                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8909                 pdcp_test_data_out[i], pdcp_test_data_in_len[i],
8910                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8911                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8912                 pdcp_test_params[i].cipher_key_len,
8913                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8914                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8915                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8916                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8917                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8918 }
8919
8920 int
8921 test_pdcp_proto_uplane_decap_with_int(int i)
8922 {
8923         return test_pdcp_proto(
8924                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8925                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8926                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8927                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8928                 pdcp_test_params[i].cipher_key_len,
8929                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8930                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8931                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8932                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8933                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8934 }
8935
8936 static int
8937 test_PDCP_PROTO_SGL_in_place_32B(void)
8938 {
8939         /* i can be used for running any PDCP case
8940          * In this case it is uplane 12-bit AES-SNOW DL encap
8941          */
8942         int i = PDCP_UPLANE_12BIT_OFFSET + AES_ENC + SNOW_AUTH + DOWNLINK;
8943         return test_pdcp_proto_SGL(i, IN_PLACE,
8944                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8945                         RTE_CRYPTO_AUTH_OP_GENERATE,
8946                         pdcp_test_data_in[i],
8947                         pdcp_test_data_in_len[i],
8948                         pdcp_test_data_out[i],
8949                         pdcp_test_data_in_len[i]+4,
8950                         32, 0);
8951 }
8952 static int
8953 test_PDCP_PROTO_SGL_oop_32B_128B(void)
8954 {
8955         /* i can be used for running any PDCP case
8956          * In this case it is uplane 18-bit NULL-NULL DL encap
8957          */
8958         int i = PDCP_UPLANE_18BIT_OFFSET + NULL_ENC + NULL_AUTH + DOWNLINK;
8959         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8960                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8961                         RTE_CRYPTO_AUTH_OP_GENERATE,
8962                         pdcp_test_data_in[i],
8963                         pdcp_test_data_in_len[i],
8964                         pdcp_test_data_out[i],
8965                         pdcp_test_data_in_len[i]+4,
8966                         32, 128);
8967 }
8968 static int
8969 test_PDCP_PROTO_SGL_oop_32B_40B(void)
8970 {
8971         /* i can be used for running any PDCP case
8972          * In this case it is uplane 18-bit AES DL encap
8973          */
8974         int i = PDCP_UPLANE_OFFSET + AES_ENC + EIGHTEEN_BIT_SEQ_NUM_OFFSET
8975                         + DOWNLINK;
8976         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8977                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8978                         RTE_CRYPTO_AUTH_OP_GENERATE,
8979                         pdcp_test_data_in[i],
8980                         pdcp_test_data_in_len[i],
8981                         pdcp_test_data_out[i],
8982                         pdcp_test_data_in_len[i],
8983                         32, 40);
8984 }
8985 static int
8986 test_PDCP_PROTO_SGL_oop_128B_32B(void)
8987 {
8988         /* i can be used for running any PDCP case
8989          * In this case it is cplane 12-bit AES-ZUC DL encap
8990          */
8991         int i = PDCP_CPLANE_LONG_SN_OFFSET + AES_ENC + ZUC_AUTH + DOWNLINK;
8992         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8993                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8994                         RTE_CRYPTO_AUTH_OP_GENERATE,
8995                         pdcp_test_data_in[i],
8996                         pdcp_test_data_in_len[i],
8997                         pdcp_test_data_out[i],
8998                         pdcp_test_data_in_len[i]+4,
8999                         128, 32);
9000 }
9001
9002 static int
9003 test_PDCP_SDAP_PROTO_encap_all(void)
9004 {
9005         int i = 0, size = 0;
9006         int err, all_err = TEST_SUCCESS;
9007         const struct pdcp_sdap_test *cur_test;
9008
9009         size = RTE_DIM(list_pdcp_sdap_tests);
9010
9011         for (i = 0; i < size; i++) {
9012                 cur_test = &list_pdcp_sdap_tests[i];
9013                 err = test_pdcp_proto(
9014                         i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT,
9015                         RTE_CRYPTO_AUTH_OP_GENERATE, cur_test->data_in,
9016                         cur_test->in_len, cur_test->data_out,
9017                         cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
9018                         cur_test->param.cipher_alg, cur_test->cipher_key,
9019                         cur_test->param.cipher_key_len,
9020                         cur_test->param.auth_alg,
9021                         cur_test->auth_key, cur_test->param.auth_key_len,
9022                         cur_test->bearer, cur_test->param.domain,
9023                         cur_test->packet_direction, cur_test->sn_size,
9024                         cur_test->hfn,
9025                         cur_test->hfn_threshold, SDAP_ENABLED);
9026                 if (err) {
9027                         printf("\t%d) %s: Encapsulation failed\n",
9028                                         cur_test->test_idx,
9029                                         cur_test->param.name);
9030                         err = TEST_FAILED;
9031                 } else {
9032                         printf("\t%d) %s: Encap PASS\n", cur_test->test_idx,
9033                                         cur_test->param.name);
9034                         err = TEST_SUCCESS;
9035                 }
9036                 all_err += err;
9037         }
9038
9039         printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
9040
9041         return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
9042 }
9043
9044 static int
9045 test_PDCP_PROTO_short_mac(void)
9046 {
9047         int i = 0, size = 0;
9048         int err, all_err = TEST_SUCCESS;
9049         const struct pdcp_short_mac_test *cur_test;
9050
9051         size = RTE_DIM(list_pdcp_smac_tests);
9052
9053         for (i = 0; i < size; i++) {
9054                 cur_test = &list_pdcp_smac_tests[i];
9055                 err = test_pdcp_proto(
9056                         i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT,
9057                         RTE_CRYPTO_AUTH_OP_GENERATE, cur_test->data_in,
9058                         cur_test->in_len, cur_test->data_out,
9059                         cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
9060                         RTE_CRYPTO_CIPHER_NULL, NULL,
9061                         0, cur_test->param.auth_alg,
9062                         cur_test->auth_key, cur_test->param.auth_key_len,
9063                         0, cur_test->param.domain, 0, 0,
9064                         0, 0, 0);
9065                 if (err) {
9066                         printf("\t%d) %s: Short MAC test failed\n",
9067                                         cur_test->test_idx,
9068                                         cur_test->param.name);
9069                         err = TEST_FAILED;
9070                 } else {
9071                         printf("\t%d) %s: Short MAC test PASS\n",
9072                                         cur_test->test_idx,
9073                                         cur_test->param.name);
9074                         rte_hexdump(stdout, "MAC I",
9075                                     cur_test->data_out + cur_test->in_len + 2,
9076                                     2);
9077                         err = TEST_SUCCESS;
9078                 }
9079                 all_err += err;
9080         }
9081
9082         printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
9083
9084         return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
9085
9086 }
9087
9088 static int
9089 test_PDCP_SDAP_PROTO_decap_all(void)
9090 {
9091         int i = 0, size = 0;
9092         int err, all_err = TEST_SUCCESS;
9093         const struct pdcp_sdap_test *cur_test;
9094
9095         size = RTE_DIM(list_pdcp_sdap_tests);
9096
9097         for (i = 0; i < size; i++) {
9098                 cur_test = &list_pdcp_sdap_tests[i];
9099                 err = test_pdcp_proto(
9100                         i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT,
9101                         RTE_CRYPTO_AUTH_OP_VERIFY,
9102                         cur_test->data_out,
9103                         cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
9104                         cur_test->data_in, cur_test->in_len,
9105                         cur_test->param.cipher_alg,
9106                         cur_test->cipher_key, cur_test->param.cipher_key_len,
9107                         cur_test->param.auth_alg, cur_test->auth_key,
9108                         cur_test->param.auth_key_len, cur_test->bearer,
9109                         cur_test->param.domain, cur_test->packet_direction,
9110                         cur_test->sn_size, cur_test->hfn,
9111                         cur_test->hfn_threshold, SDAP_ENABLED);
9112                 if (err) {
9113                         printf("\t%d) %s: Decapsulation failed\n",
9114                                         cur_test->test_idx,
9115                                         cur_test->param.name);
9116                         err = TEST_FAILED;
9117                 } else {
9118                         printf("\t%d) %s: Decap PASS\n", cur_test->test_idx,
9119                                         cur_test->param.name);
9120                         err = TEST_SUCCESS;
9121                 }
9122                 all_err += err;
9123         }
9124
9125         printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
9126
9127         return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
9128 }
9129
9130 static int
9131 test_ipsec_proto_process(const struct ipsec_test_data td[],
9132                          struct ipsec_test_data res_d[],
9133                          int nb_td,
9134                          bool silent,
9135                          const struct ipsec_test_flags *flags)
9136 {
9137         uint16_t v6_src[8] = {0x2607, 0xf8b0, 0x400c, 0x0c03, 0x0000, 0x0000,
9138                                 0x0000, 0x001a};
9139         uint16_t v6_dst[8] = {0x2001, 0x0470, 0xe5bf, 0xdead, 0x4957, 0x2174,
9140                                 0xe82c, 0x4887};
9141         struct crypto_testsuite_params *ts_params = &testsuite_params;
9142         struct crypto_unittest_params *ut_params = &unittest_params;
9143         struct rte_security_capability_idx sec_cap_idx;
9144         const struct rte_security_capability *sec_cap;
9145         struct rte_security_ipsec_xform ipsec_xform;
9146         uint8_t dev_id = ts_params->valid_devs[0];
9147         enum rte_security_ipsec_sa_direction dir;
9148         struct ipsec_test_data *res_d_tmp = NULL;
9149         uint32_t src = RTE_IPV4(192, 168, 1, 0);
9150         uint32_t dst = RTE_IPV4(192, 168, 1, 1);
9151         int salt_len, i, ret = TEST_SUCCESS;
9152         struct rte_security_ctx *ctx;
9153         uint8_t *input_text;
9154         uint32_t verify;
9155
9156         ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
9157         gbl_action_type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
9158
9159         /* Use first test data to create session */
9160
9161         /* Copy IPsec xform */
9162         memcpy(&ipsec_xform, &td[0].ipsec_xform, sizeof(ipsec_xform));
9163
9164         dir = ipsec_xform.direction;
9165         verify = flags->tunnel_hdr_verify;
9166
9167         if ((dir == RTE_SECURITY_IPSEC_SA_DIR_INGRESS) && verify) {
9168                 if (verify == RTE_SECURITY_IPSEC_TUNNEL_VERIFY_SRC_DST_ADDR)
9169                         src += 1;
9170                 else if (verify == RTE_SECURITY_IPSEC_TUNNEL_VERIFY_DST_ADDR)
9171                         dst += 1;
9172         }
9173
9174         if (td->ipsec_xform.mode == RTE_SECURITY_IPSEC_SA_MODE_TUNNEL) {
9175                 if (td->ipsec_xform.tunnel.type ==
9176                                 RTE_SECURITY_IPSEC_TUNNEL_IPV4) {
9177                         memcpy(&ipsec_xform.tunnel.ipv4.src_ip, &src,
9178                                sizeof(src));
9179                         memcpy(&ipsec_xform.tunnel.ipv4.dst_ip, &dst,
9180                                sizeof(dst));
9181
9182                         if (flags->df == TEST_IPSEC_SET_DF_0_INNER_1)
9183                                 ipsec_xform.tunnel.ipv4.df = 0;
9184
9185                         if (flags->df == TEST_IPSEC_SET_DF_1_INNER_0)
9186                                 ipsec_xform.tunnel.ipv4.df = 1;
9187
9188                 } else {
9189                         memcpy(&ipsec_xform.tunnel.ipv6.src_addr, &v6_src,
9190                                sizeof(v6_src));
9191                         memcpy(&ipsec_xform.tunnel.ipv6.dst_addr, &v6_dst,
9192                                sizeof(v6_dst));
9193                 }
9194         }
9195
9196         ctx = rte_cryptodev_get_sec_ctx(dev_id);
9197
9198         sec_cap_idx.action = ut_params->type;
9199         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_IPSEC;
9200         sec_cap_idx.ipsec.proto = ipsec_xform.proto;
9201         sec_cap_idx.ipsec.mode = ipsec_xform.mode;
9202         sec_cap_idx.ipsec.direction = ipsec_xform.direction;
9203
9204         if (flags->udp_encap)
9205                 ipsec_xform.options.udp_encap = 1;
9206
9207         sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
9208         if (sec_cap == NULL)
9209                 return TEST_SKIPPED;
9210
9211         /* Copy cipher session parameters */
9212         if (td[0].aead) {
9213                 memcpy(&ut_params->aead_xform, &td[0].xform.aead,
9214                        sizeof(ut_params->aead_xform));
9215                 ut_params->aead_xform.aead.key.data = td[0].key.data;
9216                 ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
9217
9218                 /* Verify crypto capabilities */
9219                 if (test_ipsec_crypto_caps_aead_verify(
9220                                 sec_cap,
9221                                 &ut_params->aead_xform) != 0) {
9222                         if (!silent)
9223                                 RTE_LOG(INFO, USER1,
9224                                         "Crypto capabilities not supported\n");
9225                         return TEST_SKIPPED;
9226                 }
9227         } else {
9228                 memcpy(&ut_params->cipher_xform, &td[0].xform.chain.cipher,
9229                        sizeof(ut_params->cipher_xform));
9230                 memcpy(&ut_params->auth_xform, &td[0].xform.chain.auth,
9231                        sizeof(ut_params->auth_xform));
9232                 ut_params->cipher_xform.cipher.key.data = td[0].key.data;
9233                 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
9234                 ut_params->auth_xform.auth.key.data = td[0].auth_key.data;
9235
9236                 /* Verify crypto capabilities */
9237
9238                 if (test_ipsec_crypto_caps_cipher_verify(
9239                                 sec_cap,
9240                                 &ut_params->cipher_xform) != 0) {
9241                         if (!silent)
9242                                 RTE_LOG(INFO, USER1,
9243                                         "Cipher crypto capabilities not supported\n");
9244                         return TEST_SKIPPED;
9245                 }
9246
9247                 if (test_ipsec_crypto_caps_auth_verify(
9248                                 sec_cap,
9249                                 &ut_params->auth_xform) != 0) {
9250                         if (!silent)
9251                                 RTE_LOG(INFO, USER1,
9252                                         "Auth crypto capabilities not supported\n");
9253                         return TEST_SKIPPED;
9254                 }
9255         }
9256
9257         if (test_ipsec_sec_caps_verify(&ipsec_xform, sec_cap, silent) != 0)
9258                 return TEST_SKIPPED;
9259
9260         struct rte_security_session_conf sess_conf = {
9261                 .action_type = ut_params->type,
9262                 .protocol = RTE_SECURITY_PROTOCOL_IPSEC,
9263         };
9264
9265         if (td[0].aead) {
9266                 salt_len = RTE_MIN(sizeof(ipsec_xform.salt), td[0].salt.len);
9267                 memcpy(&ipsec_xform.salt, td[0].salt.data, salt_len);
9268                 sess_conf.ipsec = ipsec_xform;
9269                 sess_conf.crypto_xform = &ut_params->aead_xform;
9270         } else {
9271                 sess_conf.ipsec = ipsec_xform;
9272                 if (dir == RTE_SECURITY_IPSEC_SA_DIR_EGRESS) {
9273                         sess_conf.crypto_xform = &ut_params->cipher_xform;
9274                         ut_params->cipher_xform.next = &ut_params->auth_xform;
9275                 } else {
9276                         sess_conf.crypto_xform = &ut_params->auth_xform;
9277                         ut_params->auth_xform.next = &ut_params->cipher_xform;
9278                 }
9279         }
9280
9281         /* Create security session */
9282         ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
9283                                         ts_params->session_mpool,
9284                                         ts_params->session_priv_mpool);
9285
9286         if (ut_params->sec_session == NULL)
9287                 return TEST_SKIPPED;
9288
9289         for (i = 0; i < nb_td; i++) {
9290                 /* Setup source mbuf payload */
9291                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9292                 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9293                                 rte_pktmbuf_tailroom(ut_params->ibuf));
9294
9295                 input_text = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9296                                 td[i].input_text.len);
9297
9298                 memcpy(input_text, td[i].input_text.data,
9299                        td[i].input_text.len);
9300
9301                 if (test_ipsec_pkt_update(input_text, flags))
9302                         return TEST_FAILED;
9303
9304                 /* Generate crypto op data structure */
9305                 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9306                                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9307                 if (!ut_params->op) {
9308                         printf("TestCase %s line %d: %s\n",
9309                                 __func__, __LINE__,
9310                                 "failed to allocate crypto op");
9311                         ret = TEST_FAILED;
9312                         goto crypto_op_free;
9313                 }
9314
9315                 /* Attach session to operation */
9316                 rte_security_attach_session(ut_params->op,
9317                                             ut_params->sec_session);
9318
9319                 /* Set crypto operation mbufs */
9320                 ut_params->op->sym->m_src = ut_params->ibuf;
9321                 ut_params->op->sym->m_dst = NULL;
9322
9323                 /* Copy IV in crypto operation when IV generation is disabled */
9324                 if (dir == RTE_SECURITY_IPSEC_SA_DIR_EGRESS &&
9325                     ipsec_xform.options.iv_gen_disable == 1) {
9326                         uint8_t *iv = rte_crypto_op_ctod_offset(ut_params->op,
9327                                                                 uint8_t *,
9328                                                                 IV_OFFSET);
9329                         int len;
9330
9331                         if (td[i].aead)
9332                                 len = td[i].xform.aead.aead.iv.length;
9333                         else
9334                                 len = td[i].xform.chain.cipher.cipher.iv.length;
9335
9336                         memcpy(iv, td[i].iv.data, len);
9337                 }
9338
9339                 /* Process crypto operation */
9340                 process_crypto_request(dev_id, ut_params->op);
9341
9342                 ret = test_ipsec_status_check(ut_params->op, flags, dir, i + 1);
9343                 if (ret != TEST_SUCCESS)
9344                         goto crypto_op_free;
9345
9346                 if (res_d != NULL)
9347                         res_d_tmp = &res_d[i];
9348
9349                 ret = test_ipsec_post_process(ut_params->ibuf, &td[i],
9350                                               res_d_tmp, silent, flags);
9351                 if (ret != TEST_SUCCESS)
9352                         goto crypto_op_free;
9353
9354                 ret = test_ipsec_stats_verify(ctx, ut_params->sec_session,
9355                                               flags, dir);
9356                 if (ret != TEST_SUCCESS)
9357                         goto crypto_op_free;
9358
9359                 rte_crypto_op_free(ut_params->op);
9360                 ut_params->op = NULL;
9361
9362                 rte_pktmbuf_free(ut_params->ibuf);
9363                 ut_params->ibuf = NULL;
9364         }
9365
9366 crypto_op_free:
9367         rte_crypto_op_free(ut_params->op);
9368         ut_params->op = NULL;
9369
9370         rte_pktmbuf_free(ut_params->ibuf);
9371         ut_params->ibuf = NULL;
9372
9373         if (ut_params->sec_session)
9374                 rte_security_session_destroy(ctx, ut_params->sec_session);
9375         ut_params->sec_session = NULL;
9376
9377         return ret;
9378 }
9379
9380 static int
9381 test_ipsec_proto_known_vec(const void *test_data)
9382 {
9383         struct ipsec_test_data td_outb;
9384         struct ipsec_test_flags flags;
9385
9386         memset(&flags, 0, sizeof(flags));
9387
9388         memcpy(&td_outb, test_data, sizeof(td_outb));
9389
9390         if (td_outb.aead ||
9391             td_outb.xform.chain.cipher.cipher.algo != RTE_CRYPTO_CIPHER_NULL) {
9392                 /* Disable IV gen to be able to test with known vectors */
9393                 td_outb.ipsec_xform.options.iv_gen_disable = 1;
9394         }
9395
9396         return test_ipsec_proto_process(&td_outb, NULL, 1, false, &flags);
9397 }
9398
9399 static int
9400 test_ipsec_proto_known_vec_inb(const void *test_data)
9401 {
9402         const struct ipsec_test_data *td = test_data;
9403         struct ipsec_test_flags flags;
9404         struct ipsec_test_data td_inb;
9405
9406         memset(&flags, 0, sizeof(flags));
9407
9408         if (td->ipsec_xform.direction == RTE_SECURITY_IPSEC_SA_DIR_EGRESS)
9409                 test_ipsec_td_in_from_out(td, &td_inb);
9410         else
9411                 memcpy(&td_inb, td, sizeof(td_inb));
9412
9413         return test_ipsec_proto_process(&td_inb, NULL, 1, false, &flags);
9414 }
9415
9416 static int
9417 test_ipsec_proto_known_vec_fragmented(const void *test_data)
9418 {
9419         struct ipsec_test_data td_outb;
9420         struct ipsec_test_flags flags;
9421
9422         memset(&flags, 0, sizeof(flags));
9423         flags.fragment = true;
9424
9425         memcpy(&td_outb, test_data, sizeof(td_outb));
9426
9427         /* Disable IV gen to be able to test with known vectors */
9428         td_outb.ipsec_xform.options.iv_gen_disable = 1;
9429
9430         return test_ipsec_proto_process(&td_outb, NULL, 1, false, &flags);
9431 }
9432
9433 static int
9434 test_ipsec_proto_all(const struct ipsec_test_flags *flags)
9435 {
9436         struct ipsec_test_data td_outb[IPSEC_TEST_PACKETS_MAX];
9437         struct ipsec_test_data td_inb[IPSEC_TEST_PACKETS_MAX];
9438         unsigned int i, nb_pkts = 1, pass_cnt = 0;
9439         int ret;
9440
9441         if (flags->iv_gen ||
9442             flags->sa_expiry_pkts_soft ||
9443             flags->sa_expiry_pkts_hard)
9444                 nb_pkts = IPSEC_TEST_PACKETS_MAX;
9445
9446         for (i = 0; i < RTE_DIM(alg_list); i++) {
9447                 test_ipsec_td_prepare(alg_list[i].param1,
9448                                       alg_list[i].param2,
9449                                       flags,
9450                                       td_outb,
9451                                       nb_pkts);
9452
9453                 if (!td_outb->aead) {
9454                         enum rte_crypto_cipher_algorithm cipher_alg;
9455                         enum rte_crypto_auth_algorithm auth_alg;
9456
9457                         cipher_alg = td_outb->xform.chain.cipher.cipher.algo;
9458                         auth_alg = td_outb->xform.chain.auth.auth.algo;
9459
9460                         /* ICV is not applicable for NULL auth */
9461                         if (flags->icv_corrupt &&
9462                             auth_alg == RTE_CRYPTO_AUTH_NULL)
9463                                 continue;
9464
9465                         /* IV is not applicable for NULL cipher */
9466                         if (flags->iv_gen &&
9467                             cipher_alg == RTE_CRYPTO_CIPHER_NULL)
9468                                 continue;
9469                 }
9470
9471                 ret = test_ipsec_proto_process(td_outb, td_inb, nb_pkts, true,
9472                                                flags);
9473                 if (ret == TEST_SKIPPED)
9474                         continue;
9475
9476                 if (ret == TEST_FAILED)
9477                         return TEST_FAILED;
9478
9479                 test_ipsec_td_update(td_inb, td_outb, nb_pkts, flags);
9480
9481                 ret = test_ipsec_proto_process(td_inb, NULL, nb_pkts, true,
9482                                                flags);
9483                 if (ret == TEST_SKIPPED)
9484                         continue;
9485
9486                 if (ret == TEST_FAILED)
9487                         return TEST_FAILED;
9488
9489                 if (flags->display_alg)
9490                         test_ipsec_display_alg(alg_list[i].param1,
9491                                                alg_list[i].param2);
9492
9493                 pass_cnt++;
9494         }
9495
9496         if (pass_cnt > 0)
9497                 return TEST_SUCCESS;
9498         else
9499                 return TEST_SKIPPED;
9500 }
9501
9502 static int
9503 test_ipsec_proto_display_list(const void *data __rte_unused)
9504 {
9505         struct ipsec_test_flags flags;
9506
9507         memset(&flags, 0, sizeof(flags));
9508
9509         flags.display_alg = true;
9510
9511         return test_ipsec_proto_all(&flags);
9512 }
9513
9514 static int
9515 test_ipsec_proto_iv_gen(const void *data __rte_unused)
9516 {
9517         struct ipsec_test_flags flags;
9518
9519         memset(&flags, 0, sizeof(flags));
9520
9521         flags.iv_gen = true;
9522
9523         return test_ipsec_proto_all(&flags);
9524 }
9525
9526 static int
9527 test_ipsec_proto_sa_exp_pkts_soft(const void *data __rte_unused)
9528 {
9529         struct ipsec_test_flags flags;
9530
9531         memset(&flags, 0, sizeof(flags));
9532
9533         flags.sa_expiry_pkts_soft = true;
9534
9535         return test_ipsec_proto_all(&flags);
9536 }
9537
9538 static int
9539 test_ipsec_proto_sa_exp_pkts_hard(const void *data __rte_unused)
9540 {
9541         struct ipsec_test_flags flags;
9542
9543         memset(&flags, 0, sizeof(flags));
9544
9545         flags.sa_expiry_pkts_hard = true;
9546
9547         return test_ipsec_proto_all(&flags);
9548 }
9549
9550 static int
9551 test_ipsec_proto_err_icv_corrupt(const void *data __rte_unused)
9552 {
9553         struct ipsec_test_flags flags;
9554
9555         memset(&flags, 0, sizeof(flags));
9556
9557         flags.icv_corrupt = true;
9558
9559         return test_ipsec_proto_all(&flags);
9560 }
9561
9562 static int
9563 test_ipsec_proto_udp_encap(const void *data __rte_unused)
9564 {
9565         struct ipsec_test_flags flags;
9566
9567         memset(&flags, 0, sizeof(flags));
9568
9569         flags.udp_encap = true;
9570
9571         return test_ipsec_proto_all(&flags);
9572 }
9573
9574 static int
9575 test_ipsec_proto_tunnel_src_dst_addr_verify(const void *data __rte_unused)
9576 {
9577         struct ipsec_test_flags flags;
9578
9579         memset(&flags, 0, sizeof(flags));
9580
9581         flags.tunnel_hdr_verify = RTE_SECURITY_IPSEC_TUNNEL_VERIFY_SRC_DST_ADDR;
9582
9583         return test_ipsec_proto_all(&flags);
9584 }
9585
9586 static int
9587 test_ipsec_proto_tunnel_dst_addr_verify(const void *data __rte_unused)
9588 {
9589         struct ipsec_test_flags flags;
9590
9591         memset(&flags, 0, sizeof(flags));
9592
9593         flags.tunnel_hdr_verify = RTE_SECURITY_IPSEC_TUNNEL_VERIFY_DST_ADDR;
9594
9595         return test_ipsec_proto_all(&flags);
9596 }
9597
9598 static int
9599 test_ipsec_proto_udp_ports_verify(const void *data __rte_unused)
9600 {
9601         struct ipsec_test_flags flags;
9602
9603         memset(&flags, 0, sizeof(flags));
9604
9605         flags.udp_encap = true;
9606         flags.udp_ports_verify = true;
9607
9608         return test_ipsec_proto_all(&flags);
9609 }
9610
9611 static int
9612 test_ipsec_proto_inner_ip_csum(const void *data __rte_unused)
9613 {
9614         struct ipsec_test_flags flags;
9615
9616         memset(&flags, 0, sizeof(flags));
9617
9618         flags.ip_csum = true;
9619
9620         return test_ipsec_proto_all(&flags);
9621 }
9622
9623 static int
9624 test_ipsec_proto_inner_l4_csum(const void *data __rte_unused)
9625 {
9626         struct ipsec_test_flags flags;
9627
9628         memset(&flags, 0, sizeof(flags));
9629
9630         flags.l4_csum = true;
9631
9632         return test_ipsec_proto_all(&flags);
9633 }
9634
9635 static int
9636 test_ipsec_proto_tunnel_v4_in_v4(const void *data __rte_unused)
9637 {
9638         struct ipsec_test_flags flags;
9639
9640         memset(&flags, 0, sizeof(flags));
9641
9642         flags.ipv6 = false;
9643         flags.tunnel_ipv6 = false;
9644
9645         return test_ipsec_proto_all(&flags);
9646 }
9647
9648 static int
9649 test_ipsec_proto_tunnel_v6_in_v6(const void *data __rte_unused)
9650 {
9651         struct ipsec_test_flags flags;
9652
9653         memset(&flags, 0, sizeof(flags));
9654
9655         flags.ipv6 = true;
9656         flags.tunnel_ipv6 = true;
9657
9658         return test_ipsec_proto_all(&flags);
9659 }
9660
9661 static int
9662 test_ipsec_proto_tunnel_v4_in_v6(const void *data __rte_unused)
9663 {
9664         struct ipsec_test_flags flags;
9665
9666         memset(&flags, 0, sizeof(flags));
9667
9668         flags.ipv6 = false;
9669         flags.tunnel_ipv6 = true;
9670
9671         return test_ipsec_proto_all(&flags);
9672 }
9673
9674 static int
9675 test_ipsec_proto_tunnel_v6_in_v4(const void *data __rte_unused)
9676 {
9677         struct ipsec_test_flags flags;
9678
9679         memset(&flags, 0, sizeof(flags));
9680
9681         flags.ipv6 = true;
9682         flags.tunnel_ipv6 = false;
9683
9684         return test_ipsec_proto_all(&flags);
9685 }
9686
9687 static int
9688 test_ipsec_proto_transport_v4(const void *data __rte_unused)
9689 {
9690         struct ipsec_test_flags flags;
9691
9692         memset(&flags, 0, sizeof(flags));
9693
9694         flags.ipv6 = false;
9695         flags.transport = true;
9696
9697         return test_ipsec_proto_all(&flags);
9698 }
9699
9700 static int
9701 test_ipsec_proto_stats(const void *data __rte_unused)
9702 {
9703         struct ipsec_test_flags flags;
9704
9705         memset(&flags, 0, sizeof(flags));
9706
9707         flags.stats_success = true;
9708
9709         return test_ipsec_proto_all(&flags);
9710 }
9711
9712 static int
9713 test_ipsec_proto_pkt_fragment(const void *data __rte_unused)
9714 {
9715         struct ipsec_test_flags flags;
9716
9717         memset(&flags, 0, sizeof(flags));
9718
9719         flags.fragment = true;
9720
9721         return test_ipsec_proto_all(&flags);
9722
9723 }
9724
9725 static int
9726 test_ipsec_proto_copy_df_inner_0(const void *data __rte_unused)
9727 {
9728         struct ipsec_test_flags flags;
9729
9730         memset(&flags, 0, sizeof(flags));
9731
9732         flags.df = TEST_IPSEC_COPY_DF_INNER_0;
9733
9734         return test_ipsec_proto_all(&flags);
9735 }
9736
9737 static int
9738 test_ipsec_proto_copy_df_inner_1(const void *data __rte_unused)
9739 {
9740         struct ipsec_test_flags flags;
9741
9742         memset(&flags, 0, sizeof(flags));
9743
9744         flags.df = TEST_IPSEC_COPY_DF_INNER_1;
9745
9746         return test_ipsec_proto_all(&flags);
9747 }
9748
9749 static int
9750 test_ipsec_proto_set_df_0_inner_1(const void *data __rte_unused)
9751 {
9752         struct ipsec_test_flags flags;
9753
9754         memset(&flags, 0, sizeof(flags));
9755
9756         flags.df = TEST_IPSEC_SET_DF_0_INNER_1;
9757
9758         return test_ipsec_proto_all(&flags);
9759 }
9760
9761 static int
9762 test_ipsec_proto_set_df_1_inner_0(const void *data __rte_unused)
9763 {
9764         struct ipsec_test_flags flags;
9765
9766         memset(&flags, 0, sizeof(flags));
9767
9768         flags.df = TEST_IPSEC_SET_DF_1_INNER_0;
9769
9770         return test_ipsec_proto_all(&flags);
9771 }
9772
9773 static int
9774 test_PDCP_PROTO_all(void)
9775 {
9776         struct crypto_testsuite_params *ts_params = &testsuite_params;
9777         struct crypto_unittest_params *ut_params = &unittest_params;
9778         struct rte_cryptodev_info dev_info;
9779         int status;
9780
9781         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
9782         uint64_t feat_flags = dev_info.feature_flags;
9783
9784         if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY))
9785                 return TEST_SKIPPED;
9786
9787         /* Set action type */
9788         ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
9789                 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
9790                 gbl_action_type;
9791
9792         if (security_proto_supported(ut_params->type,
9793                         RTE_SECURITY_PROTOCOL_PDCP) < 0)
9794                 return TEST_SKIPPED;
9795
9796         status = test_PDCP_PROTO_cplane_encap_all();
9797         status += test_PDCP_PROTO_cplane_decap_all();
9798         status += test_PDCP_PROTO_uplane_encap_all();
9799         status += test_PDCP_PROTO_uplane_decap_all();
9800         status += test_PDCP_PROTO_SGL_in_place_32B();
9801         status += test_PDCP_PROTO_SGL_oop_32B_128B();
9802         status += test_PDCP_PROTO_SGL_oop_32B_40B();
9803         status += test_PDCP_PROTO_SGL_oop_128B_32B();
9804         status += test_PDCP_SDAP_PROTO_encap_all();
9805         status += test_PDCP_SDAP_PROTO_decap_all();
9806         status += test_PDCP_PROTO_short_mac();
9807
9808         if (status)
9809                 return TEST_FAILED;
9810         else
9811                 return TEST_SUCCESS;
9812 }
9813
9814 static int
9815 test_docsis_proto_uplink(const void *data)
9816 {
9817         const struct docsis_test_data *d_td = data;
9818         struct crypto_testsuite_params *ts_params = &testsuite_params;
9819         struct crypto_unittest_params *ut_params = &unittest_params;
9820         uint8_t *plaintext = NULL;
9821         uint8_t *ciphertext = NULL;
9822         uint8_t *iv_ptr;
9823         int32_t cipher_len, crc_len;
9824         uint32_t crc_data_len;
9825         int ret = TEST_SUCCESS;
9826
9827         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
9828                                         rte_cryptodev_get_sec_ctx(
9829                                                 ts_params->valid_devs[0]);
9830
9831         /* Verify the capabilities */
9832         struct rte_security_capability_idx sec_cap_idx;
9833         const struct rte_security_capability *sec_cap;
9834         const struct rte_cryptodev_capabilities *crypto_cap;
9835         const struct rte_cryptodev_symmetric_capability *sym_cap;
9836         int j = 0;
9837
9838         /* Set action type */
9839         ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
9840                 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
9841                 gbl_action_type;
9842
9843         if (security_proto_supported(ut_params->type,
9844                         RTE_SECURITY_PROTOCOL_DOCSIS) < 0)
9845                 return TEST_SKIPPED;
9846
9847         sec_cap_idx.action = ut_params->type;
9848         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
9849         sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_UPLINK;
9850
9851         sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
9852         if (sec_cap == NULL)
9853                 return TEST_SKIPPED;
9854
9855         while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
9856                         RTE_CRYPTO_OP_TYPE_UNDEFINED) {
9857                 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
9858                                 crypto_cap->sym.xform_type ==
9859                                         RTE_CRYPTO_SYM_XFORM_CIPHER &&
9860                                 crypto_cap->sym.cipher.algo ==
9861                                         RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
9862                         sym_cap = &crypto_cap->sym;
9863                         if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
9864                                                 d_td->key.len,
9865                                                 d_td->iv.len) == 0)
9866                                 break;
9867                 }
9868         }
9869
9870         if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
9871                 return TEST_SKIPPED;
9872
9873         /* Setup source mbuf payload */
9874         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9875         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9876                         rte_pktmbuf_tailroom(ut_params->ibuf));
9877
9878         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9879                         d_td->ciphertext.len);
9880
9881         memcpy(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len);
9882
9883         /* Setup cipher session parameters */
9884         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
9885         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
9886         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
9887         ut_params->cipher_xform.cipher.key.data = d_td->key.data;
9888         ut_params->cipher_xform.cipher.key.length = d_td->key.len;
9889         ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
9890         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
9891         ut_params->cipher_xform.next = NULL;
9892
9893         /* Setup DOCSIS session parameters */
9894         ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_UPLINK;
9895
9896         struct rte_security_session_conf sess_conf = {
9897                 .action_type = ut_params->type,
9898                 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
9899                 .docsis = ut_params->docsis_xform,
9900                 .crypto_xform = &ut_params->cipher_xform,
9901         };
9902
9903         /* Create security session */
9904         ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
9905                                         ts_params->session_mpool,
9906                                         ts_params->session_priv_mpool);
9907
9908         if (!ut_params->sec_session) {
9909                 printf("Test function %s line %u: failed to allocate session\n",
9910                         __func__, __LINE__);
9911                 ret = TEST_FAILED;
9912                 goto on_err;
9913         }
9914
9915         /* Generate crypto op data structure */
9916         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9917                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9918         if (!ut_params->op) {
9919                 printf("Test function %s line %u: failed to allocate symmetric "
9920                         "crypto operation\n", __func__, __LINE__);
9921                 ret = TEST_FAILED;
9922                 goto on_err;
9923         }
9924
9925         /* Setup CRC operation parameters */
9926         crc_len = d_td->ciphertext.no_crc == false ?
9927                         (d_td->ciphertext.len -
9928                                 d_td->ciphertext.crc_offset -
9929                                 RTE_ETHER_CRC_LEN) :
9930                         0;
9931         crc_len = crc_len > 0 ? crc_len : 0;
9932         crc_data_len = crc_len == 0 ? 0 : RTE_ETHER_CRC_LEN;
9933         ut_params->op->sym->auth.data.length = crc_len;
9934         ut_params->op->sym->auth.data.offset = d_td->ciphertext.crc_offset;
9935
9936         /* Setup cipher operation parameters */
9937         cipher_len = d_td->ciphertext.no_cipher == false ?
9938                         (d_td->ciphertext.len -
9939                                 d_td->ciphertext.cipher_offset) :
9940                         0;
9941         cipher_len = cipher_len > 0 ? cipher_len : 0;
9942         ut_params->op->sym->cipher.data.length = cipher_len;
9943         ut_params->op->sym->cipher.data.offset = d_td->ciphertext.cipher_offset;
9944
9945         /* Setup cipher IV */
9946         iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
9947         rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
9948
9949         /* Attach session to operation */
9950         rte_security_attach_session(ut_params->op, ut_params->sec_session);
9951
9952         /* Set crypto operation mbufs */
9953         ut_params->op->sym->m_src = ut_params->ibuf;
9954         ut_params->op->sym->m_dst = NULL;
9955
9956         /* Process crypto operation */
9957         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
9958                         NULL) {
9959                 printf("Test function %s line %u: failed to process security "
9960                         "crypto op\n", __func__, __LINE__);
9961                 ret = TEST_FAILED;
9962                 goto on_err;
9963         }
9964
9965         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
9966                 printf("Test function %s line %u: failed to process crypto op\n",
9967                         __func__, __LINE__);
9968                 ret = TEST_FAILED;
9969                 goto on_err;
9970         }
9971
9972         /* Validate plaintext */
9973         plaintext = ciphertext;
9974
9975         if (memcmp(plaintext, d_td->plaintext.data,
9976                         d_td->plaintext.len - crc_data_len)) {
9977                 printf("Test function %s line %u: plaintext not as expected\n",
9978                         __func__, __LINE__);
9979                 rte_hexdump(stdout, "expected", d_td->plaintext.data,
9980                                 d_td->plaintext.len);
9981                 rte_hexdump(stdout, "actual", plaintext, d_td->plaintext.len);
9982                 ret = TEST_FAILED;
9983                 goto on_err;
9984         }
9985
9986 on_err:
9987         rte_crypto_op_free(ut_params->op);
9988         ut_params->op = NULL;
9989
9990         if (ut_params->sec_session)
9991                 rte_security_session_destroy(ctx, ut_params->sec_session);
9992         ut_params->sec_session = NULL;
9993
9994         rte_pktmbuf_free(ut_params->ibuf);
9995         ut_params->ibuf = NULL;
9996
9997         return ret;
9998 }
9999
10000 static int
10001 test_docsis_proto_downlink(const void *data)
10002 {
10003         const struct docsis_test_data *d_td = data;
10004         struct crypto_testsuite_params *ts_params = &testsuite_params;
10005         struct crypto_unittest_params *ut_params = &unittest_params;
10006         uint8_t *plaintext = NULL;
10007         uint8_t *ciphertext = NULL;
10008         uint8_t *iv_ptr;
10009         int32_t cipher_len, crc_len;
10010         int ret = TEST_SUCCESS;
10011
10012         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
10013                                         rte_cryptodev_get_sec_ctx(
10014                                                 ts_params->valid_devs[0]);
10015
10016         /* Verify the capabilities */
10017         struct rte_security_capability_idx sec_cap_idx;
10018         const struct rte_security_capability *sec_cap;
10019         const struct rte_cryptodev_capabilities *crypto_cap;
10020         const struct rte_cryptodev_symmetric_capability *sym_cap;
10021         int j = 0;
10022
10023         /* Set action type */
10024         ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
10025                 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
10026                 gbl_action_type;
10027
10028         if (security_proto_supported(ut_params->type,
10029                         RTE_SECURITY_PROTOCOL_DOCSIS) < 0)
10030                 return TEST_SKIPPED;
10031
10032         sec_cap_idx.action = ut_params->type;
10033         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
10034         sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
10035
10036         sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
10037         if (sec_cap == NULL)
10038                 return TEST_SKIPPED;
10039
10040         while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
10041                         RTE_CRYPTO_OP_TYPE_UNDEFINED) {
10042                 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
10043                                 crypto_cap->sym.xform_type ==
10044                                         RTE_CRYPTO_SYM_XFORM_CIPHER &&
10045                                 crypto_cap->sym.cipher.algo ==
10046                                         RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
10047                         sym_cap = &crypto_cap->sym;
10048                         if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
10049                                                 d_td->key.len,
10050                                                 d_td->iv.len) == 0)
10051                                 break;
10052                 }
10053         }
10054
10055         if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
10056                 return TEST_SKIPPED;
10057
10058         /* Setup source mbuf payload */
10059         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10060         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10061                         rte_pktmbuf_tailroom(ut_params->ibuf));
10062
10063         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
10064                         d_td->plaintext.len);
10065
10066         memcpy(plaintext, d_td->plaintext.data, d_td->plaintext.len);
10067
10068         /* Setup cipher session parameters */
10069         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10070         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
10071         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
10072         ut_params->cipher_xform.cipher.key.data = d_td->key.data;
10073         ut_params->cipher_xform.cipher.key.length = d_td->key.len;
10074         ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
10075         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
10076         ut_params->cipher_xform.next = NULL;
10077
10078         /* Setup DOCSIS session parameters */
10079         ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
10080
10081         struct rte_security_session_conf sess_conf = {
10082                 .action_type = ut_params->type,
10083                 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
10084                 .docsis = ut_params->docsis_xform,
10085                 .crypto_xform = &ut_params->cipher_xform,
10086         };
10087
10088         /* Create security session */
10089         ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
10090                                         ts_params->session_mpool,
10091                                         ts_params->session_priv_mpool);
10092
10093         if (!ut_params->sec_session) {
10094                 printf("Test function %s line %u: failed to allocate session\n",
10095                         __func__, __LINE__);
10096                 ret = TEST_FAILED;
10097                 goto on_err;
10098         }
10099
10100         /* Generate crypto op data structure */
10101         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10102                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10103         if (!ut_params->op) {
10104                 printf("Test function %s line %u: failed to allocate symmetric "
10105                         "crypto operation\n", __func__, __LINE__);
10106                 ret = TEST_FAILED;
10107                 goto on_err;
10108         }
10109
10110         /* Setup CRC operation parameters */
10111         crc_len = d_td->plaintext.no_crc == false ?
10112                         (d_td->plaintext.len -
10113                                 d_td->plaintext.crc_offset -
10114                                 RTE_ETHER_CRC_LEN) :
10115                         0;
10116         crc_len = crc_len > 0 ? crc_len : 0;
10117         ut_params->op->sym->auth.data.length = crc_len;
10118         ut_params->op->sym->auth.data.offset = d_td->plaintext.crc_offset;
10119
10120         /* Setup cipher operation parameters */
10121         cipher_len = d_td->plaintext.no_cipher == false ?
10122                         (d_td->plaintext.len -
10123                                 d_td->plaintext.cipher_offset) :
10124                         0;
10125         cipher_len = cipher_len > 0 ? cipher_len : 0;
10126         ut_params->op->sym->cipher.data.length = cipher_len;
10127         ut_params->op->sym->cipher.data.offset = d_td->plaintext.cipher_offset;
10128
10129         /* Setup cipher IV */
10130         iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
10131         rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
10132
10133         /* Attach session to operation */
10134         rte_security_attach_session(ut_params->op, ut_params->sec_session);
10135
10136         /* Set crypto operation mbufs */
10137         ut_params->op->sym->m_src = ut_params->ibuf;
10138         ut_params->op->sym->m_dst = NULL;
10139
10140         /* Process crypto operation */
10141         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
10142                         NULL) {
10143                 printf("Test function %s line %u: failed to process crypto op\n",
10144                         __func__, __LINE__);
10145                 ret = TEST_FAILED;
10146                 goto on_err;
10147         }
10148
10149         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
10150                 printf("Test function %s line %u: crypto op processing failed\n",
10151                         __func__, __LINE__);
10152                 ret = TEST_FAILED;
10153                 goto on_err;
10154         }
10155
10156         /* Validate ciphertext */
10157         ciphertext = plaintext;
10158
10159         if (memcmp(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len)) {
10160                 printf("Test function %s line %u: plaintext not as expected\n",
10161                         __func__, __LINE__);
10162                 rte_hexdump(stdout, "expected", d_td->ciphertext.data,
10163                                 d_td->ciphertext.len);
10164                 rte_hexdump(stdout, "actual", ciphertext, d_td->ciphertext.len);
10165                 ret = TEST_FAILED;
10166                 goto on_err;
10167         }
10168
10169 on_err:
10170         rte_crypto_op_free(ut_params->op);
10171         ut_params->op = NULL;
10172
10173         if (ut_params->sec_session)
10174                 rte_security_session_destroy(ctx, ut_params->sec_session);
10175         ut_params->sec_session = NULL;
10176
10177         rte_pktmbuf_free(ut_params->ibuf);
10178         ut_params->ibuf = NULL;
10179
10180         return ret;
10181 }
10182 #endif
10183
10184 static int
10185 test_AES_GCM_authenticated_encryption_test_case_1(void)
10186 {
10187         return test_authenticated_encryption(&gcm_test_case_1);
10188 }
10189
10190 static int
10191 test_AES_GCM_authenticated_encryption_test_case_2(void)
10192 {
10193         return test_authenticated_encryption(&gcm_test_case_2);
10194 }
10195
10196 static int
10197 test_AES_GCM_authenticated_encryption_test_case_3(void)
10198 {
10199         return test_authenticated_encryption(&gcm_test_case_3);
10200 }
10201
10202 static int
10203 test_AES_GCM_authenticated_encryption_test_case_4(void)
10204 {
10205         return test_authenticated_encryption(&gcm_test_case_4);
10206 }
10207
10208 static int
10209 test_AES_GCM_authenticated_encryption_test_case_5(void)
10210 {
10211         return test_authenticated_encryption(&gcm_test_case_5);
10212 }
10213
10214 static int
10215 test_AES_GCM_authenticated_encryption_test_case_6(void)
10216 {
10217         return test_authenticated_encryption(&gcm_test_case_6);
10218 }
10219
10220 static int
10221 test_AES_GCM_authenticated_encryption_test_case_7(void)
10222 {
10223         return test_authenticated_encryption(&gcm_test_case_7);
10224 }
10225
10226 static int
10227 test_AES_GCM_authenticated_encryption_test_case_8(void)
10228 {
10229         return test_authenticated_encryption(&gcm_test_case_8);
10230 }
10231
10232 static int
10233 test_AES_GCM_J0_authenticated_encryption_test_case_1(void)
10234 {
10235         return test_authenticated_encryption(&gcm_J0_test_case_1);
10236 }
10237
10238 static int
10239 test_AES_GCM_auth_encryption_test_case_192_1(void)
10240 {
10241         return test_authenticated_encryption(&gcm_test_case_192_1);
10242 }
10243
10244 static int
10245 test_AES_GCM_auth_encryption_test_case_192_2(void)
10246 {
10247         return test_authenticated_encryption(&gcm_test_case_192_2);
10248 }
10249
10250 static int
10251 test_AES_GCM_auth_encryption_test_case_192_3(void)
10252 {
10253         return test_authenticated_encryption(&gcm_test_case_192_3);
10254 }
10255
10256 static int
10257 test_AES_GCM_auth_encryption_test_case_192_4(void)
10258 {
10259         return test_authenticated_encryption(&gcm_test_case_192_4);
10260 }
10261
10262 static int
10263 test_AES_GCM_auth_encryption_test_case_192_5(void)
10264 {
10265         return test_authenticated_encryption(&gcm_test_case_192_5);
10266 }
10267
10268 static int
10269 test_AES_GCM_auth_encryption_test_case_192_6(void)
10270 {
10271         return test_authenticated_encryption(&gcm_test_case_192_6);
10272 }
10273
10274 static int
10275 test_AES_GCM_auth_encryption_test_case_192_7(void)
10276 {
10277         return test_authenticated_encryption(&gcm_test_case_192_7);
10278 }
10279
10280 static int
10281 test_AES_GCM_auth_encryption_test_case_256_1(void)
10282 {
10283         return test_authenticated_encryption(&gcm_test_case_256_1);
10284 }
10285
10286 static int
10287 test_AES_GCM_auth_encryption_test_case_256_2(void)
10288 {
10289         return test_authenticated_encryption(&gcm_test_case_256_2);
10290 }
10291
10292 static int
10293 test_AES_GCM_auth_encryption_test_case_256_3(void)
10294 {
10295         return test_authenticated_encryption(&gcm_test_case_256_3);
10296 }
10297
10298 static int
10299 test_AES_GCM_auth_encryption_test_case_256_4(void)
10300 {
10301         return test_authenticated_encryption(&gcm_test_case_256_4);
10302 }
10303
10304 static int
10305 test_AES_GCM_auth_encryption_test_case_256_5(void)
10306 {
10307         return test_authenticated_encryption(&gcm_test_case_256_5);
10308 }
10309
10310 static int
10311 test_AES_GCM_auth_encryption_test_case_256_6(void)
10312 {
10313         return test_authenticated_encryption(&gcm_test_case_256_6);
10314 }
10315
10316 static int
10317 test_AES_GCM_auth_encryption_test_case_256_7(void)
10318 {
10319         return test_authenticated_encryption(&gcm_test_case_256_7);
10320 }
10321
10322 static int
10323 test_AES_GCM_auth_encryption_test_case_aad_1(void)
10324 {
10325         return test_authenticated_encryption(&gcm_test_case_aad_1);
10326 }
10327
10328 static int
10329 test_AES_GCM_auth_encryption_test_case_aad_2(void)
10330 {
10331         return test_authenticated_encryption(&gcm_test_case_aad_2);
10332 }
10333
10334 static int
10335 test_AES_GCM_auth_encryption_fail_iv_corrupt(void)
10336 {
10337         struct aead_test_data tdata;
10338         int res;
10339
10340         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10341         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10342         tdata.iv.data[0] += 1;
10343         res = test_authenticated_encryption(&tdata);
10344         if (res == TEST_SKIPPED)
10345                 return res;
10346         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10347         return TEST_SUCCESS;
10348 }
10349
10350 static int
10351 test_AES_GCM_auth_encryption_fail_in_data_corrupt(void)
10352 {
10353         struct aead_test_data tdata;
10354         int res;
10355
10356         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10357         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10358         tdata.plaintext.data[0] += 1;
10359         res = test_authenticated_encryption(&tdata);
10360         if (res == TEST_SKIPPED)
10361                 return res;
10362         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10363         return TEST_SUCCESS;
10364 }
10365
10366 static int
10367 test_AES_GCM_auth_encryption_fail_out_data_corrupt(void)
10368 {
10369         struct aead_test_data tdata;
10370         int res;
10371
10372         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10373         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10374         tdata.ciphertext.data[0] += 1;
10375         res = test_authenticated_encryption(&tdata);
10376         if (res == TEST_SKIPPED)
10377                 return res;
10378         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10379         return TEST_SUCCESS;
10380 }
10381
10382 static int
10383 test_AES_GCM_auth_encryption_fail_aad_len_corrupt(void)
10384 {
10385         struct aead_test_data tdata;
10386         int res;
10387
10388         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10389         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10390         tdata.aad.len += 1;
10391         res = test_authenticated_encryption(&tdata);
10392         if (res == TEST_SKIPPED)
10393                 return res;
10394         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10395         return TEST_SUCCESS;
10396 }
10397
10398 static int
10399 test_AES_GCM_auth_encryption_fail_aad_corrupt(void)
10400 {
10401         struct aead_test_data tdata;
10402         uint8_t aad[gcm_test_case_7.aad.len];
10403         int res;
10404
10405         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10406         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10407         memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
10408         aad[0] += 1;
10409         tdata.aad.data = aad;
10410         res = test_authenticated_encryption(&tdata);
10411         if (res == TEST_SKIPPED)
10412                 return res;
10413         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10414         return TEST_SUCCESS;
10415 }
10416
10417 static int
10418 test_AES_GCM_auth_encryption_fail_tag_corrupt(void)
10419 {
10420         struct aead_test_data tdata;
10421         int res;
10422
10423         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10424         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10425         tdata.auth_tag.data[0] += 1;
10426         res = test_authenticated_encryption(&tdata);
10427         if (res == TEST_SKIPPED)
10428                 return res;
10429         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10430         return TEST_SUCCESS;
10431 }
10432
10433 static int
10434 test_authenticated_decryption(const struct aead_test_data *tdata)
10435 {
10436         struct crypto_testsuite_params *ts_params = &testsuite_params;
10437         struct crypto_unittest_params *ut_params = &unittest_params;
10438
10439         int retval;
10440         uint8_t *plaintext;
10441         uint32_t i;
10442         struct rte_cryptodev_info dev_info;
10443
10444         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10445         uint64_t feat_flags = dev_info.feature_flags;
10446
10447         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10448                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10449                 printf("Device doesn't support RAW data-path APIs.\n");
10450                 return TEST_SKIPPED;
10451         }
10452
10453         /* Verify the capabilities */
10454         struct rte_cryptodev_sym_capability_idx cap_idx;
10455         const struct rte_cryptodev_symmetric_capability *capability;
10456         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10457         cap_idx.algo.aead = tdata->algo;
10458         capability = rte_cryptodev_sym_capability_get(
10459                         ts_params->valid_devs[0], &cap_idx);
10460         if (capability == NULL)
10461                 return TEST_SKIPPED;
10462         if (rte_cryptodev_sym_capability_check_aead(
10463                         capability, tdata->key.len, tdata->auth_tag.len,
10464                         tdata->aad.len, tdata->iv.len))
10465                 return TEST_SKIPPED;
10466
10467         /* Create AEAD session */
10468         retval = create_aead_session(ts_params->valid_devs[0],
10469                         tdata->algo,
10470                         RTE_CRYPTO_AEAD_OP_DECRYPT,
10471                         tdata->key.data, tdata->key.len,
10472                         tdata->aad.len, tdata->auth_tag.len,
10473                         tdata->iv.len);
10474         if (retval < 0)
10475                 return retval;
10476
10477         /* alloc mbuf and set payload */
10478         if (tdata->aad.len > MBUF_SIZE) {
10479                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
10480                 /* Populate full size of add data */
10481                 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
10482                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
10483         } else
10484                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10485
10486         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10487                         rte_pktmbuf_tailroom(ut_params->ibuf));
10488
10489         /* Create AEAD operation */
10490         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
10491         if (retval < 0)
10492                 return retval;
10493
10494         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10495
10496         ut_params->op->sym->m_src = ut_params->ibuf;
10497
10498         /* Process crypto operation */
10499         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10500                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
10501         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10502                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10503                                 ut_params->op, 0, 0, 0, 0);
10504         else
10505                 TEST_ASSERT_NOT_NULL(
10506                         process_crypto_request(ts_params->valid_devs[0],
10507                         ut_params->op), "failed to process sym crypto op");
10508
10509         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10510                         "crypto op processing failed");
10511
10512         if (ut_params->op->sym->m_dst)
10513                 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
10514                                 uint8_t *);
10515         else
10516                 plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
10517                                 uint8_t *,
10518                                 ut_params->op->sym->cipher.data.offset);
10519
10520         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
10521
10522         /* Validate obuf */
10523         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10524                         plaintext,
10525                         tdata->plaintext.data,
10526                         tdata->plaintext.len,
10527                         "Plaintext data not as expected");
10528
10529         TEST_ASSERT_EQUAL(ut_params->op->status,
10530                         RTE_CRYPTO_OP_STATUS_SUCCESS,
10531                         "Authentication failed");
10532
10533         return 0;
10534 }
10535
10536 static int
10537 test_AES_GCM_authenticated_decryption_test_case_1(void)
10538 {
10539         return test_authenticated_decryption(&gcm_test_case_1);
10540 }
10541
10542 static int
10543 test_AES_GCM_authenticated_decryption_test_case_2(void)
10544 {
10545         return test_authenticated_decryption(&gcm_test_case_2);
10546 }
10547
10548 static int
10549 test_AES_GCM_authenticated_decryption_test_case_3(void)
10550 {
10551         return test_authenticated_decryption(&gcm_test_case_3);
10552 }
10553
10554 static int
10555 test_AES_GCM_authenticated_decryption_test_case_4(void)
10556 {
10557         return test_authenticated_decryption(&gcm_test_case_4);
10558 }
10559
10560 static int
10561 test_AES_GCM_authenticated_decryption_test_case_5(void)
10562 {
10563         return test_authenticated_decryption(&gcm_test_case_5);
10564 }
10565
10566 static int
10567 test_AES_GCM_authenticated_decryption_test_case_6(void)
10568 {
10569         return test_authenticated_decryption(&gcm_test_case_6);
10570 }
10571
10572 static int
10573 test_AES_GCM_authenticated_decryption_test_case_7(void)
10574 {
10575         return test_authenticated_decryption(&gcm_test_case_7);
10576 }
10577
10578 static int
10579 test_AES_GCM_authenticated_decryption_test_case_8(void)
10580 {
10581         return test_authenticated_decryption(&gcm_test_case_8);
10582 }
10583
10584 static int
10585 test_AES_GCM_J0_authenticated_decryption_test_case_1(void)
10586 {
10587         return test_authenticated_decryption(&gcm_J0_test_case_1);
10588 }
10589
10590 static int
10591 test_AES_GCM_auth_decryption_test_case_192_1(void)
10592 {
10593         return test_authenticated_decryption(&gcm_test_case_192_1);
10594 }
10595
10596 static int
10597 test_AES_GCM_auth_decryption_test_case_192_2(void)
10598 {
10599         return test_authenticated_decryption(&gcm_test_case_192_2);
10600 }
10601
10602 static int
10603 test_AES_GCM_auth_decryption_test_case_192_3(void)
10604 {
10605         return test_authenticated_decryption(&gcm_test_case_192_3);
10606 }
10607
10608 static int
10609 test_AES_GCM_auth_decryption_test_case_192_4(void)
10610 {
10611         return test_authenticated_decryption(&gcm_test_case_192_4);
10612 }
10613
10614 static int
10615 test_AES_GCM_auth_decryption_test_case_192_5(void)
10616 {
10617         return test_authenticated_decryption(&gcm_test_case_192_5);
10618 }
10619
10620 static int
10621 test_AES_GCM_auth_decryption_test_case_192_6(void)
10622 {
10623         return test_authenticated_decryption(&gcm_test_case_192_6);
10624 }
10625
10626 static int
10627 test_AES_GCM_auth_decryption_test_case_192_7(void)
10628 {
10629         return test_authenticated_decryption(&gcm_test_case_192_7);
10630 }
10631
10632 static int
10633 test_AES_GCM_auth_decryption_test_case_256_1(void)
10634 {
10635         return test_authenticated_decryption(&gcm_test_case_256_1);
10636 }
10637
10638 static int
10639 test_AES_GCM_auth_decryption_test_case_256_2(void)
10640 {
10641         return test_authenticated_decryption(&gcm_test_case_256_2);
10642 }
10643
10644 static int
10645 test_AES_GCM_auth_decryption_test_case_256_3(void)
10646 {
10647         return test_authenticated_decryption(&gcm_test_case_256_3);
10648 }
10649
10650 static int
10651 test_AES_GCM_auth_decryption_test_case_256_4(void)
10652 {
10653         return test_authenticated_decryption(&gcm_test_case_256_4);
10654 }
10655
10656 static int
10657 test_AES_GCM_auth_decryption_test_case_256_5(void)
10658 {
10659         return test_authenticated_decryption(&gcm_test_case_256_5);
10660 }
10661
10662 static int
10663 test_AES_GCM_auth_decryption_test_case_256_6(void)
10664 {
10665         return test_authenticated_decryption(&gcm_test_case_256_6);
10666 }
10667
10668 static int
10669 test_AES_GCM_auth_decryption_test_case_256_7(void)
10670 {
10671         return test_authenticated_decryption(&gcm_test_case_256_7);
10672 }
10673
10674 static int
10675 test_AES_GCM_auth_decryption_test_case_aad_1(void)
10676 {
10677         return test_authenticated_decryption(&gcm_test_case_aad_1);
10678 }
10679
10680 static int
10681 test_AES_GCM_auth_decryption_test_case_aad_2(void)
10682 {
10683         return test_authenticated_decryption(&gcm_test_case_aad_2);
10684 }
10685
10686 static int
10687 test_AES_GCM_auth_decryption_fail_iv_corrupt(void)
10688 {
10689         struct aead_test_data tdata;
10690         int res;
10691
10692         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10693         tdata.iv.data[0] += 1;
10694         res = test_authenticated_decryption(&tdata);
10695         if (res == TEST_SKIPPED)
10696                 return res;
10697         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10698         return TEST_SUCCESS;
10699 }
10700
10701 static int
10702 test_AES_GCM_auth_decryption_fail_in_data_corrupt(void)
10703 {
10704         struct aead_test_data tdata;
10705         int res;
10706
10707         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10708         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10709         tdata.plaintext.data[0] += 1;
10710         res = test_authenticated_decryption(&tdata);
10711         if (res == TEST_SKIPPED)
10712                 return res;
10713         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10714         return TEST_SUCCESS;
10715 }
10716
10717 static int
10718 test_AES_GCM_auth_decryption_fail_out_data_corrupt(void)
10719 {
10720         struct aead_test_data tdata;
10721         int res;
10722
10723         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10724         tdata.ciphertext.data[0] += 1;
10725         res = test_authenticated_decryption(&tdata);
10726         if (res == TEST_SKIPPED)
10727                 return res;
10728         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10729         return TEST_SUCCESS;
10730 }
10731
10732 static int
10733 test_AES_GCM_auth_decryption_fail_aad_len_corrupt(void)
10734 {
10735         struct aead_test_data tdata;
10736         int res;
10737
10738         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10739         tdata.aad.len += 1;
10740         res = test_authenticated_decryption(&tdata);
10741         if (res == TEST_SKIPPED)
10742                 return res;
10743         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10744         return TEST_SUCCESS;
10745 }
10746
10747 static int
10748 test_AES_GCM_auth_decryption_fail_aad_corrupt(void)
10749 {
10750         struct aead_test_data tdata;
10751         uint8_t aad[gcm_test_case_7.aad.len];
10752         int res;
10753
10754         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10755         memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
10756         aad[0] += 1;
10757         tdata.aad.data = aad;
10758         res = test_authenticated_decryption(&tdata);
10759         if (res == TEST_SKIPPED)
10760                 return res;
10761         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10762         return TEST_SUCCESS;
10763 }
10764
10765 static int
10766 test_AES_GCM_auth_decryption_fail_tag_corrupt(void)
10767 {
10768         struct aead_test_data tdata;
10769         int res;
10770
10771         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10772         tdata.auth_tag.data[0] += 1;
10773         res = test_authenticated_decryption(&tdata);
10774         if (res == TEST_SKIPPED)
10775                 return res;
10776         TEST_ASSERT_EQUAL(res, TEST_FAILED, "authentication not failed");
10777         return TEST_SUCCESS;
10778 }
10779
10780 static int
10781 test_authenticated_encryption_oop(const struct aead_test_data *tdata)
10782 {
10783         struct crypto_testsuite_params *ts_params = &testsuite_params;
10784         struct crypto_unittest_params *ut_params = &unittest_params;
10785
10786         int retval;
10787         uint8_t *ciphertext, *auth_tag;
10788         uint16_t plaintext_pad_len;
10789         struct rte_cryptodev_info dev_info;
10790
10791         /* Verify the capabilities */
10792         struct rte_cryptodev_sym_capability_idx cap_idx;
10793         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10794         cap_idx.algo.aead = tdata->algo;
10795         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10796                         &cap_idx) == NULL)
10797                 return TEST_SKIPPED;
10798
10799         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10800         uint64_t feat_flags = dev_info.feature_flags;
10801
10802         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10803                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP)))
10804                 return TEST_SKIPPED;
10805
10806         /* not supported with CPU crypto */
10807         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10808                 return TEST_SKIPPED;
10809
10810         /* Create AEAD session */
10811         retval = create_aead_session(ts_params->valid_devs[0],
10812                         tdata->algo,
10813                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
10814                         tdata->key.data, tdata->key.len,
10815                         tdata->aad.len, tdata->auth_tag.len,
10816                         tdata->iv.len);
10817         if (retval < 0)
10818                 return retval;
10819
10820         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10821         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10822
10823         /* clear mbuf payload */
10824         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10825                         rte_pktmbuf_tailroom(ut_params->ibuf));
10826         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
10827                         rte_pktmbuf_tailroom(ut_params->obuf));
10828
10829         /* Create AEAD operation */
10830         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
10831         if (retval < 0)
10832                 return retval;
10833
10834         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10835
10836         ut_params->op->sym->m_src = ut_params->ibuf;
10837         ut_params->op->sym->m_dst = ut_params->obuf;
10838
10839         /* Process crypto operation */
10840         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10841                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10842                         ut_params->op, 0, 0, 0, 0);
10843         else
10844                 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
10845                         ut_params->op), "failed to process sym crypto op");
10846
10847         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10848                         "crypto op processing failed");
10849
10850         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
10851
10852         ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
10853                         ut_params->op->sym->cipher.data.offset);
10854         auth_tag = ciphertext + plaintext_pad_len;
10855
10856         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
10857         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
10858
10859         /* Validate obuf */
10860         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10861                         ciphertext,
10862                         tdata->ciphertext.data,
10863                         tdata->ciphertext.len,
10864                         "Ciphertext data not as expected");
10865
10866         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10867                         auth_tag,
10868                         tdata->auth_tag.data,
10869                         tdata->auth_tag.len,
10870                         "Generated auth tag not as expected");
10871
10872         return 0;
10873
10874 }
10875
10876 static int
10877 test_AES_GCM_authenticated_encryption_oop_test_case_1(void)
10878 {
10879         return test_authenticated_encryption_oop(&gcm_test_case_5);
10880 }
10881
10882 static int
10883 test_authenticated_decryption_oop(const struct aead_test_data *tdata)
10884 {
10885         struct crypto_testsuite_params *ts_params = &testsuite_params;
10886         struct crypto_unittest_params *ut_params = &unittest_params;
10887
10888         int retval;
10889         uint8_t *plaintext;
10890         struct rte_cryptodev_info dev_info;
10891
10892         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10893         uint64_t feat_flags = dev_info.feature_flags;
10894
10895         /* Verify the capabilities */
10896         struct rte_cryptodev_sym_capability_idx cap_idx;
10897         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10898         cap_idx.algo.aead = tdata->algo;
10899         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10900                         &cap_idx) == NULL)
10901                 return TEST_SKIPPED;
10902
10903         /* not supported with CPU crypto and raw data-path APIs*/
10904         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO ||
10905                         global_api_test_type == CRYPTODEV_RAW_API_TEST)
10906                 return TEST_SKIPPED;
10907
10908         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10909                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10910                 printf("Device does not support RAW data-path APIs.\n");
10911                 return TEST_SKIPPED;
10912         }
10913
10914         /* Create AEAD session */
10915         retval = create_aead_session(ts_params->valid_devs[0],
10916                         tdata->algo,
10917                         RTE_CRYPTO_AEAD_OP_DECRYPT,
10918                         tdata->key.data, tdata->key.len,
10919                         tdata->aad.len, tdata->auth_tag.len,
10920                         tdata->iv.len);
10921         if (retval < 0)
10922                 return retval;
10923
10924         /* alloc mbuf and set payload */
10925         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10926         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10927
10928         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10929                         rte_pktmbuf_tailroom(ut_params->ibuf));
10930         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
10931                         rte_pktmbuf_tailroom(ut_params->obuf));
10932
10933         /* Create AEAD operation */
10934         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
10935         if (retval < 0)
10936                 return retval;
10937
10938         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10939
10940         ut_params->op->sym->m_src = ut_params->ibuf;
10941         ut_params->op->sym->m_dst = ut_params->obuf;
10942
10943         /* Process crypto operation */
10944         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10945                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10946                                 ut_params->op, 0, 0, 0, 0);
10947         else
10948                 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
10949                         ut_params->op), "failed to process sym crypto op");
10950
10951         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10952                         "crypto op processing failed");
10953
10954         plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
10955                         ut_params->op->sym->cipher.data.offset);
10956
10957         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
10958
10959         /* Validate obuf */
10960         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10961                         plaintext,
10962                         tdata->plaintext.data,
10963                         tdata->plaintext.len,
10964                         "Plaintext data not as expected");
10965
10966         TEST_ASSERT_EQUAL(ut_params->op->status,
10967                         RTE_CRYPTO_OP_STATUS_SUCCESS,
10968                         "Authentication failed");
10969         return 0;
10970 }
10971
10972 static int
10973 test_AES_GCM_authenticated_decryption_oop_test_case_1(void)
10974 {
10975         return test_authenticated_decryption_oop(&gcm_test_case_5);
10976 }
10977
10978 static int
10979 test_authenticated_encryption_sessionless(
10980                 const struct aead_test_data *tdata)
10981 {
10982         struct crypto_testsuite_params *ts_params = &testsuite_params;
10983         struct crypto_unittest_params *ut_params = &unittest_params;
10984
10985         int retval;
10986         uint8_t *ciphertext, *auth_tag;
10987         uint16_t plaintext_pad_len;
10988         uint8_t key[tdata->key.len + 1];
10989         struct rte_cryptodev_info dev_info;
10990
10991         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10992         uint64_t feat_flags = dev_info.feature_flags;
10993
10994         if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
10995                 printf("Device doesn't support Sessionless ops.\n");
10996                 return TEST_SKIPPED;
10997         }
10998
10999         /* not supported with CPU crypto */
11000         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11001                 return TEST_SKIPPED;
11002
11003         /* Verify the capabilities */
11004         struct rte_cryptodev_sym_capability_idx cap_idx;
11005         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
11006         cap_idx.algo.aead = tdata->algo;
11007         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11008                         &cap_idx) == NULL)
11009                 return TEST_SKIPPED;
11010
11011         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11012
11013         /* clear mbuf payload */
11014         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11015                         rte_pktmbuf_tailroom(ut_params->ibuf));
11016
11017         /* Create AEAD operation */
11018         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
11019         if (retval < 0)
11020                 return retval;
11021
11022         /* Create GCM xform */
11023         memcpy(key, tdata->key.data, tdata->key.len);
11024         retval = create_aead_xform(ut_params->op,
11025                         tdata->algo,
11026                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
11027                         key, tdata->key.len,
11028                         tdata->aad.len, tdata->auth_tag.len,
11029                         tdata->iv.len);
11030         if (retval < 0)
11031                 return retval;
11032
11033         ut_params->op->sym->m_src = ut_params->ibuf;
11034
11035         TEST_ASSERT_EQUAL(ut_params->op->sess_type,
11036                         RTE_CRYPTO_OP_SESSIONLESS,
11037                         "crypto op session type not sessionless");
11038
11039         /* Process crypto operation */
11040         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
11041                         ut_params->op), "failed to process sym crypto op");
11042
11043         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
11044
11045         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11046                         "crypto op status not success");
11047
11048         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
11049
11050         ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
11051                         ut_params->op->sym->cipher.data.offset);
11052         auth_tag = ciphertext + plaintext_pad_len;
11053
11054         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
11055         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
11056
11057         /* Validate obuf */
11058         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11059                         ciphertext,
11060                         tdata->ciphertext.data,
11061                         tdata->ciphertext.len,
11062                         "Ciphertext data not as expected");
11063
11064         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11065                         auth_tag,
11066                         tdata->auth_tag.data,
11067                         tdata->auth_tag.len,
11068                         "Generated auth tag not as expected");
11069
11070         return 0;
11071
11072 }
11073
11074 static int
11075 test_AES_GCM_authenticated_encryption_sessionless_test_case_1(void)
11076 {
11077         return test_authenticated_encryption_sessionless(
11078                         &gcm_test_case_5);
11079 }
11080
11081 static int
11082 test_authenticated_decryption_sessionless(
11083                 const struct aead_test_data *tdata)
11084 {
11085         struct crypto_testsuite_params *ts_params = &testsuite_params;
11086         struct crypto_unittest_params *ut_params = &unittest_params;
11087
11088         int retval;
11089         uint8_t *plaintext;
11090         uint8_t key[tdata->key.len + 1];
11091         struct rte_cryptodev_info dev_info;
11092
11093         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11094         uint64_t feat_flags = dev_info.feature_flags;
11095
11096         if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
11097                 printf("Device doesn't support Sessionless ops.\n");
11098                 return TEST_SKIPPED;
11099         }
11100
11101         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11102                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11103                 printf("Device doesn't support RAW data-path APIs.\n");
11104                 return TEST_SKIPPED;
11105         }
11106
11107         /* not supported with CPU crypto */
11108         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11109                 return TEST_SKIPPED;
11110
11111         /* Verify the capabilities */
11112         struct rte_cryptodev_sym_capability_idx cap_idx;
11113         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
11114         cap_idx.algo.aead = tdata->algo;
11115         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11116                         &cap_idx) == NULL)
11117                 return TEST_SKIPPED;
11118
11119         /* alloc mbuf and set payload */
11120         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11121
11122         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11123                         rte_pktmbuf_tailroom(ut_params->ibuf));
11124
11125         /* Create AEAD operation */
11126         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
11127         if (retval < 0)
11128                 return retval;
11129
11130         /* Create AEAD xform */
11131         memcpy(key, tdata->key.data, tdata->key.len);
11132         retval = create_aead_xform(ut_params->op,
11133                         tdata->algo,
11134                         RTE_CRYPTO_AEAD_OP_DECRYPT,
11135                         key, tdata->key.len,
11136                         tdata->aad.len, tdata->auth_tag.len,
11137                         tdata->iv.len);
11138         if (retval < 0)
11139                 return retval;
11140
11141         ut_params->op->sym->m_src = ut_params->ibuf;
11142
11143         TEST_ASSERT_EQUAL(ut_params->op->sess_type,
11144                         RTE_CRYPTO_OP_SESSIONLESS,
11145                         "crypto op session type not sessionless");
11146
11147         /* Process crypto operation */
11148         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11149                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11150                                 ut_params->op, 0, 0, 0, 0);
11151         else
11152                 TEST_ASSERT_NOT_NULL(process_crypto_request(
11153                         ts_params->valid_devs[0], ut_params->op),
11154                                 "failed to process sym crypto op");
11155
11156         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
11157
11158         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11159                         "crypto op status not success");
11160
11161         plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
11162                         ut_params->op->sym->cipher.data.offset);
11163
11164         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
11165
11166         /* Validate obuf */
11167         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11168                         plaintext,
11169                         tdata->plaintext.data,
11170                         tdata->plaintext.len,
11171                         "Plaintext data not as expected");
11172
11173         TEST_ASSERT_EQUAL(ut_params->op->status,
11174                         RTE_CRYPTO_OP_STATUS_SUCCESS,
11175                         "Authentication failed");
11176         return 0;
11177 }
11178
11179 static int
11180 test_AES_GCM_authenticated_decryption_sessionless_test_case_1(void)
11181 {
11182         return test_authenticated_decryption_sessionless(
11183                         &gcm_test_case_5);
11184 }
11185
11186 static int
11187 test_AES_CCM_authenticated_encryption_test_case_128_1(void)
11188 {
11189         return test_authenticated_encryption(&ccm_test_case_128_1);
11190 }
11191
11192 static int
11193 test_AES_CCM_authenticated_encryption_test_case_128_2(void)
11194 {
11195         return test_authenticated_encryption(&ccm_test_case_128_2);
11196 }
11197
11198 static int
11199 test_AES_CCM_authenticated_encryption_test_case_128_3(void)
11200 {
11201         return test_authenticated_encryption(&ccm_test_case_128_3);
11202 }
11203
11204 static int
11205 test_AES_CCM_authenticated_decryption_test_case_128_1(void)
11206 {
11207         return test_authenticated_decryption(&ccm_test_case_128_1);
11208 }
11209
11210 static int
11211 test_AES_CCM_authenticated_decryption_test_case_128_2(void)
11212 {
11213         return test_authenticated_decryption(&ccm_test_case_128_2);
11214 }
11215
11216 static int
11217 test_AES_CCM_authenticated_decryption_test_case_128_3(void)
11218 {
11219         return test_authenticated_decryption(&ccm_test_case_128_3);
11220 }
11221
11222 static int
11223 test_AES_CCM_authenticated_encryption_test_case_192_1(void)
11224 {
11225         return test_authenticated_encryption(&ccm_test_case_192_1);
11226 }
11227
11228 static int
11229 test_AES_CCM_authenticated_encryption_test_case_192_2(void)
11230 {
11231         return test_authenticated_encryption(&ccm_test_case_192_2);
11232 }
11233
11234 static int
11235 test_AES_CCM_authenticated_encryption_test_case_192_3(void)
11236 {
11237         return test_authenticated_encryption(&ccm_test_case_192_3);
11238 }
11239
11240 static int
11241 test_AES_CCM_authenticated_decryption_test_case_192_1(void)
11242 {
11243         return test_authenticated_decryption(&ccm_test_case_192_1);
11244 }
11245
11246 static int
11247 test_AES_CCM_authenticated_decryption_test_case_192_2(void)
11248 {
11249         return test_authenticated_decryption(&ccm_test_case_192_2);
11250 }
11251
11252 static int
11253 test_AES_CCM_authenticated_decryption_test_case_192_3(void)
11254 {
11255         return test_authenticated_decryption(&ccm_test_case_192_3);
11256 }
11257
11258 static int
11259 test_AES_CCM_authenticated_encryption_test_case_256_1(void)
11260 {
11261         return test_authenticated_encryption(&ccm_test_case_256_1);
11262 }
11263
11264 static int
11265 test_AES_CCM_authenticated_encryption_test_case_256_2(void)
11266 {
11267         return test_authenticated_encryption(&ccm_test_case_256_2);
11268 }
11269
11270 static int
11271 test_AES_CCM_authenticated_encryption_test_case_256_3(void)
11272 {
11273         return test_authenticated_encryption(&ccm_test_case_256_3);
11274 }
11275
11276 static int
11277 test_AES_CCM_authenticated_decryption_test_case_256_1(void)
11278 {
11279         return test_authenticated_decryption(&ccm_test_case_256_1);
11280 }
11281
11282 static int
11283 test_AES_CCM_authenticated_decryption_test_case_256_2(void)
11284 {
11285         return test_authenticated_decryption(&ccm_test_case_256_2);
11286 }
11287
11288 static int
11289 test_AES_CCM_authenticated_decryption_test_case_256_3(void)
11290 {
11291         return test_authenticated_decryption(&ccm_test_case_256_3);
11292 }
11293
11294 static int
11295 test_stats(void)
11296 {
11297         struct crypto_testsuite_params *ts_params = &testsuite_params;
11298         struct rte_cryptodev_stats stats;
11299
11300         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11301                 return TEST_SKIPPED;
11302
11303         /* Verify the capabilities */
11304         struct rte_cryptodev_sym_capability_idx cap_idx;
11305         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11306         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
11307         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11308                         &cap_idx) == NULL)
11309                 return TEST_SKIPPED;
11310         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11311         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
11312         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11313                         &cap_idx) == NULL)
11314                 return TEST_SKIPPED;
11315
11316         if (rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
11317                         == -ENOTSUP)
11318                 return TEST_SKIPPED;
11319
11320         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
11321         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
11322                         &stats) == -ENODEV),
11323                 "rte_cryptodev_stats_get invalid dev failed");
11324         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
11325                 "rte_cryptodev_stats_get invalid Param failed");
11326
11327         /* Test expected values */
11328         test_AES_CBC_HMAC_SHA1_encrypt_digest();
11329         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
11330                         &stats),
11331                 "rte_cryptodev_stats_get failed");
11332         TEST_ASSERT((stats.enqueued_count == 1),
11333                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11334         TEST_ASSERT((stats.dequeued_count == 1),
11335                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11336         TEST_ASSERT((stats.enqueue_err_count == 0),
11337                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11338         TEST_ASSERT((stats.dequeue_err_count == 0),
11339                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11340
11341         /* invalid device but should ignore and not reset device stats*/
11342         rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
11343         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
11344                         &stats),
11345                 "rte_cryptodev_stats_get failed");
11346         TEST_ASSERT((stats.enqueued_count == 1),
11347                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11348
11349         /* check that a valid reset clears stats */
11350         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
11351         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
11352                         &stats),
11353                                           "rte_cryptodev_stats_get failed");
11354         TEST_ASSERT((stats.enqueued_count == 0),
11355                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11356         TEST_ASSERT((stats.dequeued_count == 0),
11357                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11358
11359         return TEST_SUCCESS;
11360 }
11361
11362 static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
11363                                    struct crypto_unittest_params *ut_params,
11364                                    enum rte_crypto_auth_operation op,
11365                                    const struct HMAC_MD5_vector *test_case)
11366 {
11367         uint8_t key[64];
11368         int status;
11369
11370         memcpy(key, test_case->key.data, test_case->key.len);
11371
11372         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11373         ut_params->auth_xform.next = NULL;
11374         ut_params->auth_xform.auth.op = op;
11375
11376         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC;
11377
11378         ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN;
11379         ut_params->auth_xform.auth.key.length = test_case->key.len;
11380         ut_params->auth_xform.auth.key.data = key;
11381
11382         ut_params->sess = rte_cryptodev_sym_session_create(
11383                         ts_params->session_mpool);
11384         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
11385         if (ut_params->sess == NULL)
11386                 return TEST_FAILED;
11387
11388         status = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11389                         ut_params->sess, &ut_params->auth_xform,
11390                         ts_params->session_priv_mpool);
11391         if (status == -ENOTSUP)
11392                 return TEST_SKIPPED;
11393
11394         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11395
11396         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11397                         rte_pktmbuf_tailroom(ut_params->ibuf));
11398
11399         return 0;
11400 }
11401
11402 static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
11403                               const struct HMAC_MD5_vector *test_case,
11404                               uint8_t **plaintext)
11405 {
11406         uint16_t plaintext_pad_len;
11407
11408         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
11409
11410         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
11411                                 16);
11412
11413         *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11414                         plaintext_pad_len);
11415         memcpy(*plaintext, test_case->plaintext.data,
11416                         test_case->plaintext.len);
11417
11418         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
11419                         ut_params->ibuf, MD5_DIGEST_LEN);
11420         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
11421                         "no room to append digest");
11422         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
11423                         ut_params->ibuf, plaintext_pad_len);
11424
11425         if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
11426                 rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data,
11427                            test_case->auth_tag.len);
11428         }
11429
11430         sym_op->auth.data.offset = 0;
11431         sym_op->auth.data.length = test_case->plaintext.len;
11432
11433         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11434         ut_params->op->sym->m_src = ut_params->ibuf;
11435
11436         return 0;
11437 }
11438
11439 static int
11440 test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
11441 {
11442         uint16_t plaintext_pad_len;
11443         uint8_t *plaintext, *auth_tag;
11444
11445         struct crypto_testsuite_params *ts_params = &testsuite_params;
11446         struct crypto_unittest_params *ut_params = &unittest_params;
11447         struct rte_cryptodev_info dev_info;
11448
11449         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11450         uint64_t feat_flags = dev_info.feature_flags;
11451
11452         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11453                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11454                 printf("Device doesn't support RAW data-path APIs.\n");
11455                 return TEST_SKIPPED;
11456         }
11457
11458         /* Verify the capabilities */
11459         struct rte_cryptodev_sym_capability_idx cap_idx;
11460         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11461         cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
11462         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11463                         &cap_idx) == NULL)
11464                 return TEST_SKIPPED;
11465
11466         if (MD5_HMAC_create_session(ts_params, ut_params,
11467                         RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
11468                 return TEST_FAILED;
11469
11470         /* Generate Crypto op data structure */
11471         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11472                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11473         TEST_ASSERT_NOT_NULL(ut_params->op,
11474                         "Failed to allocate symmetric crypto operation struct");
11475
11476         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
11477                                 16);
11478
11479         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
11480                 return TEST_FAILED;
11481
11482         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11483                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11484                         ut_params->op);
11485         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11486                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11487                                 ut_params->op, 0, 1, 0, 0);
11488         else
11489                 TEST_ASSERT_NOT_NULL(
11490                         process_crypto_request(ts_params->valid_devs[0],
11491                                 ut_params->op),
11492                                 "failed to process sym crypto op");
11493
11494         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11495                         "crypto op processing failed");
11496
11497         if (ut_params->op->sym->m_dst) {
11498                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
11499                                 uint8_t *, plaintext_pad_len);
11500         } else {
11501                 auth_tag = plaintext + plaintext_pad_len;
11502         }
11503
11504         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11505                         auth_tag,
11506                         test_case->auth_tag.data,
11507                         test_case->auth_tag.len,
11508                         "HMAC_MD5 generated tag not as expected");
11509
11510         return TEST_SUCCESS;
11511 }
11512
11513 static int
11514 test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
11515 {
11516         uint8_t *plaintext;
11517
11518         struct crypto_testsuite_params *ts_params = &testsuite_params;
11519         struct crypto_unittest_params *ut_params = &unittest_params;
11520         struct rte_cryptodev_info dev_info;
11521
11522         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11523         uint64_t feat_flags = dev_info.feature_flags;
11524
11525         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11526                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11527                 printf("Device doesn't support RAW data-path APIs.\n");
11528                 return TEST_SKIPPED;
11529         }
11530
11531         /* Verify the capabilities */
11532         struct rte_cryptodev_sym_capability_idx cap_idx;
11533         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11534         cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
11535         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11536                         &cap_idx) == NULL)
11537                 return TEST_SKIPPED;
11538
11539         if (MD5_HMAC_create_session(ts_params, ut_params,
11540                         RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
11541                 return TEST_FAILED;
11542         }
11543
11544         /* Generate Crypto op data structure */
11545         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11546                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11547         TEST_ASSERT_NOT_NULL(ut_params->op,
11548                         "Failed to allocate symmetric crypto operation struct");
11549
11550         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
11551                 return TEST_FAILED;
11552
11553         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11554                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11555                         ut_params->op);
11556         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11557                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11558                                 ut_params->op, 0, 1, 0, 0);
11559         else
11560                 TEST_ASSERT_NOT_NULL(
11561                         process_crypto_request(ts_params->valid_devs[0],
11562                                 ut_params->op),
11563                                 "failed to process sym crypto op");
11564
11565         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11566                         "HMAC_MD5 crypto op processing failed");
11567
11568         return TEST_SUCCESS;
11569 }
11570
11571 static int
11572 test_MD5_HMAC_generate_case_1(void)
11573 {
11574         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1);
11575 }
11576
11577 static int
11578 test_MD5_HMAC_verify_case_1(void)
11579 {
11580         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1);
11581 }
11582
11583 static int
11584 test_MD5_HMAC_generate_case_2(void)
11585 {
11586         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2);
11587 }
11588
11589 static int
11590 test_MD5_HMAC_verify_case_2(void)
11591 {
11592         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2);
11593 }
11594
11595 static int
11596 test_multi_session(void)
11597 {
11598         struct crypto_testsuite_params *ts_params = &testsuite_params;
11599         struct crypto_unittest_params *ut_params = &unittest_params;
11600
11601         struct rte_cryptodev_info dev_info;
11602         struct rte_cryptodev_sym_session **sessions;
11603
11604         uint16_t i;
11605         int status;
11606
11607         /* Verify the capabilities */
11608         struct rte_cryptodev_sym_capability_idx cap_idx;
11609         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11610         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
11611         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11612                         &cap_idx) == NULL)
11613                 return TEST_SKIPPED;
11614         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11615         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
11616         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11617                         &cap_idx) == NULL)
11618                 return TEST_SKIPPED;
11619
11620         test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
11621                         aes_cbc_key, hmac_sha512_key);
11622
11623
11624         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11625
11626         sessions = rte_malloc(NULL,
11627                         sizeof(struct rte_cryptodev_sym_session *) *
11628                         (MAX_NB_SESSIONS + 1), 0);
11629
11630         /* Create multiple crypto sessions*/
11631         for (i = 0; i < MAX_NB_SESSIONS; i++) {
11632
11633                 sessions[i] = rte_cryptodev_sym_session_create(
11634                                 ts_params->session_mpool);
11635                 TEST_ASSERT_NOT_NULL(sessions[i],
11636                                 "Session creation failed at session number %u",
11637                                 i);
11638
11639                 status = rte_cryptodev_sym_session_init(
11640                                 ts_params->valid_devs[0],
11641                                 sessions[i], &ut_params->auth_xform,
11642                                 ts_params->session_priv_mpool);
11643                 if (status == -ENOTSUP)
11644                         return TEST_SKIPPED;
11645
11646                 /* Attempt to send a request on each session */
11647                 TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform(
11648                         sessions[i],
11649                         ut_params,
11650                         ts_params,
11651                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
11652                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
11653                         aes_cbc_iv),
11654                         "Failed to perform decrypt on request number %u.", i);
11655                 /* free crypto operation structure */
11656                 if (ut_params->op)
11657                         rte_crypto_op_free(ut_params->op);
11658
11659                 /*
11660                  * free mbuf - both obuf and ibuf are usually the same,
11661                  * so check if they point at the same address is necessary,
11662                  * to avoid freeing the mbuf twice.
11663                  */
11664                 if (ut_params->obuf) {
11665                         rte_pktmbuf_free(ut_params->obuf);
11666                         if (ut_params->ibuf == ut_params->obuf)
11667                                 ut_params->ibuf = 0;
11668                         ut_params->obuf = 0;
11669                 }
11670                 if (ut_params->ibuf) {
11671                         rte_pktmbuf_free(ut_params->ibuf);
11672                         ut_params->ibuf = 0;
11673                 }
11674         }
11675
11676         sessions[i] = NULL;
11677         /* Next session create should fail */
11678         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11679                         sessions[i], &ut_params->auth_xform,
11680                         ts_params->session_priv_mpool);
11681         TEST_ASSERT_NULL(sessions[i],
11682                         "Session creation succeeded unexpectedly!");
11683
11684         for (i = 0; i < MAX_NB_SESSIONS; i++) {
11685                 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
11686                                 sessions[i]);
11687                 rte_cryptodev_sym_session_free(sessions[i]);
11688         }
11689
11690         rte_free(sessions);
11691
11692         return TEST_SUCCESS;
11693 }
11694
11695 struct multi_session_params {
11696         struct crypto_unittest_params ut_params;
11697         uint8_t *cipher_key;
11698         uint8_t *hmac_key;
11699         const uint8_t *cipher;
11700         const uint8_t *digest;
11701         uint8_t *iv;
11702 };
11703
11704 #define MB_SESSION_NUMBER 3
11705
11706 static int
11707 test_multi_session_random_usage(void)
11708 {
11709         struct crypto_testsuite_params *ts_params = &testsuite_params;
11710         struct rte_cryptodev_info dev_info;
11711         struct rte_cryptodev_sym_session **sessions;
11712         uint32_t i, j;
11713         struct multi_session_params ut_paramz[] = {
11714
11715                 {
11716                         .cipher_key = ms_aes_cbc_key0,
11717                         .hmac_key = ms_hmac_key0,
11718                         .cipher = ms_aes_cbc_cipher0,
11719                         .digest = ms_hmac_digest0,
11720                         .iv = ms_aes_cbc_iv0
11721                 },
11722                 {
11723                         .cipher_key = ms_aes_cbc_key1,
11724                         .hmac_key = ms_hmac_key1,
11725                         .cipher = ms_aes_cbc_cipher1,
11726                         .digest = ms_hmac_digest1,
11727                         .iv = ms_aes_cbc_iv1
11728                 },
11729                 {
11730                         .cipher_key = ms_aes_cbc_key2,
11731                         .hmac_key = ms_hmac_key2,
11732                         .cipher = ms_aes_cbc_cipher2,
11733                         .digest = ms_hmac_digest2,
11734                         .iv = ms_aes_cbc_iv2
11735                 },
11736
11737         };
11738         int status;
11739
11740         /* Verify the capabilities */
11741         struct rte_cryptodev_sym_capability_idx cap_idx;
11742         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11743         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
11744         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11745                         &cap_idx) == NULL)
11746                 return TEST_SKIPPED;
11747         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11748         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
11749         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11750                         &cap_idx) == NULL)
11751                 return TEST_SKIPPED;
11752
11753         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11754
11755         sessions = rte_malloc(NULL,
11756                         (sizeof(struct rte_cryptodev_sym_session *)
11757                                         * MAX_NB_SESSIONS) + 1, 0);
11758
11759         for (i = 0; i < MB_SESSION_NUMBER; i++) {
11760                 sessions[i] = rte_cryptodev_sym_session_create(
11761                                 ts_params->session_mpool);
11762                 TEST_ASSERT_NOT_NULL(sessions[i],
11763                                 "Session creation failed at session number %u",
11764                                 i);
11765
11766                 rte_memcpy(&ut_paramz[i].ut_params, &unittest_params,
11767                                 sizeof(struct crypto_unittest_params));
11768
11769                 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
11770                                 &ut_paramz[i].ut_params,
11771                                 ut_paramz[i].cipher_key, ut_paramz[i].hmac_key);
11772
11773                 /* Create multiple crypto sessions*/
11774                 status = rte_cryptodev_sym_session_init(
11775                                 ts_params->valid_devs[0],
11776                                 sessions[i],
11777                                 &ut_paramz[i].ut_params.auth_xform,
11778                                 ts_params->session_priv_mpool);
11779
11780                 if (status == -ENOTSUP)
11781                         return TEST_SKIPPED;
11782
11783                 TEST_ASSERT_EQUAL(status, 0, "Session init failed");
11784         }
11785
11786         srand(time(NULL));
11787         for (i = 0; i < 40000; i++) {
11788
11789                 j = rand() % MB_SESSION_NUMBER;
11790
11791                 TEST_ASSERT_SUCCESS(
11792                         test_AES_CBC_HMAC_SHA512_decrypt_perform(
11793                                         sessions[j],
11794                                         &ut_paramz[j].ut_params,
11795                                         ts_params, ut_paramz[j].cipher,
11796                                         ut_paramz[j].digest,
11797                                         ut_paramz[j].iv),
11798                         "Failed to perform decrypt on request number %u.", i);
11799
11800                 if (ut_paramz[j].ut_params.op)
11801                         rte_crypto_op_free(ut_paramz[j].ut_params.op);
11802
11803                 /*
11804                  * free mbuf - both obuf and ibuf are usually the same,
11805                  * so check if they point at the same address is necessary,
11806                  * to avoid freeing the mbuf twice.
11807                  */
11808                 if (ut_paramz[j].ut_params.obuf) {
11809                         rte_pktmbuf_free(ut_paramz[j].ut_params.obuf);
11810                         if (ut_paramz[j].ut_params.ibuf
11811                                         == ut_paramz[j].ut_params.obuf)
11812                                 ut_paramz[j].ut_params.ibuf = 0;
11813                         ut_paramz[j].ut_params.obuf = 0;
11814                 }
11815                 if (ut_paramz[j].ut_params.ibuf) {
11816                         rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf);
11817                         ut_paramz[j].ut_params.ibuf = 0;
11818                 }
11819         }
11820
11821         for (i = 0; i < MB_SESSION_NUMBER; i++) {
11822                 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
11823                                 sessions[i]);
11824                 rte_cryptodev_sym_session_free(sessions[i]);
11825         }
11826
11827         rte_free(sessions);
11828
11829         return TEST_SUCCESS;
11830 }
11831
11832 uint8_t orig_data[] = {0xab, 0xab, 0xab, 0xab,
11833                         0xab, 0xab, 0xab, 0xab,
11834                         0xab, 0xab, 0xab, 0xab,
11835                         0xab, 0xab, 0xab, 0xab};
11836
11837 static int
11838 test_null_invalid_operation(void)
11839 {
11840         struct crypto_testsuite_params *ts_params = &testsuite_params;
11841         struct crypto_unittest_params *ut_params = &unittest_params;
11842         int ret;
11843
11844         /* This test is for NULL PMD only */
11845         if (gbl_driver_id != rte_cryptodev_driver_id_get(
11846                         RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
11847                 return TEST_SKIPPED;
11848
11849         /* Setup Cipher Parameters */
11850         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11851         ut_params->cipher_xform.next = NULL;
11852
11853         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
11854         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
11855
11856         ut_params->sess = rte_cryptodev_sym_session_create(
11857                         ts_params->session_mpool);
11858
11859         /* Create Crypto session*/
11860         ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11861                         ut_params->sess, &ut_params->cipher_xform,
11862                         ts_params->session_priv_mpool);
11863         TEST_ASSERT(ret < 0,
11864                         "Session creation succeeded unexpectedly");
11865
11866
11867         /* Setup HMAC Parameters */
11868         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11869         ut_params->auth_xform.next = NULL;
11870
11871         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
11872         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
11873
11874         ut_params->sess = rte_cryptodev_sym_session_create(
11875                         ts_params->session_mpool);
11876
11877         /* Create Crypto session*/
11878         ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11879                         ut_params->sess, &ut_params->auth_xform,
11880                         ts_params->session_priv_mpool);
11881         TEST_ASSERT(ret < 0,
11882                         "Session creation succeeded unexpectedly");
11883
11884         return TEST_SUCCESS;
11885 }
11886
11887
11888 #define NULL_BURST_LENGTH (32)
11889
11890 static int
11891 test_null_burst_operation(void)
11892 {
11893         struct crypto_testsuite_params *ts_params = &testsuite_params;
11894         struct crypto_unittest_params *ut_params = &unittest_params;
11895         int status;
11896
11897         unsigned i, burst_len = NULL_BURST_LENGTH;
11898
11899         struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
11900         struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
11901
11902         /* This test is for NULL PMD only */
11903         if (gbl_driver_id != rte_cryptodev_driver_id_get(
11904                         RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
11905                 return TEST_SKIPPED;
11906
11907         /* Setup Cipher Parameters */
11908         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11909         ut_params->cipher_xform.next = &ut_params->auth_xform;
11910
11911         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
11912         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
11913
11914         /* Setup HMAC Parameters */
11915         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11916         ut_params->auth_xform.next = NULL;
11917
11918         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
11919         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
11920
11921         ut_params->sess = rte_cryptodev_sym_session_create(
11922                         ts_params->session_mpool);
11923         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
11924
11925         /* Create Crypto session*/
11926         status = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11927                         ut_params->sess, &ut_params->cipher_xform,
11928                         ts_params->session_priv_mpool);
11929
11930         if (status == -ENOTSUP)
11931                 return TEST_SKIPPED;
11932
11933         TEST_ASSERT_EQUAL(status, 0, "Session init failed");
11934
11935         TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
11936                         RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
11937                         burst_len, "failed to generate burst of crypto ops");
11938
11939         /* Generate an operation for each mbuf in burst */
11940         for (i = 0; i < burst_len; i++) {
11941                 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11942
11943                 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
11944
11945                 unsigned *data = (unsigned *)rte_pktmbuf_append(m,
11946                                 sizeof(unsigned));
11947                 *data = i;
11948
11949                 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
11950
11951                 burst[i]->sym->m_src = m;
11952         }
11953
11954         /* Process crypto operation */
11955         TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
11956                         0, burst, burst_len),
11957                         burst_len,
11958                         "Error enqueuing burst");
11959
11960         TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
11961                         0, burst_dequeued, burst_len),
11962                         burst_len,
11963                         "Error dequeuing burst");
11964
11965
11966         for (i = 0; i < burst_len; i++) {
11967                 TEST_ASSERT_EQUAL(
11968                         *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
11969                         *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
11970                                         uint32_t *),
11971                         "data not as expected");
11972
11973                 rte_pktmbuf_free(burst[i]->sym->m_src);
11974                 rte_crypto_op_free(burst[i]);
11975         }
11976
11977         return TEST_SUCCESS;
11978 }
11979
11980 static uint16_t
11981 test_enq_callback(uint16_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops,
11982                   uint16_t nb_ops, void *user_param)
11983 {
11984         RTE_SET_USED(dev_id);
11985         RTE_SET_USED(qp_id);
11986         RTE_SET_USED(ops);
11987         RTE_SET_USED(user_param);
11988
11989         printf("crypto enqueue callback called\n");
11990         return nb_ops;
11991 }
11992
11993 static uint16_t
11994 test_deq_callback(uint16_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops,
11995                   uint16_t nb_ops, void *user_param)
11996 {
11997         RTE_SET_USED(dev_id);
11998         RTE_SET_USED(qp_id);
11999         RTE_SET_USED(ops);
12000         RTE_SET_USED(user_param);
12001
12002         printf("crypto dequeue callback called\n");
12003         return nb_ops;
12004 }
12005
12006 /*
12007  * Thread using enqueue/dequeue callback with RCU.
12008  */
12009 static int
12010 test_enqdeq_callback_thread(void *arg)
12011 {
12012         RTE_SET_USED(arg);
12013         /* DP thread calls rte_cryptodev_enqueue_burst()/
12014          * rte_cryptodev_dequeue_burst() and invokes callback.
12015          */
12016         test_null_burst_operation();
12017         return 0;
12018 }
12019
12020 static int
12021 test_enq_callback_setup(void)
12022 {
12023         struct crypto_testsuite_params *ts_params = &testsuite_params;
12024         struct rte_cryptodev_info dev_info;
12025         struct rte_cryptodev_qp_conf qp_conf = {
12026                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
12027         };
12028
12029         struct rte_cryptodev_cb *cb;
12030         uint16_t qp_id = 0;
12031
12032         /* Stop the device in case it's started so it can be configured */
12033         rte_cryptodev_stop(ts_params->valid_devs[0]);
12034
12035         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12036
12037         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
12038                         &ts_params->conf),
12039                         "Failed to configure cryptodev %u",
12040                         ts_params->valid_devs[0]);
12041
12042         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
12043         qp_conf.mp_session = ts_params->session_mpool;
12044         qp_conf.mp_session_private = ts_params->session_priv_mpool;
12045
12046         TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
12047                         ts_params->valid_devs[0], qp_id, &qp_conf,
12048                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
12049                         "Failed test for "
12050                         "rte_cryptodev_queue_pair_setup: num_inflights "
12051                         "%u on qp %u on cryptodev %u",
12052                         qp_conf.nb_descriptors, qp_id,
12053                         ts_params->valid_devs[0]);
12054
12055         /* Test with invalid crypto device */
12056         cb = rte_cryptodev_add_enq_callback(RTE_CRYPTO_MAX_DEVS,
12057                         qp_id, test_enq_callback, NULL);
12058         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12059                         "cryptodev %u did not fail",
12060                         qp_id, RTE_CRYPTO_MAX_DEVS);
12061
12062         /* Test with invalid queue pair */
12063         cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
12064                         dev_info.max_nb_queue_pairs + 1,
12065                         test_enq_callback, NULL);
12066         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12067                         "cryptodev %u did not fail",
12068                         dev_info.max_nb_queue_pairs + 1,
12069                         ts_params->valid_devs[0]);
12070
12071         /* Test with NULL callback */
12072         cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
12073                         qp_id, NULL, NULL);
12074         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12075                         "cryptodev %u did not fail",
12076                         qp_id, ts_params->valid_devs[0]);
12077
12078         /* Test with valid configuration */
12079         cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
12080                         qp_id, test_enq_callback, NULL);
12081         TEST_ASSERT_NOT_NULL(cb, "Failed test to add callback on "
12082                         "qp %u on cryptodev %u",
12083                         qp_id, ts_params->valid_devs[0]);
12084
12085         rte_cryptodev_start(ts_params->valid_devs[0]);
12086
12087         /* Launch a thread */
12088         rte_eal_remote_launch(test_enqdeq_callback_thread, NULL,
12089                                 rte_get_next_lcore(-1, 1, 0));
12090
12091         /* Wait until reader exited. */
12092         rte_eal_mp_wait_lcore();
12093
12094         /* Test with invalid crypto device */
12095         TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
12096                         RTE_CRYPTO_MAX_DEVS, qp_id, cb),
12097                         "Expected call to fail as crypto device is invalid");
12098
12099         /* Test with invalid queue pair */
12100         TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
12101                         ts_params->valid_devs[0],
12102                         dev_info.max_nb_queue_pairs + 1, cb),
12103                         "Expected call to fail as queue pair is invalid");
12104
12105         /* Test with NULL callback */
12106         TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
12107                         ts_params->valid_devs[0], qp_id, NULL),
12108                         "Expected call to fail as callback is NULL");
12109
12110         /* Test with valid configuration */
12111         TEST_ASSERT_SUCCESS(rte_cryptodev_remove_enq_callback(
12112                         ts_params->valid_devs[0], qp_id, cb),
12113                         "Failed test to remove callback on "
12114                         "qp %u on cryptodev %u",
12115                         qp_id, ts_params->valid_devs[0]);
12116
12117         return TEST_SUCCESS;
12118 }
12119
12120 static int
12121 test_deq_callback_setup(void)
12122 {
12123         struct crypto_testsuite_params *ts_params = &testsuite_params;
12124         struct rte_cryptodev_info dev_info;
12125         struct rte_cryptodev_qp_conf qp_conf = {
12126                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
12127         };
12128
12129         struct rte_cryptodev_cb *cb;
12130         uint16_t qp_id = 0;
12131
12132         /* Stop the device in case it's started so it can be configured */
12133         rte_cryptodev_stop(ts_params->valid_devs[0]);
12134
12135         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12136
12137         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
12138                         &ts_params->conf),
12139                         "Failed to configure cryptodev %u",
12140                         ts_params->valid_devs[0]);
12141
12142         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
12143         qp_conf.mp_session = ts_params->session_mpool;
12144         qp_conf.mp_session_private = ts_params->session_priv_mpool;
12145
12146         TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
12147                         ts_params->valid_devs[0], qp_id, &qp_conf,
12148                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
12149                         "Failed test for "
12150                         "rte_cryptodev_queue_pair_setup: num_inflights "
12151                         "%u on qp %u on cryptodev %u",
12152                         qp_conf.nb_descriptors, qp_id,
12153                         ts_params->valid_devs[0]);
12154
12155         /* Test with invalid crypto device */
12156         cb = rte_cryptodev_add_deq_callback(RTE_CRYPTO_MAX_DEVS,
12157                         qp_id, test_deq_callback, NULL);
12158         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12159                         "cryptodev %u did not fail",
12160                         qp_id, RTE_CRYPTO_MAX_DEVS);
12161
12162         /* Test with invalid queue pair */
12163         cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
12164                         dev_info.max_nb_queue_pairs + 1,
12165                         test_deq_callback, NULL);
12166         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12167                         "cryptodev %u did not fail",
12168                         dev_info.max_nb_queue_pairs + 1,
12169                         ts_params->valid_devs[0]);
12170
12171         /* Test with NULL callback */
12172         cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
12173                         qp_id, NULL, NULL);
12174         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12175                         "cryptodev %u did not fail",
12176                         qp_id, ts_params->valid_devs[0]);
12177
12178         /* Test with valid configuration */
12179         cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
12180                         qp_id, test_deq_callback, NULL);
12181         TEST_ASSERT_NOT_NULL(cb, "Failed test to add callback on "
12182                         "qp %u on cryptodev %u",
12183                         qp_id, ts_params->valid_devs[0]);
12184
12185         rte_cryptodev_start(ts_params->valid_devs[0]);
12186
12187         /* Launch a thread */
12188         rte_eal_remote_launch(test_enqdeq_callback_thread, NULL,
12189                                 rte_get_next_lcore(-1, 1, 0));
12190
12191         /* Wait until reader exited. */
12192         rte_eal_mp_wait_lcore();
12193
12194         /* Test with invalid crypto device */
12195         TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
12196                         RTE_CRYPTO_MAX_DEVS, qp_id, cb),
12197                         "Expected call to fail as crypto device is invalid");
12198
12199         /* Test with invalid queue pair */
12200         TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
12201                         ts_params->valid_devs[0],
12202                         dev_info.max_nb_queue_pairs + 1, cb),
12203                         "Expected call to fail as queue pair is invalid");
12204
12205         /* Test with NULL callback */
12206         TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
12207                         ts_params->valid_devs[0], qp_id, NULL),
12208                         "Expected call to fail as callback is NULL");
12209
12210         /* Test with valid configuration */
12211         TEST_ASSERT_SUCCESS(rte_cryptodev_remove_deq_callback(
12212                         ts_params->valid_devs[0], qp_id, cb),
12213                         "Failed test to remove callback on "
12214                         "qp %u on cryptodev %u",
12215                         qp_id, ts_params->valid_devs[0]);
12216
12217         return TEST_SUCCESS;
12218 }
12219
12220 static void
12221 generate_gmac_large_plaintext(uint8_t *data)
12222 {
12223         uint16_t i;
12224
12225         for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32)
12226                 memcpy(&data[i], &data[0], 32);
12227 }
12228
12229 static int
12230 create_gmac_operation(enum rte_crypto_auth_operation op,
12231                 const struct gmac_test_data *tdata)
12232 {
12233         struct crypto_testsuite_params *ts_params = &testsuite_params;
12234         struct crypto_unittest_params *ut_params = &unittest_params;
12235         struct rte_crypto_sym_op *sym_op;
12236
12237         uint32_t plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
12238
12239         /* Generate Crypto op data structure */
12240         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12241                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12242         TEST_ASSERT_NOT_NULL(ut_params->op,
12243                         "Failed to allocate symmetric crypto operation struct");
12244
12245         sym_op = ut_params->op->sym;
12246
12247         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
12248                         ut_params->ibuf, tdata->gmac_tag.len);
12249         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
12250                         "no room to append digest");
12251
12252         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
12253                         ut_params->ibuf, plaintext_pad_len);
12254
12255         if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
12256                 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
12257                                 tdata->gmac_tag.len);
12258                 debug_hexdump(stdout, "digest:",
12259                                 sym_op->auth.digest.data,
12260                                 tdata->gmac_tag.len);
12261         }
12262
12263         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
12264                         uint8_t *, IV_OFFSET);
12265
12266         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
12267
12268         debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
12269
12270         sym_op->cipher.data.length = 0;
12271         sym_op->cipher.data.offset = 0;
12272
12273         sym_op->auth.data.offset = 0;
12274         sym_op->auth.data.length = tdata->plaintext.len;
12275
12276         return 0;
12277 }
12278
12279 static int
12280 create_gmac_operation_sgl(enum rte_crypto_auth_operation op,
12281                 const struct gmac_test_data *tdata,
12282                 void *digest_mem, uint64_t digest_phys)
12283 {
12284         struct crypto_testsuite_params *ts_params = &testsuite_params;
12285         struct crypto_unittest_params *ut_params = &unittest_params;
12286         struct rte_crypto_sym_op *sym_op;
12287
12288         /* Generate Crypto op data structure */
12289         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12290                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12291         TEST_ASSERT_NOT_NULL(ut_params->op,
12292                         "Failed to allocate symmetric crypto operation struct");
12293
12294         sym_op = ut_params->op->sym;
12295
12296         sym_op->auth.digest.data = digest_mem;
12297         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
12298                         "no room to append digest");
12299
12300         sym_op->auth.digest.phys_addr = digest_phys;
12301
12302         if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
12303                 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
12304                                 tdata->gmac_tag.len);
12305                 debug_hexdump(stdout, "digest:",
12306                                 sym_op->auth.digest.data,
12307                                 tdata->gmac_tag.len);
12308         }
12309
12310         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
12311                         uint8_t *, IV_OFFSET);
12312
12313         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
12314
12315         debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
12316
12317         sym_op->cipher.data.length = 0;
12318         sym_op->cipher.data.offset = 0;
12319
12320         sym_op->auth.data.offset = 0;
12321         sym_op->auth.data.length = tdata->plaintext.len;
12322
12323         return 0;
12324 }
12325
12326 static int create_gmac_session(uint8_t dev_id,
12327                 const struct gmac_test_data *tdata,
12328                 enum rte_crypto_auth_operation auth_op)
12329 {
12330         uint8_t auth_key[tdata->key.len];
12331         int status;
12332
12333         struct crypto_testsuite_params *ts_params = &testsuite_params;
12334         struct crypto_unittest_params *ut_params = &unittest_params;
12335
12336         memcpy(auth_key, tdata->key.data, tdata->key.len);
12337
12338         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12339         ut_params->auth_xform.next = NULL;
12340
12341         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
12342         ut_params->auth_xform.auth.op = auth_op;
12343         ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
12344         ut_params->auth_xform.auth.key.length = tdata->key.len;
12345         ut_params->auth_xform.auth.key.data = auth_key;
12346         ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
12347         ut_params->auth_xform.auth.iv.length = tdata->iv.len;
12348
12349
12350         ut_params->sess = rte_cryptodev_sym_session_create(
12351                         ts_params->session_mpool);
12352         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12353
12354         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
12355                         &ut_params->auth_xform,
12356                         ts_params->session_priv_mpool);
12357
12358         return status;
12359 }
12360
12361 static int
12362 test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
12363 {
12364         struct crypto_testsuite_params *ts_params = &testsuite_params;
12365         struct crypto_unittest_params *ut_params = &unittest_params;
12366         struct rte_cryptodev_info dev_info;
12367
12368         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12369         uint64_t feat_flags = dev_info.feature_flags;
12370
12371         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12372                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12373                 printf("Device doesn't support RAW data-path APIs.\n");
12374                 return TEST_SKIPPED;
12375         }
12376
12377         int retval;
12378
12379         uint8_t *auth_tag, *plaintext;
12380         uint16_t plaintext_pad_len;
12381
12382         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
12383                               "No GMAC length in the source data");
12384
12385         /* Verify the capabilities */
12386         struct rte_cryptodev_sym_capability_idx cap_idx;
12387         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12388         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
12389         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12390                         &cap_idx) == NULL)
12391                 return TEST_SKIPPED;
12392
12393         retval = create_gmac_session(ts_params->valid_devs[0],
12394                         tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
12395
12396         if (retval == -ENOTSUP)
12397                 return TEST_SKIPPED;
12398         if (retval < 0)
12399                 return retval;
12400
12401         if (tdata->plaintext.len > MBUF_SIZE)
12402                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
12403         else
12404                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12405         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12406                         "Failed to allocate input buffer in mempool");
12407
12408         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12409                         rte_pktmbuf_tailroom(ut_params->ibuf));
12410
12411         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
12412         /*
12413          * Runtime generate the large plain text instead of use hard code
12414          * plain text vector. It is done to avoid create huge source file
12415          * with the test vector.
12416          */
12417         if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
12418                 generate_gmac_large_plaintext(tdata->plaintext.data);
12419
12420         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12421                                 plaintext_pad_len);
12422         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12423
12424         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
12425         debug_hexdump(stdout, "plaintext:", plaintext,
12426                         tdata->plaintext.len);
12427
12428         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
12429                         tdata);
12430
12431         if (retval < 0)
12432                 return retval;
12433
12434         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12435
12436         ut_params->op->sym->m_src = ut_params->ibuf;
12437
12438         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12439                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12440                         ut_params->op);
12441         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12442                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12443                                 ut_params->op, 0, 1, 0, 0);
12444         else
12445                 TEST_ASSERT_NOT_NULL(
12446                         process_crypto_request(ts_params->valid_devs[0],
12447                         ut_params->op), "failed to process sym crypto op");
12448
12449         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12450                         "crypto op processing failed");
12451
12452         if (ut_params->op->sym->m_dst) {
12453                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
12454                                 uint8_t *, plaintext_pad_len);
12455         } else {
12456                 auth_tag = plaintext + plaintext_pad_len;
12457         }
12458
12459         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
12460
12461         TEST_ASSERT_BUFFERS_ARE_EQUAL(
12462                         auth_tag,
12463                         tdata->gmac_tag.data,
12464                         tdata->gmac_tag.len,
12465                         "GMAC Generated auth tag not as expected");
12466
12467         return 0;
12468 }
12469
12470 static int
12471 test_AES_GMAC_authentication_test_case_1(void)
12472 {
12473         return test_AES_GMAC_authentication(&gmac_test_case_1);
12474 }
12475
12476 static int
12477 test_AES_GMAC_authentication_test_case_2(void)
12478 {
12479         return test_AES_GMAC_authentication(&gmac_test_case_2);
12480 }
12481
12482 static int
12483 test_AES_GMAC_authentication_test_case_3(void)
12484 {
12485         return test_AES_GMAC_authentication(&gmac_test_case_3);
12486 }
12487
12488 static int
12489 test_AES_GMAC_authentication_test_case_4(void)
12490 {
12491         return test_AES_GMAC_authentication(&gmac_test_case_4);
12492 }
12493
12494 static int
12495 test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
12496 {
12497         struct crypto_testsuite_params *ts_params = &testsuite_params;
12498         struct crypto_unittest_params *ut_params = &unittest_params;
12499         int retval;
12500         uint32_t plaintext_pad_len;
12501         uint8_t *plaintext;
12502         struct rte_cryptodev_info dev_info;
12503
12504         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12505         uint64_t feat_flags = dev_info.feature_flags;
12506
12507         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12508                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12509                 printf("Device doesn't support RAW data-path APIs.\n");
12510                 return TEST_SKIPPED;
12511         }
12512
12513         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
12514                               "No GMAC length in the source data");
12515
12516         /* Verify the capabilities */
12517         struct rte_cryptodev_sym_capability_idx cap_idx;
12518         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12519         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
12520         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12521                         &cap_idx) == NULL)
12522                 return TEST_SKIPPED;
12523
12524         retval = create_gmac_session(ts_params->valid_devs[0],
12525                         tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
12526
12527         if (retval == -ENOTSUP)
12528                 return TEST_SKIPPED;
12529         if (retval < 0)
12530                 return retval;
12531
12532         if (tdata->plaintext.len > MBUF_SIZE)
12533                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
12534         else
12535                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12536         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12537                         "Failed to allocate input buffer in mempool");
12538
12539         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12540                         rte_pktmbuf_tailroom(ut_params->ibuf));
12541
12542         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
12543
12544         /*
12545          * Runtime generate the large plain text instead of use hard code
12546          * plain text vector. It is done to avoid create huge source file
12547          * with the test vector.
12548          */
12549         if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
12550                 generate_gmac_large_plaintext(tdata->plaintext.data);
12551
12552         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12553                                 plaintext_pad_len);
12554         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12555
12556         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
12557         debug_hexdump(stdout, "plaintext:", plaintext,
12558                         tdata->plaintext.len);
12559
12560         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
12561                         tdata);
12562
12563         if (retval < 0)
12564                 return retval;
12565
12566         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12567
12568         ut_params->op->sym->m_src = ut_params->ibuf;
12569
12570         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12571                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12572                         ut_params->op);
12573         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12574                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12575                                 ut_params->op, 0, 1, 0, 0);
12576         else
12577                 TEST_ASSERT_NOT_NULL(
12578                         process_crypto_request(ts_params->valid_devs[0],
12579                         ut_params->op), "failed to process sym crypto op");
12580
12581         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12582                         "crypto op processing failed");
12583
12584         return 0;
12585
12586 }
12587
12588 static int
12589 test_AES_GMAC_authentication_verify_test_case_1(void)
12590 {
12591         return test_AES_GMAC_authentication_verify(&gmac_test_case_1);
12592 }
12593
12594 static int
12595 test_AES_GMAC_authentication_verify_test_case_2(void)
12596 {
12597         return test_AES_GMAC_authentication_verify(&gmac_test_case_2);
12598 }
12599
12600 static int
12601 test_AES_GMAC_authentication_verify_test_case_3(void)
12602 {
12603         return test_AES_GMAC_authentication_verify(&gmac_test_case_3);
12604 }
12605
12606 static int
12607 test_AES_GMAC_authentication_verify_test_case_4(void)
12608 {
12609         return test_AES_GMAC_authentication_verify(&gmac_test_case_4);
12610 }
12611
12612 static int
12613 test_AES_GMAC_authentication_SGL(const struct gmac_test_data *tdata,
12614                                 uint32_t fragsz)
12615 {
12616         struct crypto_testsuite_params *ts_params = &testsuite_params;
12617         struct crypto_unittest_params *ut_params = &unittest_params;
12618         struct rte_cryptodev_info dev_info;
12619         uint64_t feature_flags;
12620         unsigned int trn_data = 0;
12621         void *digest_mem = NULL;
12622         uint32_t segs = 1;
12623         unsigned int to_trn = 0;
12624         struct rte_mbuf *buf = NULL;
12625         uint8_t *auth_tag, *plaintext;
12626         int retval;
12627
12628         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
12629                               "No GMAC length in the source data");
12630
12631         /* Verify the capabilities */
12632         struct rte_cryptodev_sym_capability_idx cap_idx;
12633         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12634         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
12635         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12636                         &cap_idx) == NULL)
12637                 return TEST_SKIPPED;
12638
12639         /* Check for any input SGL support */
12640         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12641         feature_flags = dev_info.feature_flags;
12642
12643         if ((!(feature_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) ||
12644                         (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT)) ||
12645                         (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)))
12646                 return TEST_SKIPPED;
12647
12648         if (fragsz > tdata->plaintext.len)
12649                 fragsz = tdata->plaintext.len;
12650
12651         uint16_t plaintext_len = fragsz;
12652
12653         retval = create_gmac_session(ts_params->valid_devs[0],
12654                         tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
12655
12656         if (retval == -ENOTSUP)
12657                 return TEST_SKIPPED;
12658         if (retval < 0)
12659                 return retval;
12660
12661         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12662         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12663                         "Failed to allocate input buffer in mempool");
12664
12665         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12666                         rte_pktmbuf_tailroom(ut_params->ibuf));
12667
12668         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12669                                 plaintext_len);
12670         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12671
12672         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
12673
12674         trn_data += plaintext_len;
12675
12676         buf = ut_params->ibuf;
12677
12678         /*
12679          * Loop until no more fragments
12680          */
12681
12682         while (trn_data < tdata->plaintext.len) {
12683                 ++segs;
12684                 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
12685                                 (tdata->plaintext.len - trn_data) : fragsz;
12686
12687                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12688                 buf = buf->next;
12689
12690                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
12691                                 rte_pktmbuf_tailroom(buf));
12692
12693                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
12694                                 to_trn);
12695
12696                 memcpy(plaintext, tdata->plaintext.data + trn_data,
12697                                 to_trn);
12698                 trn_data += to_trn;
12699                 if (trn_data  == tdata->plaintext.len)
12700                         digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
12701                                         tdata->gmac_tag.len);
12702         }
12703         ut_params->ibuf->nb_segs = segs;
12704
12705         /*
12706          * Place digest at the end of the last buffer
12707          */
12708         uint64_t digest_phys = rte_pktmbuf_iova(buf) + to_trn;
12709
12710         if (!digest_mem) {
12711                 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12712                                 + tdata->gmac_tag.len);
12713                 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
12714                                 tdata->plaintext.len);
12715         }
12716
12717         retval = create_gmac_operation_sgl(RTE_CRYPTO_AUTH_OP_GENERATE,
12718                         tdata, digest_mem, digest_phys);
12719
12720         if (retval < 0)
12721                 return retval;
12722
12723         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12724
12725         ut_params->op->sym->m_src = ut_params->ibuf;
12726
12727         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12728                 return TEST_SKIPPED;
12729
12730         TEST_ASSERT_NOT_NULL(
12731                 process_crypto_request(ts_params->valid_devs[0],
12732                 ut_params->op), "failed to process sym crypto op");
12733
12734         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12735                         "crypto op processing failed");
12736
12737         auth_tag = digest_mem;
12738         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
12739         TEST_ASSERT_BUFFERS_ARE_EQUAL(
12740                         auth_tag,
12741                         tdata->gmac_tag.data,
12742                         tdata->gmac_tag.len,
12743                         "GMAC Generated auth tag not as expected");
12744
12745         return 0;
12746 }
12747
12748 /* Segment size not multiple of block size (16B) */
12749 static int
12750 test_AES_GMAC_authentication_SGL_40B(void)
12751 {
12752         return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 40);
12753 }
12754
12755 static int
12756 test_AES_GMAC_authentication_SGL_80B(void)
12757 {
12758         return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 80);
12759 }
12760
12761 static int
12762 test_AES_GMAC_authentication_SGL_2048B(void)
12763 {
12764         return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2048);
12765 }
12766
12767 /* Segment size not multiple of block size (16B) */
12768 static int
12769 test_AES_GMAC_authentication_SGL_2047B(void)
12770 {
12771         return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2047);
12772 }
12773
12774 struct test_crypto_vector {
12775         enum rte_crypto_cipher_algorithm crypto_algo;
12776         unsigned int cipher_offset;
12777         unsigned int cipher_len;
12778
12779         struct {
12780                 uint8_t data[64];
12781                 unsigned int len;
12782         } cipher_key;
12783
12784         struct {
12785                 uint8_t data[64];
12786                 unsigned int len;
12787         } iv;
12788
12789         struct {
12790                 const uint8_t *data;
12791                 unsigned int len;
12792         } plaintext;
12793
12794         struct {
12795                 const uint8_t *data;
12796                 unsigned int len;
12797         } ciphertext;
12798
12799         enum rte_crypto_auth_algorithm auth_algo;
12800         unsigned int auth_offset;
12801
12802         struct {
12803                 uint8_t data[128];
12804                 unsigned int len;
12805         } auth_key;
12806
12807         struct {
12808                 const uint8_t *data;
12809                 unsigned int len;
12810         } aad;
12811
12812         struct {
12813                 uint8_t data[128];
12814                 unsigned int len;
12815         } digest;
12816 };
12817
12818 static const struct test_crypto_vector
12819 hmac_sha1_test_crypto_vector = {
12820         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
12821         .plaintext = {
12822                 .data = plaintext_hash,
12823                 .len = 512
12824         },
12825         .auth_key = {
12826                 .data = {
12827                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
12828                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
12829                         0xDE, 0xF4, 0xDE, 0xAD
12830                 },
12831                 .len = 20
12832         },
12833         .digest = {
12834                 .data = {
12835                         0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
12836                         0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
12837                         0x3F, 0x91, 0x64, 0x59
12838                 },
12839                 .len = 20
12840         }
12841 };
12842
12843 static const struct test_crypto_vector
12844 aes128_gmac_test_vector = {
12845         .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
12846         .plaintext = {
12847                 .data = plaintext_hash,
12848                 .len = 512
12849         },
12850         .iv = {
12851                 .data = {
12852                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
12853                         0x08, 0x09, 0x0A, 0x0B
12854                 },
12855                 .len = 12
12856         },
12857         .auth_key = {
12858                 .data = {
12859                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
12860                         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
12861                 },
12862                 .len = 16
12863         },
12864         .digest = {
12865                 .data = {
12866                         0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56,
12867                         0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A
12868                 },
12869                 .len = 16
12870         }
12871 };
12872
12873 static const struct test_crypto_vector
12874 aes128cbc_hmac_sha1_test_vector = {
12875         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
12876         .cipher_offset = 0,
12877         .cipher_len = 512,
12878         .cipher_key = {
12879                 .data = {
12880                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
12881                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
12882                 },
12883                 .len = 16
12884         },
12885         .iv = {
12886                 .data = {
12887                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
12888                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
12889                 },
12890                 .len = 16
12891         },
12892         .plaintext = {
12893                 .data = plaintext_hash,
12894                 .len = 512
12895         },
12896         .ciphertext = {
12897                 .data = ciphertext512_aes128cbc,
12898                 .len = 512
12899         },
12900         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
12901         .auth_offset = 0,
12902         .auth_key = {
12903                 .data = {
12904                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
12905                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
12906                         0xDE, 0xF4, 0xDE, 0xAD
12907                 },
12908                 .len = 20
12909         },
12910         .digest = {
12911                 .data = {
12912                         0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
12913                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
12914                         0x18, 0x8C, 0x1D, 0x32
12915                 },
12916                 .len = 20
12917         }
12918 };
12919
12920 static const struct test_crypto_vector
12921 aes128cbc_hmac_sha1_aad_test_vector = {
12922         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
12923         .cipher_offset = 8,
12924         .cipher_len = 496,
12925         .cipher_key = {
12926                 .data = {
12927                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
12928                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
12929                 },
12930                 .len = 16
12931         },
12932         .iv = {
12933                 .data = {
12934                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
12935                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
12936                 },
12937                 .len = 16
12938         },
12939         .plaintext = {
12940                 .data = plaintext_hash,
12941                 .len = 512
12942         },
12943         .ciphertext = {
12944                 .data = ciphertext512_aes128cbc_aad,
12945                 .len = 512
12946         },
12947         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
12948         .auth_offset = 0,
12949         .auth_key = {
12950                 .data = {
12951                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
12952                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
12953                         0xDE, 0xF4, 0xDE, 0xAD
12954                 },
12955                 .len = 20
12956         },
12957         .digest = {
12958                 .data = {
12959                         0x6D, 0xF3, 0x50, 0x79, 0x7A, 0x2A, 0xAC, 0x7F,
12960                         0xA6, 0xF0, 0xC6, 0x38, 0x1F, 0xA4, 0xDD, 0x9B,
12961                         0x62, 0x0F, 0xFB, 0x10
12962                 },
12963                 .len = 20
12964         }
12965 };
12966
12967 static void
12968 data_corruption(uint8_t *data)
12969 {
12970         data[0] += 1;
12971 }
12972
12973 static void
12974 tag_corruption(uint8_t *data, unsigned int tag_offset)
12975 {
12976         data[tag_offset] += 1;
12977 }
12978
12979 static int
12980 create_auth_session(struct crypto_unittest_params *ut_params,
12981                 uint8_t dev_id,
12982                 const struct test_crypto_vector *reference,
12983                 enum rte_crypto_auth_operation auth_op)
12984 {
12985         struct crypto_testsuite_params *ts_params = &testsuite_params;
12986         uint8_t auth_key[reference->auth_key.len + 1];
12987         int status;
12988
12989         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
12990
12991         /* Setup Authentication Parameters */
12992         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12993         ut_params->auth_xform.auth.op = auth_op;
12994         ut_params->auth_xform.next = NULL;
12995         ut_params->auth_xform.auth.algo = reference->auth_algo;
12996         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
12997         ut_params->auth_xform.auth.key.data = auth_key;
12998         ut_params->auth_xform.auth.digest_length = reference->digest.len;
12999
13000         /* Create Crypto session*/
13001         ut_params->sess = rte_cryptodev_sym_session_create(
13002                         ts_params->session_mpool);
13003         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
13004
13005         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
13006                                 &ut_params->auth_xform,
13007                                 ts_params->session_priv_mpool);
13008
13009         return status;
13010 }
13011
13012 static int
13013 create_auth_cipher_session(struct crypto_unittest_params *ut_params,
13014                 uint8_t dev_id,
13015                 const struct test_crypto_vector *reference,
13016                 enum rte_crypto_auth_operation auth_op,
13017                 enum rte_crypto_cipher_operation cipher_op)
13018 {
13019         struct crypto_testsuite_params *ts_params = &testsuite_params;
13020         uint8_t cipher_key[reference->cipher_key.len + 1];
13021         uint8_t auth_key[reference->auth_key.len + 1];
13022         int status;
13023
13024         memcpy(cipher_key, reference->cipher_key.data,
13025                         reference->cipher_key.len);
13026         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
13027
13028         /* Setup Authentication Parameters */
13029         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13030         ut_params->auth_xform.auth.op = auth_op;
13031         ut_params->auth_xform.auth.algo = reference->auth_algo;
13032         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
13033         ut_params->auth_xform.auth.key.data = auth_key;
13034         ut_params->auth_xform.auth.digest_length = reference->digest.len;
13035
13036         if (reference->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) {
13037                 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
13038                 ut_params->auth_xform.auth.iv.length = reference->iv.len;
13039         } else {
13040                 ut_params->auth_xform.next = &ut_params->cipher_xform;
13041
13042                 /* Setup Cipher Parameters */
13043                 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13044                 ut_params->cipher_xform.next = NULL;
13045                 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
13046                 ut_params->cipher_xform.cipher.op = cipher_op;
13047                 ut_params->cipher_xform.cipher.key.data = cipher_key;
13048                 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
13049                 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
13050                 ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
13051         }
13052
13053         /* Create Crypto session*/
13054         ut_params->sess = rte_cryptodev_sym_session_create(
13055                         ts_params->session_mpool);
13056         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
13057
13058         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
13059                                 &ut_params->auth_xform,
13060                                 ts_params->session_priv_mpool);
13061
13062         return status;
13063 }
13064
13065 static int
13066 create_auth_operation(struct crypto_testsuite_params *ts_params,
13067                 struct crypto_unittest_params *ut_params,
13068                 const struct test_crypto_vector *reference,
13069                 unsigned int auth_generate)
13070 {
13071         /* Generate Crypto op data structure */
13072         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
13073                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
13074         TEST_ASSERT_NOT_NULL(ut_params->op,
13075                         "Failed to allocate pktmbuf offload");
13076
13077         /* Set crypto operation data parameters */
13078         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
13079
13080         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
13081
13082         /* set crypto operation source mbuf */
13083         sym_op->m_src = ut_params->ibuf;
13084
13085         /* digest */
13086         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
13087                         ut_params->ibuf, reference->digest.len);
13088
13089         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
13090                         "no room to append auth tag");
13091
13092         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
13093                         ut_params->ibuf, reference->plaintext.len);
13094
13095         if (auth_generate)
13096                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
13097         else
13098                 memcpy(sym_op->auth.digest.data,
13099                                 reference->digest.data,
13100                                 reference->digest.len);
13101
13102         debug_hexdump(stdout, "digest:",
13103                         sym_op->auth.digest.data,
13104                         reference->digest.len);
13105
13106         sym_op->auth.data.length = reference->plaintext.len;
13107         sym_op->auth.data.offset = 0;
13108
13109         return 0;
13110 }
13111
13112 static int
13113 create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
13114                 struct crypto_unittest_params *ut_params,
13115                 const struct test_crypto_vector *reference,
13116                 unsigned int auth_generate)
13117 {
13118         /* Generate Crypto op data structure */
13119         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
13120                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
13121         TEST_ASSERT_NOT_NULL(ut_params->op,
13122                         "Failed to allocate pktmbuf offload");
13123
13124         /* Set crypto operation data parameters */
13125         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
13126
13127         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
13128
13129         /* set crypto operation source mbuf */
13130         sym_op->m_src = ut_params->ibuf;
13131
13132         /* digest */
13133         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
13134                         ut_params->ibuf, reference->digest.len);
13135
13136         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
13137                         "no room to append auth tag");
13138
13139         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
13140                         ut_params->ibuf, reference->ciphertext.len);
13141
13142         if (auth_generate)
13143                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
13144         else
13145                 memcpy(sym_op->auth.digest.data,
13146                                 reference->digest.data,
13147                                 reference->digest.len);
13148
13149         debug_hexdump(stdout, "digest:",
13150                         sym_op->auth.digest.data,
13151                         reference->digest.len);
13152
13153         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
13154                         reference->iv.data, reference->iv.len);
13155
13156         sym_op->cipher.data.length = 0;
13157         sym_op->cipher.data.offset = 0;
13158
13159         sym_op->auth.data.length = reference->plaintext.len;
13160         sym_op->auth.data.offset = 0;
13161
13162         return 0;
13163 }
13164
13165 static int
13166 create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
13167                 struct crypto_unittest_params *ut_params,
13168                 const struct test_crypto_vector *reference,
13169                 unsigned int auth_generate)
13170 {
13171         /* Generate Crypto op data structure */
13172         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
13173                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
13174         TEST_ASSERT_NOT_NULL(ut_params->op,
13175                         "Failed to allocate pktmbuf offload");
13176
13177         /* Set crypto operation data parameters */
13178         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
13179
13180         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
13181
13182         /* set crypto operation source mbuf */
13183         sym_op->m_src = ut_params->ibuf;
13184
13185         /* digest */
13186         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
13187                         ut_params->ibuf, reference->digest.len);
13188
13189         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
13190                         "no room to append auth tag");
13191
13192         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
13193                         ut_params->ibuf, reference->ciphertext.len);
13194
13195         if (auth_generate)
13196                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
13197         else
13198                 memcpy(sym_op->auth.digest.data,
13199                                 reference->digest.data,
13200                                 reference->digest.len);
13201
13202         debug_hexdump(stdout, "digest:",
13203                         sym_op->auth.digest.data,
13204                         reference->digest.len);
13205
13206         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
13207                         reference->iv.data, reference->iv.len);
13208
13209         sym_op->cipher.data.length = reference->cipher_len;
13210         sym_op->cipher.data.offset = reference->cipher_offset;
13211
13212         sym_op->auth.data.length = reference->plaintext.len;
13213         sym_op->auth.data.offset = reference->auth_offset;
13214
13215         return 0;
13216 }
13217
13218 static int
13219 create_auth_verify_operation(struct crypto_testsuite_params *ts_params,
13220                 struct crypto_unittest_params *ut_params,
13221                 const struct test_crypto_vector *reference)
13222 {
13223         return create_auth_operation(ts_params, ut_params, reference, 0);
13224 }
13225
13226 static int
13227 create_auth_verify_GMAC_operation(
13228                 struct crypto_testsuite_params *ts_params,
13229                 struct crypto_unittest_params *ut_params,
13230                 const struct test_crypto_vector *reference)
13231 {
13232         return create_auth_GMAC_operation(ts_params, ut_params, reference, 0);
13233 }
13234
13235 static int
13236 create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params,
13237                 struct crypto_unittest_params *ut_params,
13238                 const struct test_crypto_vector *reference)
13239 {
13240         return create_cipher_auth_operation(ts_params, ut_params, reference, 0);
13241 }
13242
13243 static int
13244 test_authentication_verify_fail_when_data_corruption(
13245                 struct crypto_testsuite_params *ts_params,
13246                 struct crypto_unittest_params *ut_params,
13247                 const struct test_crypto_vector *reference,
13248                 unsigned int data_corrupted)
13249 {
13250         int retval;
13251
13252         uint8_t *plaintext;
13253         struct rte_cryptodev_info dev_info;
13254
13255         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13256         uint64_t feat_flags = dev_info.feature_flags;
13257
13258         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13259                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13260                 printf("Device doesn't support RAW data-path APIs.\n");
13261                 return TEST_SKIPPED;
13262         }
13263
13264         /* Verify the capabilities */
13265         struct rte_cryptodev_sym_capability_idx cap_idx;
13266         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13267         cap_idx.algo.auth = reference->auth_algo;
13268         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13269                         &cap_idx) == NULL)
13270                 return TEST_SKIPPED;
13271
13272
13273         /* Create session */
13274         retval = create_auth_session(ut_params,
13275                         ts_params->valid_devs[0],
13276                         reference,
13277                         RTE_CRYPTO_AUTH_OP_VERIFY);
13278
13279         if (retval == -ENOTSUP)
13280                 return TEST_SKIPPED;
13281         if (retval < 0)
13282                 return retval;
13283
13284         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13285         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13286                         "Failed to allocate input buffer in mempool");
13287
13288         /* clear mbuf payload */
13289         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13290                         rte_pktmbuf_tailroom(ut_params->ibuf));
13291
13292         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13293                         reference->plaintext.len);
13294         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
13295         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
13296
13297         debug_hexdump(stdout, "plaintext:", plaintext,
13298                 reference->plaintext.len);
13299
13300         /* Create operation */
13301         retval = create_auth_verify_operation(ts_params, ut_params, reference);
13302
13303         if (retval < 0)
13304                 return retval;
13305
13306         if (data_corrupted)
13307                 data_corruption(plaintext);
13308         else
13309                 tag_corruption(plaintext, reference->plaintext.len);
13310
13311         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
13312                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13313                         ut_params->op);
13314                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
13315                         RTE_CRYPTO_OP_STATUS_SUCCESS,
13316                         "authentication not failed");
13317         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13318                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13319                                 ut_params->op, 0, 1, 0, 0);
13320         else {
13321                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13322                         ut_params->op);
13323         }
13324         if (ut_params->op == NULL)
13325                 return 0;
13326         else if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS)
13327                 return 0;
13328
13329         return -1;
13330 }
13331
13332 static int
13333 test_authentication_verify_GMAC_fail_when_corruption(
13334                 struct crypto_testsuite_params *ts_params,
13335                 struct crypto_unittest_params *ut_params,
13336                 const struct test_crypto_vector *reference,
13337                 unsigned int data_corrupted)
13338 {
13339         int retval;
13340         uint8_t *plaintext;
13341         struct rte_cryptodev_info dev_info;
13342
13343         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13344         uint64_t feat_flags = dev_info.feature_flags;
13345
13346         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13347                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13348                 printf("Device doesn't support RAW data-path APIs.\n");
13349                 return TEST_SKIPPED;
13350         }
13351
13352         /* Verify the capabilities */
13353         struct rte_cryptodev_sym_capability_idx cap_idx;
13354         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13355         cap_idx.algo.auth = reference->auth_algo;
13356         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13357                         &cap_idx) == NULL)
13358                 return TEST_SKIPPED;
13359
13360         /* Create session */
13361         retval = create_auth_cipher_session(ut_params,
13362                         ts_params->valid_devs[0],
13363                         reference,
13364                         RTE_CRYPTO_AUTH_OP_VERIFY,
13365                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
13366         if (retval < 0)
13367                 return retval;
13368
13369         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13370         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13371                         "Failed to allocate input buffer in mempool");
13372
13373         /* clear mbuf payload */
13374         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13375                         rte_pktmbuf_tailroom(ut_params->ibuf));
13376
13377         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13378                         reference->plaintext.len);
13379         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
13380         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
13381
13382         debug_hexdump(stdout, "plaintext:", plaintext,
13383                 reference->plaintext.len);
13384
13385         /* Create operation */
13386         retval = create_auth_verify_GMAC_operation(ts_params,
13387                         ut_params,
13388                         reference);
13389
13390         if (retval < 0)
13391                 return retval;
13392
13393         if (data_corrupted)
13394                 data_corruption(plaintext);
13395         else
13396                 tag_corruption(plaintext, reference->aad.len);
13397
13398         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
13399                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13400                         ut_params->op);
13401                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
13402                         RTE_CRYPTO_OP_STATUS_SUCCESS,
13403                         "authentication not failed");
13404         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13405                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13406                                 ut_params->op, 0, 1, 0, 0);
13407         else {
13408                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13409                         ut_params->op);
13410                 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
13411         }
13412
13413         return 0;
13414 }
13415
13416 static int
13417 test_authenticated_decryption_fail_when_corruption(
13418                 struct crypto_testsuite_params *ts_params,
13419                 struct crypto_unittest_params *ut_params,
13420                 const struct test_crypto_vector *reference,
13421                 unsigned int data_corrupted)
13422 {
13423         int retval;
13424
13425         uint8_t *ciphertext;
13426         struct rte_cryptodev_info dev_info;
13427
13428         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13429         uint64_t feat_flags = dev_info.feature_flags;
13430
13431         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13432                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13433                 printf("Device doesn't support RAW data-path APIs.\n");
13434                 return TEST_SKIPPED;
13435         }
13436
13437         /* Verify the capabilities */
13438         struct rte_cryptodev_sym_capability_idx cap_idx;
13439         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13440         cap_idx.algo.auth = reference->auth_algo;
13441         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13442                         &cap_idx) == NULL)
13443                 return TEST_SKIPPED;
13444         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13445         cap_idx.algo.cipher = reference->crypto_algo;
13446         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13447                         &cap_idx) == NULL)
13448                 return TEST_SKIPPED;
13449
13450         /* Create session */
13451         retval = create_auth_cipher_session(ut_params,
13452                         ts_params->valid_devs[0],
13453                         reference,
13454                         RTE_CRYPTO_AUTH_OP_VERIFY,
13455                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
13456
13457         if (retval == -ENOTSUP)
13458                 return TEST_SKIPPED;
13459         if (retval < 0)
13460                 return retval;
13461
13462         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13463         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13464                         "Failed to allocate input buffer in mempool");
13465
13466         /* clear mbuf payload */
13467         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13468                         rte_pktmbuf_tailroom(ut_params->ibuf));
13469
13470         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13471                         reference->ciphertext.len);
13472         TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
13473         memcpy(ciphertext, reference->ciphertext.data,
13474                         reference->ciphertext.len);
13475
13476         /* Create operation */
13477         retval = create_cipher_auth_verify_operation(ts_params,
13478                         ut_params,
13479                         reference);
13480
13481         if (retval < 0)
13482                 return retval;
13483
13484         if (data_corrupted)
13485                 data_corruption(ciphertext);
13486         else
13487                 tag_corruption(ciphertext, reference->ciphertext.len);
13488
13489         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
13490                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13491                         ut_params->op);
13492                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
13493                         RTE_CRYPTO_OP_STATUS_SUCCESS,
13494                         "authentication not failed");
13495         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13496                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13497                                 ut_params->op, 1, 1, 0, 0);
13498         else {
13499                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13500                         ut_params->op);
13501                 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
13502         }
13503
13504         return 0;
13505 }
13506
13507 static int
13508 test_authenticated_encrypt_with_esn(
13509                 struct crypto_testsuite_params *ts_params,
13510                 struct crypto_unittest_params *ut_params,
13511                 const struct test_crypto_vector *reference)
13512 {
13513         int retval;
13514
13515         uint8_t *authciphertext, *plaintext, *auth_tag;
13516         uint16_t plaintext_pad_len;
13517         uint8_t cipher_key[reference->cipher_key.len + 1];
13518         uint8_t auth_key[reference->auth_key.len + 1];
13519         struct rte_cryptodev_info dev_info;
13520         int status;
13521
13522         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13523         uint64_t feat_flags = dev_info.feature_flags;
13524
13525         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13526                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13527                 printf("Device doesn't support RAW data-path APIs.\n");
13528                 return TEST_SKIPPED;
13529         }
13530
13531         /* Verify the capabilities */
13532         struct rte_cryptodev_sym_capability_idx cap_idx;
13533         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13534         cap_idx.algo.auth = reference->auth_algo;
13535         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13536                         &cap_idx) == NULL)
13537                 return TEST_SKIPPED;
13538         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13539         cap_idx.algo.cipher = reference->crypto_algo;
13540         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13541                         &cap_idx) == NULL)
13542                 return TEST_SKIPPED;
13543
13544         /* Create session */
13545         memcpy(cipher_key, reference->cipher_key.data,
13546                         reference->cipher_key.len);
13547         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
13548
13549         /* Setup Cipher Parameters */
13550         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13551         ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
13552         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
13553         ut_params->cipher_xform.cipher.key.data = cipher_key;
13554         ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
13555         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
13556         ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
13557
13558         ut_params->cipher_xform.next = &ut_params->auth_xform;
13559
13560         /* Setup Authentication Parameters */
13561         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13562         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
13563         ut_params->auth_xform.auth.algo = reference->auth_algo;
13564         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
13565         ut_params->auth_xform.auth.key.data = auth_key;
13566         ut_params->auth_xform.auth.digest_length = reference->digest.len;
13567         ut_params->auth_xform.next = NULL;
13568
13569         /* Create Crypto session*/
13570         ut_params->sess = rte_cryptodev_sym_session_create(
13571                         ts_params->session_mpool);
13572         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
13573
13574         status = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
13575                                 ut_params->sess,
13576                                 &ut_params->cipher_xform,
13577                                 ts_params->session_priv_mpool);
13578
13579         if (status == -ENOTSUP)
13580                 return TEST_SKIPPED;
13581
13582         TEST_ASSERT_EQUAL(status, 0, "Session init failed");
13583
13584         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13585         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13586                         "Failed to allocate input buffer in mempool");
13587
13588         /* clear mbuf payload */
13589         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13590                         rte_pktmbuf_tailroom(ut_params->ibuf));
13591
13592         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13593                         reference->plaintext.len);
13594         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
13595         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
13596
13597         /* Create operation */
13598         retval = create_cipher_auth_operation(ts_params,
13599                         ut_params,
13600                         reference, 0);
13601
13602         if (retval < 0)
13603                 return retval;
13604
13605         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13606                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13607                         ut_params->op);
13608         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13609                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13610                                 ut_params->op, 1, 1, 0, 0);
13611         else
13612                 ut_params->op = process_crypto_request(
13613                         ts_params->valid_devs[0], ut_params->op);
13614
13615         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
13616
13617         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
13618                         "crypto op processing failed");
13619
13620         plaintext_pad_len = RTE_ALIGN_CEIL(reference->plaintext.len, 16);
13621
13622         authciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
13623                         ut_params->op->sym->auth.data.offset);
13624         auth_tag = authciphertext + plaintext_pad_len;
13625         debug_hexdump(stdout, "ciphertext:", authciphertext,
13626                         reference->ciphertext.len);
13627         debug_hexdump(stdout, "auth tag:", auth_tag, reference->digest.len);
13628
13629         /* Validate obuf */
13630         TEST_ASSERT_BUFFERS_ARE_EQUAL(
13631                         authciphertext,
13632                         reference->ciphertext.data,
13633                         reference->ciphertext.len,
13634                         "Ciphertext data not as expected");
13635
13636         TEST_ASSERT_BUFFERS_ARE_EQUAL(
13637                         auth_tag,
13638                         reference->digest.data,
13639                         reference->digest.len,
13640                         "Generated digest not as expected");
13641
13642         return TEST_SUCCESS;
13643
13644 }
13645
13646 static int
13647 test_authenticated_decrypt_with_esn(
13648                 struct crypto_testsuite_params *ts_params,
13649                 struct crypto_unittest_params *ut_params,
13650                 const struct test_crypto_vector *reference)
13651 {
13652         int retval;
13653
13654         uint8_t *ciphertext;
13655         uint8_t cipher_key[reference->cipher_key.len + 1];
13656         uint8_t auth_key[reference->auth_key.len + 1];
13657         struct rte_cryptodev_info dev_info;
13658
13659         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13660         uint64_t feat_flags = dev_info.feature_flags;
13661
13662         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13663                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13664                 printf("Device doesn't support RAW data-path APIs.\n");
13665                 return TEST_SKIPPED;
13666         }
13667
13668         /* Verify the capabilities */
13669         struct rte_cryptodev_sym_capability_idx cap_idx;
13670         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13671         cap_idx.algo.auth = reference->auth_algo;
13672         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13673                         &cap_idx) == NULL)
13674                 return TEST_SKIPPED;
13675         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13676         cap_idx.algo.cipher = reference->crypto_algo;
13677         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13678                         &cap_idx) == NULL)
13679                 return TEST_SKIPPED;
13680
13681         /* Create session */
13682         memcpy(cipher_key, reference->cipher_key.data,
13683                         reference->cipher_key.len);
13684         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
13685
13686         /* Setup Authentication Parameters */
13687         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13688         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
13689         ut_params->auth_xform.auth.algo = reference->auth_algo;
13690         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
13691         ut_params->auth_xform.auth.key.data = auth_key;
13692         ut_params->auth_xform.auth.digest_length = reference->digest.len;
13693         ut_params->auth_xform.next = &ut_params->cipher_xform;
13694
13695         /* Setup Cipher Parameters */
13696         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13697         ut_params->cipher_xform.next = NULL;
13698         ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
13699         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
13700         ut_params->cipher_xform.cipher.key.data = cipher_key;
13701         ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
13702         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
13703         ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
13704
13705         /* Create Crypto session*/
13706         ut_params->sess = rte_cryptodev_sym_session_create(
13707                         ts_params->session_mpool);
13708         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
13709
13710         retval = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
13711                                 ut_params->sess,
13712                                 &ut_params->auth_xform,
13713                                 ts_params->session_priv_mpool);
13714
13715         if (retval == -ENOTSUP)
13716                 return TEST_SKIPPED;
13717
13718         TEST_ASSERT_EQUAL(retval, 0, "Session init failed");
13719
13720         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13721         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13722                         "Failed to allocate input buffer in mempool");
13723
13724         /* clear mbuf payload */
13725         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13726                         rte_pktmbuf_tailroom(ut_params->ibuf));
13727
13728         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13729                         reference->ciphertext.len);
13730         TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
13731         memcpy(ciphertext, reference->ciphertext.data,
13732                         reference->ciphertext.len);
13733
13734         /* Create operation */
13735         retval = create_cipher_auth_verify_operation(ts_params,
13736                         ut_params,
13737                         reference);
13738
13739         if (retval < 0)
13740                 return retval;
13741
13742         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13743                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13744                         ut_params->op);
13745         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13746                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13747                                 ut_params->op, 1, 1, 0, 0);
13748         else
13749                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13750                         ut_params->op);
13751
13752         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
13753         TEST_ASSERT_EQUAL(ut_params->op->status,
13754                         RTE_CRYPTO_OP_STATUS_SUCCESS,
13755                         "crypto op processing passed");
13756
13757         ut_params->obuf = ut_params->op->sym->m_src;
13758         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
13759
13760         return 0;
13761 }
13762
13763 static int
13764 create_aead_operation_SGL(enum rte_crypto_aead_operation op,
13765                 const struct aead_test_data *tdata,
13766                 void *digest_mem, uint64_t digest_phys)
13767 {
13768         struct crypto_testsuite_params *ts_params = &testsuite_params;
13769         struct crypto_unittest_params *ut_params = &unittest_params;
13770
13771         const unsigned int auth_tag_len = tdata->auth_tag.len;
13772         const unsigned int iv_len = tdata->iv.len;
13773         unsigned int aad_len = tdata->aad.len;
13774         unsigned int aad_len_pad = 0;
13775
13776         /* Generate Crypto op data structure */
13777         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
13778                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
13779         TEST_ASSERT_NOT_NULL(ut_params->op,
13780                 "Failed to allocate symmetric crypto operation struct");
13781
13782         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
13783
13784         sym_op->aead.digest.data = digest_mem;
13785
13786         TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
13787                         "no room to append digest");
13788
13789         sym_op->aead.digest.phys_addr = digest_phys;
13790
13791         if (op == RTE_CRYPTO_AEAD_OP_DECRYPT) {
13792                 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
13793                                 auth_tag_len);
13794                 debug_hexdump(stdout, "digest:",
13795                                 sym_op->aead.digest.data,
13796                                 auth_tag_len);
13797         }
13798
13799         /* Append aad data */
13800         if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
13801                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
13802                                 uint8_t *, IV_OFFSET);
13803
13804                 /* Copy IV 1 byte after the IV pointer, according to the API */
13805                 rte_memcpy(iv_ptr + 1, tdata->iv.data, iv_len);
13806
13807                 aad_len = RTE_ALIGN_CEIL(aad_len + 18, 16);
13808
13809                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
13810                                 ut_params->ibuf, aad_len);
13811                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
13812                                 "no room to prepend aad");
13813                 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
13814                                 ut_params->ibuf);
13815
13816                 memset(sym_op->aead.aad.data, 0, aad_len);
13817                 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
13818                 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
13819
13820                 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
13821                 debug_hexdump(stdout, "aad:",
13822                                 sym_op->aead.aad.data, aad_len);
13823         } else {
13824                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
13825                                 uint8_t *, IV_OFFSET);
13826
13827                 rte_memcpy(iv_ptr, tdata->iv.data, iv_len);
13828
13829                 aad_len_pad = RTE_ALIGN_CEIL(aad_len, 16);
13830
13831                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
13832                                 ut_params->ibuf, aad_len_pad);
13833                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
13834                                 "no room to prepend aad");
13835                 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
13836                                 ut_params->ibuf);
13837
13838                 memset(sym_op->aead.aad.data, 0, aad_len);
13839                 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
13840
13841                 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
13842                 debug_hexdump(stdout, "aad:",
13843                                 sym_op->aead.aad.data, aad_len);
13844         }
13845
13846         sym_op->aead.data.length = tdata->plaintext.len;
13847         sym_op->aead.data.offset = aad_len_pad;
13848
13849         return 0;
13850 }
13851
13852 #define SGL_MAX_NO      16
13853
13854 static int
13855 test_authenticated_encryption_SGL(const struct aead_test_data *tdata,
13856                 const int oop, uint32_t fragsz, uint32_t fragsz_oop)
13857 {
13858         struct crypto_testsuite_params *ts_params = &testsuite_params;
13859         struct crypto_unittest_params *ut_params = &unittest_params;
13860         struct rte_mbuf *buf, *buf_oop = NULL, *buf_last_oop = NULL;
13861         int retval;
13862         int to_trn = 0;
13863         int to_trn_tbl[SGL_MAX_NO];
13864         int segs = 1;
13865         unsigned int trn_data = 0;
13866         uint8_t *plaintext, *ciphertext, *auth_tag;
13867         struct rte_cryptodev_info dev_info;
13868
13869         /* Verify the capabilities */
13870         struct rte_cryptodev_sym_capability_idx cap_idx;
13871         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
13872         cap_idx.algo.aead = tdata->algo;
13873         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13874                         &cap_idx) == NULL)
13875                 return TEST_SKIPPED;
13876
13877         /* OOP not supported with CPU crypto */
13878         if (oop && gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13879                 return TEST_SKIPPED;
13880
13881         /* Detailed check for the particular SGL support flag */
13882         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13883         if (!oop) {
13884                 unsigned int sgl_in = fragsz < tdata->plaintext.len;
13885                 if (sgl_in && (!(dev_info.feature_flags &
13886                                 RTE_CRYPTODEV_FF_IN_PLACE_SGL)))
13887                         return TEST_SKIPPED;
13888
13889                 uint64_t feat_flags = dev_info.feature_flags;
13890
13891                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13892                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13893                         printf("Device doesn't support RAW data-path APIs.\n");
13894                         return TEST_SKIPPED;
13895                 }
13896         } else {
13897                 unsigned int sgl_in = fragsz < tdata->plaintext.len;
13898                 unsigned int sgl_out = (fragsz_oop ? fragsz_oop : fragsz) <
13899                                 tdata->plaintext.len;
13900                 /* Raw data path API does not support OOP */
13901                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13902                         return TEST_SKIPPED;
13903                 if (sgl_in && !sgl_out) {
13904                         if (!(dev_info.feature_flags &
13905                                         RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT))
13906                                 return TEST_SKIPPED;
13907                 } else if (!sgl_in && sgl_out) {
13908                         if (!(dev_info.feature_flags &
13909                                         RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT))
13910                                 return TEST_SKIPPED;
13911                 } else if (sgl_in && sgl_out) {
13912                         if (!(dev_info.feature_flags &
13913                                         RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT))
13914                                 return TEST_SKIPPED;
13915                 }
13916         }
13917
13918         if (fragsz > tdata->plaintext.len)
13919                 fragsz = tdata->plaintext.len;
13920
13921         uint16_t plaintext_len = fragsz;
13922         uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
13923
13924         if (fragsz_oop > tdata->plaintext.len)
13925                 frag_size_oop = tdata->plaintext.len;
13926
13927         int ecx = 0;
13928         void *digest_mem = NULL;
13929
13930         uint32_t prepend_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
13931
13932         if (tdata->plaintext.len % fragsz != 0) {
13933                 if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO)
13934                         return 1;
13935         }       else {
13936                 if (tdata->plaintext.len / fragsz > SGL_MAX_NO)
13937                         return 1;
13938         }
13939
13940         /*
13941          * For out-op-place we need to alloc another mbuf
13942          */
13943         if (oop) {
13944                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13945                 rte_pktmbuf_append(ut_params->obuf,
13946                                 frag_size_oop + prepend_len);
13947                 buf_oop = ut_params->obuf;
13948         }
13949
13950         /* Create AEAD session */
13951         retval = create_aead_session(ts_params->valid_devs[0],
13952                         tdata->algo,
13953                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
13954                         tdata->key.data, tdata->key.len,
13955                         tdata->aad.len, tdata->auth_tag.len,
13956                         tdata->iv.len);
13957         if (retval < 0)
13958                 return retval;
13959
13960         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13961
13962         /* clear mbuf payload */
13963         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13964                         rte_pktmbuf_tailroom(ut_params->ibuf));
13965
13966         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13967                         plaintext_len);
13968
13969         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
13970
13971         trn_data += plaintext_len;
13972
13973         buf = ut_params->ibuf;
13974
13975         /*
13976          * Loop until no more fragments
13977          */
13978
13979         while (trn_data < tdata->plaintext.len) {
13980                 ++segs;
13981                 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
13982                                 (tdata->plaintext.len - trn_data) : fragsz;
13983
13984                 to_trn_tbl[ecx++] = to_trn;
13985
13986                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13987                 buf = buf->next;
13988
13989                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
13990                                 rte_pktmbuf_tailroom(buf));
13991
13992                 /* OOP */
13993                 if (oop && !fragsz_oop) {
13994                         buf_last_oop = buf_oop->next =
13995                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
13996                         buf_oop = buf_oop->next;
13997                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
13998                                         0, rte_pktmbuf_tailroom(buf_oop));
13999                         rte_pktmbuf_append(buf_oop, to_trn);
14000                 }
14001
14002                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
14003                                 to_trn);
14004
14005                 memcpy(plaintext, tdata->plaintext.data + trn_data,
14006                                 to_trn);
14007                 trn_data += to_trn;
14008                 if (trn_data  == tdata->plaintext.len) {
14009                         if (oop) {
14010                                 if (!fragsz_oop)
14011                                         digest_mem = rte_pktmbuf_append(buf_oop,
14012                                                 tdata->auth_tag.len);
14013                         } else
14014                                 digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
14015                                         tdata->auth_tag.len);
14016                 }
14017         }
14018
14019         uint64_t digest_phys = 0;
14020
14021         ut_params->ibuf->nb_segs = segs;
14022
14023         segs = 1;
14024         if (fragsz_oop && oop) {
14025                 to_trn = 0;
14026                 ecx = 0;
14027
14028                 if (frag_size_oop == tdata->plaintext.len) {
14029                         digest_mem = rte_pktmbuf_append(ut_params->obuf,
14030                                 tdata->auth_tag.len);
14031
14032                         digest_phys = rte_pktmbuf_iova_offset(
14033                                         ut_params->obuf,
14034                                         tdata->plaintext.len + prepend_len);
14035                 }
14036
14037                 trn_data = frag_size_oop;
14038                 while (trn_data < tdata->plaintext.len) {
14039                         ++segs;
14040                         to_trn =
14041                                 (tdata->plaintext.len - trn_data <
14042                                                 frag_size_oop) ?
14043                                 (tdata->plaintext.len - trn_data) :
14044                                                 frag_size_oop;
14045
14046                         to_trn_tbl[ecx++] = to_trn;
14047
14048                         buf_last_oop = buf_oop->next =
14049                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
14050                         buf_oop = buf_oop->next;
14051                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
14052                                         0, rte_pktmbuf_tailroom(buf_oop));
14053                         rte_pktmbuf_append(buf_oop, to_trn);
14054
14055                         trn_data += to_trn;
14056
14057                         if (trn_data  == tdata->plaintext.len) {
14058                                 digest_mem = rte_pktmbuf_append(buf_oop,
14059                                         tdata->auth_tag.len);
14060                         }
14061                 }
14062
14063                 ut_params->obuf->nb_segs = segs;
14064         }
14065
14066         /*
14067          * Place digest at the end of the last buffer
14068          */
14069         if (!digest_phys)
14070                 digest_phys = rte_pktmbuf_iova(buf) + to_trn;
14071         if (oop && buf_last_oop)
14072                 digest_phys = rte_pktmbuf_iova(buf_last_oop) + to_trn;
14073
14074         if (!digest_mem && !oop) {
14075                 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
14076                                 + tdata->auth_tag.len);
14077                 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
14078                                 tdata->plaintext.len);
14079         }
14080
14081         /* Create AEAD operation */
14082         retval = create_aead_operation_SGL(RTE_CRYPTO_AEAD_OP_ENCRYPT,
14083                         tdata, digest_mem, digest_phys);
14084
14085         if (retval < 0)
14086                 return retval;
14087
14088         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
14089
14090         ut_params->op->sym->m_src = ut_params->ibuf;
14091         if (oop)
14092                 ut_params->op->sym->m_dst = ut_params->obuf;
14093
14094         /* Process crypto operation */
14095         if (oop == IN_PLACE &&
14096                         gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
14097                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
14098         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
14099                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
14100                                 ut_params->op, 0, 0, 0, 0);
14101         else
14102                 TEST_ASSERT_NOT_NULL(
14103                         process_crypto_request(ts_params->valid_devs[0],
14104                         ut_params->op), "failed to process sym crypto op");
14105
14106         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
14107                         "crypto op processing failed");
14108
14109
14110         ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
14111                         uint8_t *, prepend_len);
14112         if (oop) {
14113                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
14114                                 uint8_t *, prepend_len);
14115         }
14116
14117         if (fragsz_oop)
14118                 fragsz = fragsz_oop;
14119
14120         TEST_ASSERT_BUFFERS_ARE_EQUAL(
14121                         ciphertext,
14122                         tdata->ciphertext.data,
14123                         fragsz,
14124                         "Ciphertext data not as expected");
14125
14126         buf = ut_params->op->sym->m_src->next;
14127         if (oop)
14128                 buf = ut_params->op->sym->m_dst->next;
14129
14130         unsigned int off = fragsz;
14131
14132         ecx = 0;
14133         while (buf) {
14134                 ciphertext = rte_pktmbuf_mtod(buf,
14135                                 uint8_t *);
14136
14137                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
14138                                 ciphertext,
14139                                 tdata->ciphertext.data + off,
14140                                 to_trn_tbl[ecx],
14141                                 "Ciphertext data not as expected");
14142
14143                 off += to_trn_tbl[ecx++];
14144                 buf = buf->next;
14145         }
14146
14147         auth_tag = digest_mem;
14148         TEST_ASSERT_BUFFERS_ARE_EQUAL(
14149                         auth_tag,
14150                         tdata->auth_tag.data,
14151                         tdata->auth_tag.len,
14152                         "Generated auth tag not as expected");
14153
14154         return 0;
14155 }
14156
14157 static int
14158 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void)
14159 {
14160         return test_authenticated_encryption_SGL(
14161                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 400, 400);
14162 }
14163
14164 static int
14165 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B(void)
14166 {
14167         return test_authenticated_encryption_SGL(
14168                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 1500, 2000);
14169 }
14170
14171 static int
14172 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void)
14173 {
14174         return test_authenticated_encryption_SGL(
14175                         &gcm_test_case_8, OUT_OF_PLACE, 400,
14176                         gcm_test_case_8.plaintext.len);
14177 }
14178
14179 static int
14180 test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void)
14181 {
14182         /* This test is not for OPENSSL PMD */
14183         if (gbl_driver_id == rte_cryptodev_driver_id_get(
14184                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)))
14185                 return TEST_SKIPPED;
14186
14187         return test_authenticated_encryption_SGL(
14188                         &gcm_test_case_SGL_1, IN_PLACE, 1500, 0);
14189 }
14190
14191 static int
14192 test_authentication_verify_fail_when_data_corrupted(
14193                 struct crypto_testsuite_params *ts_params,
14194                 struct crypto_unittest_params *ut_params,
14195                 const struct test_crypto_vector *reference)
14196 {
14197         return test_authentication_verify_fail_when_data_corruption(
14198                         ts_params, ut_params, reference, 1);
14199 }
14200
14201 static int
14202 test_authentication_verify_fail_when_tag_corrupted(
14203                 struct crypto_testsuite_params *ts_params,
14204                 struct crypto_unittest_params *ut_params,
14205                 const struct test_crypto_vector *reference)
14206 {
14207         return test_authentication_verify_fail_when_data_corruption(
14208                         ts_params, ut_params, reference, 0);
14209 }
14210
14211 static int
14212 test_authentication_verify_GMAC_fail_when_data_corrupted(
14213                 struct crypto_testsuite_params *ts_params,
14214                 struct crypto_unittest_params *ut_params,
14215                 const struct test_crypto_vector *reference)
14216 {
14217         return test_authentication_verify_GMAC_fail_when_corruption(
14218                         ts_params, ut_params, reference, 1);
14219 }
14220
14221 static int
14222 test_authentication_verify_GMAC_fail_when_tag_corrupted(
14223                 struct crypto_testsuite_params *ts_params,
14224                 struct crypto_unittest_params *ut_params,
14225                 const struct test_crypto_vector *reference)
14226 {
14227         return test_authentication_verify_GMAC_fail_when_corruption(
14228                         ts_params, ut_params, reference, 0);
14229 }
14230
14231 static int
14232 test_authenticated_decryption_fail_when_data_corrupted(
14233                 struct crypto_testsuite_params *ts_params,
14234                 struct crypto_unittest_params *ut_params,
14235                 const struct test_crypto_vector *reference)
14236 {
14237         return test_authenticated_decryption_fail_when_corruption(
14238                         ts_params, ut_params, reference, 1);
14239 }
14240
14241 static int
14242 test_authenticated_decryption_fail_when_tag_corrupted(
14243                 struct crypto_testsuite_params *ts_params,
14244                 struct crypto_unittest_params *ut_params,
14245                 const struct test_crypto_vector *reference)
14246 {
14247         return test_authenticated_decryption_fail_when_corruption(
14248                         ts_params, ut_params, reference, 0);
14249 }
14250
14251 static int
14252 authentication_verify_HMAC_SHA1_fail_data_corrupt(void)
14253 {
14254         return test_authentication_verify_fail_when_data_corrupted(
14255                         &testsuite_params, &unittest_params,
14256                         &hmac_sha1_test_crypto_vector);
14257 }
14258
14259 static int
14260 authentication_verify_HMAC_SHA1_fail_tag_corrupt(void)
14261 {
14262         return test_authentication_verify_fail_when_tag_corrupted(
14263                         &testsuite_params, &unittest_params,
14264                         &hmac_sha1_test_crypto_vector);
14265 }
14266
14267 static int
14268 authentication_verify_AES128_GMAC_fail_data_corrupt(void)
14269 {
14270         return test_authentication_verify_GMAC_fail_when_data_corrupted(
14271                         &testsuite_params, &unittest_params,
14272                         &aes128_gmac_test_vector);
14273 }
14274
14275 static int
14276 authentication_verify_AES128_GMAC_fail_tag_corrupt(void)
14277 {
14278         return test_authentication_verify_GMAC_fail_when_tag_corrupted(
14279                         &testsuite_params, &unittest_params,
14280                         &aes128_gmac_test_vector);
14281 }
14282
14283 static int
14284 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void)
14285 {
14286         return test_authenticated_decryption_fail_when_data_corrupted(
14287                         &testsuite_params,
14288                         &unittest_params,
14289                         &aes128cbc_hmac_sha1_test_vector);
14290 }
14291
14292 static int
14293 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void)
14294 {
14295         return test_authenticated_decryption_fail_when_tag_corrupted(
14296                         &testsuite_params,
14297                         &unittest_params,
14298                         &aes128cbc_hmac_sha1_test_vector);
14299 }
14300
14301 static int
14302 auth_encrypt_AES128CBC_HMAC_SHA1_esn_check(void)
14303 {
14304         return test_authenticated_encrypt_with_esn(
14305                         &testsuite_params,
14306                         &unittest_params,
14307                         &aes128cbc_hmac_sha1_aad_test_vector);
14308 }
14309
14310 static int
14311 auth_decrypt_AES128CBC_HMAC_SHA1_esn_check(void)
14312 {
14313         return test_authenticated_decrypt_with_esn(
14314                         &testsuite_params,
14315                         &unittest_params,
14316                         &aes128cbc_hmac_sha1_aad_test_vector);
14317 }
14318
14319 static int
14320 test_chacha20_poly1305_encrypt_test_case_rfc8439(void)
14321 {
14322         return test_authenticated_encryption(&chacha20_poly1305_case_rfc8439);
14323 }
14324
14325 static int
14326 test_chacha20_poly1305_decrypt_test_case_rfc8439(void)
14327 {
14328         return test_authenticated_decryption(&chacha20_poly1305_case_rfc8439);
14329 }
14330
14331 static int
14332 test_chacha20_poly1305_encrypt_SGL_out_of_place(void)
14333 {
14334         return test_authenticated_encryption_SGL(
14335                 &chacha20_poly1305_case_2, OUT_OF_PLACE, 32,
14336                 chacha20_poly1305_case_2.plaintext.len);
14337 }
14338
14339 #ifdef RTE_CRYPTO_SCHEDULER
14340
14341 /* global AESNI worker IDs for the scheduler test */
14342 uint8_t aesni_ids[2];
14343
14344 static int
14345 scheduler_testsuite_setup(void)
14346 {
14347         uint32_t i = 0;
14348         int32_t nb_devs, ret;
14349         char vdev_args[VDEV_ARGS_SIZE] = {""};
14350         char temp_str[VDEV_ARGS_SIZE] = {"mode=multi-core,"
14351                 "ordering=enable,name=cryptodev_test_scheduler,corelist="};
14352         uint16_t worker_core_count = 0;
14353         uint16_t socket_id = 0;
14354
14355         if (gbl_driver_id == rte_cryptodev_driver_id_get(
14356                         RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD))) {
14357
14358                 /* Identify the Worker Cores
14359                  * Use 2 worker cores for the device args
14360                  */
14361                 RTE_LCORE_FOREACH_WORKER(i) {
14362                         if (worker_core_count > 1)
14363                                 break;
14364                         snprintf(vdev_args, sizeof(vdev_args),
14365                                         "%s%d", temp_str, i);
14366                         strcpy(temp_str, vdev_args);
14367                         strlcat(temp_str, ";", sizeof(temp_str));
14368                         worker_core_count++;
14369                         socket_id = rte_lcore_to_socket_id(i);
14370                 }
14371                 if (worker_core_count != 2) {
14372                         RTE_LOG(ERR, USER1,
14373                                 "Cryptodev scheduler test require at least "
14374                                 "two worker cores to run. "
14375                                 "Please use the correct coremask.\n");
14376                         return TEST_FAILED;
14377                 }
14378                 strcpy(temp_str, vdev_args);
14379                 snprintf(vdev_args, sizeof(vdev_args), "%s,socket_id=%d",
14380                                 temp_str, socket_id);
14381                 RTE_LOG(DEBUG, USER1, "vdev_args: %s\n", vdev_args);
14382                 nb_devs = rte_cryptodev_device_count_by_driver(
14383                                 rte_cryptodev_driver_id_get(
14384                                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)));
14385                 if (nb_devs < 1) {
14386                         ret = rte_vdev_init(
14387                                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),
14388                                         vdev_args);
14389                         TEST_ASSERT(ret == 0,
14390                                 "Failed to create instance %u of pmd : %s",
14391                                 i, RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
14392                 }
14393         }
14394         return testsuite_setup();
14395 }
14396
14397 static int
14398 test_scheduler_attach_worker_op(void)
14399 {
14400         struct crypto_testsuite_params *ts_params = &testsuite_params;
14401         uint8_t sched_id = ts_params->valid_devs[0];
14402         uint32_t i, nb_devs_attached = 0;
14403         int ret;
14404         char vdev_name[32];
14405         unsigned int count = rte_cryptodev_count();
14406
14407         /* create 2 AESNI_MB vdevs on top of existing devices */
14408         for (i = count; i < count + 2; i++) {
14409                 snprintf(vdev_name, sizeof(vdev_name), "%s_%u",
14410                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD),
14411                                 i);
14412                 ret = rte_vdev_init(vdev_name, NULL);
14413
14414                 TEST_ASSERT(ret == 0,
14415                         "Failed to create instance %u of"
14416                         " pmd : %s",
14417                         i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
14418
14419                 if (ret < 0) {
14420                         RTE_LOG(ERR, USER1,
14421                                 "Failed to create 2 AESNI MB PMDs.\n");
14422                         return TEST_SKIPPED;
14423                 }
14424         }
14425
14426         /* attach 2 AESNI_MB cdevs */
14427         for (i = count; i < count + 2; i++) {
14428                 struct rte_cryptodev_info info;
14429                 unsigned int session_size;
14430
14431                 rte_cryptodev_info_get(i, &info);
14432                 if (info.driver_id != rte_cryptodev_driver_id_get(
14433                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)))
14434                         continue;
14435
14436                 session_size = rte_cryptodev_sym_get_private_session_size(i);
14437                 /*
14438                  * Create the session mempool again, since now there are new devices
14439                  * to use the mempool.
14440                  */
14441                 if (ts_params->session_mpool) {
14442                         rte_mempool_free(ts_params->session_mpool);
14443                         ts_params->session_mpool = NULL;
14444                 }
14445                 if (ts_params->session_priv_mpool) {
14446                         rte_mempool_free(ts_params->session_priv_mpool);
14447                         ts_params->session_priv_mpool = NULL;
14448                 }
14449
14450                 if (info.sym.max_nb_sessions != 0 &&
14451                                 info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
14452                         RTE_LOG(ERR, USER1,
14453                                         "Device does not support "
14454                                         "at least %u sessions\n",
14455                                         MAX_NB_SESSIONS);
14456                         return TEST_FAILED;
14457                 }
14458                 /*
14459                  * Create mempool with maximum number of sessions,
14460                  * to include the session headers
14461                  */
14462                 if (ts_params->session_mpool == NULL) {
14463                         ts_params->session_mpool =
14464                                 rte_cryptodev_sym_session_pool_create(
14465                                                 "test_sess_mp",
14466                                                 MAX_NB_SESSIONS, 0, 0, 0,
14467                                                 SOCKET_ID_ANY);
14468                         TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
14469                                         "session mempool allocation failed");
14470                 }
14471
14472                 /*
14473                  * Create mempool with maximum number of sessions,
14474                  * to include device specific session private data
14475                  */
14476                 if (ts_params->session_priv_mpool == NULL) {
14477                         ts_params->session_priv_mpool = rte_mempool_create(
14478                                         "test_sess_mp_priv",
14479                                         MAX_NB_SESSIONS,
14480                                         session_size,
14481                                         0, 0, NULL, NULL, NULL,
14482                                         NULL, SOCKET_ID_ANY,
14483                                         0);
14484
14485                         TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
14486                                         "session mempool allocation failed");
14487                 }
14488
14489                 ts_params->qp_conf.mp_session = ts_params->session_mpool;
14490                 ts_params->qp_conf.mp_session_private =
14491                                 ts_params->session_priv_mpool;
14492
14493                 ret = rte_cryptodev_scheduler_worker_attach(sched_id,
14494                                 (uint8_t)i);
14495
14496                 TEST_ASSERT(ret == 0,
14497                         "Failed to attach device %u of pmd : %s", i,
14498                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
14499
14500                 aesni_ids[nb_devs_attached] = (uint8_t)i;
14501
14502                 nb_devs_attached++;
14503         }
14504
14505         return 0;
14506 }
14507
14508 static int
14509 test_scheduler_detach_worker_op(void)
14510 {
14511         struct crypto_testsuite_params *ts_params = &testsuite_params;
14512         uint8_t sched_id = ts_params->valid_devs[0];
14513         uint32_t i;
14514         int ret;
14515
14516         for (i = 0; i < 2; i++) {
14517                 ret = rte_cryptodev_scheduler_worker_detach(sched_id,
14518                                 aesni_ids[i]);
14519                 TEST_ASSERT(ret == 0,
14520                         "Failed to detach device %u", aesni_ids[i]);
14521         }
14522
14523         return 0;
14524 }
14525
14526 static int
14527 test_scheduler_mode_op(enum rte_cryptodev_scheduler_mode scheduler_mode)
14528 {
14529         struct crypto_testsuite_params *ts_params = &testsuite_params;
14530         uint8_t sched_id = ts_params->valid_devs[0];
14531         /* set mode */
14532         return rte_cryptodev_scheduler_mode_set(sched_id,
14533                 scheduler_mode);
14534 }
14535
14536 static int
14537 test_scheduler_mode_roundrobin_op(void)
14538 {
14539         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) ==
14540                         0, "Failed to set roundrobin mode");
14541         return 0;
14542
14543 }
14544
14545 static int
14546 test_scheduler_mode_multicore_op(void)
14547 {
14548         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) ==
14549                         0, "Failed to set multicore mode");
14550
14551         return 0;
14552 }
14553
14554 static int
14555 test_scheduler_mode_failover_op(void)
14556 {
14557         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) ==
14558                         0, "Failed to set failover mode");
14559
14560         return 0;
14561 }
14562
14563 static int
14564 test_scheduler_mode_pkt_size_distr_op(void)
14565 {
14566         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) ==
14567                         0, "Failed to set pktsize mode");
14568
14569         return 0;
14570 }
14571
14572 static int
14573 scheduler_multicore_testsuite_setup(void)
14574 {
14575         if (test_scheduler_attach_worker_op() < 0)
14576                 return TEST_SKIPPED;
14577         if (test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) < 0)
14578                 return TEST_SKIPPED;
14579         return 0;
14580 }
14581
14582 static int
14583 scheduler_roundrobin_testsuite_setup(void)
14584 {
14585         if (test_scheduler_attach_worker_op() < 0)
14586                 return TEST_SKIPPED;
14587         if (test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) < 0)
14588                 return TEST_SKIPPED;
14589         return 0;
14590 }
14591
14592 static int
14593 scheduler_failover_testsuite_setup(void)
14594 {
14595         if (test_scheduler_attach_worker_op() < 0)
14596                 return TEST_SKIPPED;
14597         if (test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) < 0)
14598                 return TEST_SKIPPED;
14599         return 0;
14600 }
14601
14602 static int
14603 scheduler_pkt_size_distr_testsuite_setup(void)
14604 {
14605         if (test_scheduler_attach_worker_op() < 0)
14606                 return TEST_SKIPPED;
14607         if (test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) < 0)
14608                 return TEST_SKIPPED;
14609         return 0;
14610 }
14611
14612 static void
14613 scheduler_mode_testsuite_teardown(void)
14614 {
14615         test_scheduler_detach_worker_op();
14616 }
14617
14618 #endif /* RTE_CRYPTO_SCHEDULER */
14619
14620 static struct unit_test_suite end_testsuite = {
14621         .suite_name = NULL,
14622         .setup = NULL,
14623         .teardown = NULL,
14624         .unit_test_suites = NULL
14625 };
14626
14627 #ifdef RTE_LIB_SECURITY
14628 static struct unit_test_suite ipsec_proto_testsuite  = {
14629         .suite_name = "IPsec Proto Unit Test Suite",
14630         .setup = ipsec_proto_testsuite_setup,
14631         .unit_test_cases = {
14632                 TEST_CASE_NAMED_WITH_DATA(
14633                         "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 128)",
14634                         ut_setup_security, ut_teardown,
14635                         test_ipsec_proto_known_vec, &pkt_aes_128_gcm),
14636                 TEST_CASE_NAMED_WITH_DATA(
14637                         "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 192)",
14638                         ut_setup_security, ut_teardown,
14639                         test_ipsec_proto_known_vec, &pkt_aes_192_gcm),
14640                 TEST_CASE_NAMED_WITH_DATA(
14641                         "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 256)",
14642                         ut_setup_security, ut_teardown,
14643                         test_ipsec_proto_known_vec, &pkt_aes_256_gcm),
14644                 TEST_CASE_NAMED_WITH_DATA(
14645                         "Outbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA256 [16B ICV])",
14646                         ut_setup_security, ut_teardown,
14647                         test_ipsec_proto_known_vec,
14648                         &pkt_aes_128_cbc_hmac_sha256),
14649                 TEST_CASE_NAMED_WITH_DATA(
14650                         "Outbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA384 [24B ICV])",
14651                         ut_setup_security, ut_teardown,
14652                         test_ipsec_proto_known_vec,
14653                         &pkt_aes_128_cbc_hmac_sha384),
14654                 TEST_CASE_NAMED_WITH_DATA(
14655                         "Outbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA512 [32B ICV])",
14656                         ut_setup_security, ut_teardown,
14657                         test_ipsec_proto_known_vec,
14658                         &pkt_aes_128_cbc_hmac_sha512),
14659                 TEST_CASE_NAMED_WITH_DATA(
14660                         "Outbound known vector (ESP tunnel mode IPv6 AES-GCM 128)",
14661                         ut_setup_security, ut_teardown,
14662                         test_ipsec_proto_known_vec, &pkt_aes_256_gcm_v6),
14663                 TEST_CASE_NAMED_WITH_DATA(
14664                         "Outbound known vector (ESP tunnel mode IPv6 AES-CBC 128 HMAC-SHA256 [16B ICV])",
14665                         ut_setup_security, ut_teardown,
14666                         test_ipsec_proto_known_vec,
14667                         &pkt_aes_128_cbc_hmac_sha256_v6),
14668                 TEST_CASE_NAMED_WITH_DATA(
14669                         "Outbound known vector (ESP tunnel mode IPv4 NULL AES-XCBC-MAC [12B ICV])",
14670                         ut_setup_security, ut_teardown,
14671                         test_ipsec_proto_known_vec,
14672                         &pkt_null_aes_xcbc),
14673                 TEST_CASE_NAMED_WITH_DATA(
14674                         "Outbound fragmented packet",
14675                         ut_setup_security, ut_teardown,
14676                         test_ipsec_proto_known_vec_fragmented,
14677                         &pkt_aes_128_gcm_frag),
14678                 TEST_CASE_NAMED_WITH_DATA(
14679                         "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 128)",
14680                         ut_setup_security, ut_teardown,
14681                         test_ipsec_proto_known_vec_inb, &pkt_aes_128_gcm),
14682                 TEST_CASE_NAMED_WITH_DATA(
14683                         "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 192)",
14684                         ut_setup_security, ut_teardown,
14685                         test_ipsec_proto_known_vec_inb, &pkt_aes_192_gcm),
14686                 TEST_CASE_NAMED_WITH_DATA(
14687                         "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 256)",
14688                         ut_setup_security, ut_teardown,
14689                         test_ipsec_proto_known_vec_inb, &pkt_aes_256_gcm),
14690                 TEST_CASE_NAMED_WITH_DATA(
14691                         "Inbound known vector (ESP tunnel mode IPv4 AES-CBC 128)",
14692                         ut_setup_security, ut_teardown,
14693                         test_ipsec_proto_known_vec_inb, &pkt_aes_128_cbc_null),
14694                 TEST_CASE_NAMED_WITH_DATA(
14695                         "Inbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA256 [16B ICV])",
14696                         ut_setup_security, ut_teardown,
14697                         test_ipsec_proto_known_vec_inb,
14698                         &pkt_aes_128_cbc_hmac_sha256),
14699                 TEST_CASE_NAMED_WITH_DATA(
14700                         "Inbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA384 [24B ICV])",
14701                         ut_setup_security, ut_teardown,
14702                         test_ipsec_proto_known_vec_inb,
14703                         &pkt_aes_128_cbc_hmac_sha384),
14704                 TEST_CASE_NAMED_WITH_DATA(
14705                         "Inbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA512 [32B ICV])",
14706                         ut_setup_security, ut_teardown,
14707                         test_ipsec_proto_known_vec_inb,
14708                         &pkt_aes_128_cbc_hmac_sha512),
14709                 TEST_CASE_NAMED_WITH_DATA(
14710                         "Inbound known vector (ESP tunnel mode IPv6 AES-GCM 128)",
14711                         ut_setup_security, ut_teardown,
14712                         test_ipsec_proto_known_vec_inb, &pkt_aes_256_gcm_v6),
14713                 TEST_CASE_NAMED_WITH_DATA(
14714                         "Inbound known vector (ESP tunnel mode IPv6 AES-CBC 128 HMAC-SHA256 [16B ICV])",
14715                         ut_setup_security, ut_teardown,
14716                         test_ipsec_proto_known_vec_inb,
14717                         &pkt_aes_128_cbc_hmac_sha256_v6),
14718                 TEST_CASE_NAMED_WITH_DATA(
14719                         "Inbound known vector (ESP tunnel mode IPv4 NULL AES-XCBC-MAC [12B ICV])",
14720                         ut_setup_security, ut_teardown,
14721                         test_ipsec_proto_known_vec_inb,
14722                         &pkt_null_aes_xcbc),
14723                 TEST_CASE_NAMED_ST(
14724                         "Combined test alg list",
14725                         ut_setup_security, ut_teardown,
14726                         test_ipsec_proto_display_list),
14727                 TEST_CASE_NAMED_ST(
14728                         "IV generation",
14729                         ut_setup_security, ut_teardown,
14730                         test_ipsec_proto_iv_gen),
14731                 TEST_CASE_NAMED_ST(
14732                         "UDP encapsulation",
14733                         ut_setup_security, ut_teardown,
14734                         test_ipsec_proto_udp_encap),
14735                 TEST_CASE_NAMED_ST(
14736                         "UDP encapsulation ports verification test",
14737                         ut_setup_security, ut_teardown,
14738                         test_ipsec_proto_udp_ports_verify),
14739                 TEST_CASE_NAMED_ST(
14740                         "SA expiry packets soft",
14741                         ut_setup_security, ut_teardown,
14742                         test_ipsec_proto_sa_exp_pkts_soft),
14743                 TEST_CASE_NAMED_ST(
14744                         "SA expiry packets hard",
14745                         ut_setup_security, ut_teardown,
14746                         test_ipsec_proto_sa_exp_pkts_hard),
14747                 TEST_CASE_NAMED_ST(
14748                         "Negative test: ICV corruption",
14749                         ut_setup_security, ut_teardown,
14750                         test_ipsec_proto_err_icv_corrupt),
14751                 TEST_CASE_NAMED_ST(
14752                         "Tunnel dst addr verification",
14753                         ut_setup_security, ut_teardown,
14754                         test_ipsec_proto_tunnel_dst_addr_verify),
14755                 TEST_CASE_NAMED_ST(
14756                         "Tunnel src and dst addr verification",
14757                         ut_setup_security, ut_teardown,
14758                         test_ipsec_proto_tunnel_src_dst_addr_verify),
14759                 TEST_CASE_NAMED_ST(
14760                         "Inner IP checksum",
14761                         ut_setup_security, ut_teardown,
14762                         test_ipsec_proto_inner_ip_csum),
14763                 TEST_CASE_NAMED_ST(
14764                         "Inner L4 checksum",
14765                         ut_setup_security, ut_teardown,
14766                         test_ipsec_proto_inner_l4_csum),
14767                 TEST_CASE_NAMED_ST(
14768                         "Tunnel IPv4 in IPv4",
14769                         ut_setup_security, ut_teardown,
14770                         test_ipsec_proto_tunnel_v4_in_v4),
14771                 TEST_CASE_NAMED_ST(
14772                         "Tunnel IPv6 in IPv6",
14773                         ut_setup_security, ut_teardown,
14774                         test_ipsec_proto_tunnel_v6_in_v6),
14775                 TEST_CASE_NAMED_ST(
14776                         "Tunnel IPv4 in IPv6",
14777                         ut_setup_security, ut_teardown,
14778                         test_ipsec_proto_tunnel_v4_in_v6),
14779                 TEST_CASE_NAMED_ST(
14780                         "Tunnel IPv6 in IPv4",
14781                         ut_setup_security, ut_teardown,
14782                         test_ipsec_proto_tunnel_v6_in_v4),
14783                 TEST_CASE_NAMED_ST(
14784                         "Transport IPv4",
14785                         ut_setup_security, ut_teardown,
14786                         test_ipsec_proto_transport_v4),
14787                 TEST_CASE_NAMED_ST(
14788                         "Statistics: success",
14789                         ut_setup_security, ut_teardown,
14790                         test_ipsec_proto_stats),
14791                 TEST_CASE_NAMED_ST(
14792                         "Fragmented packet",
14793                         ut_setup_security, ut_teardown,
14794                         test_ipsec_proto_pkt_fragment),
14795                 TEST_CASE_NAMED_ST(
14796                         "Tunnel header copy DF (inner 0)",
14797                         ut_setup_security, ut_teardown,
14798                         test_ipsec_proto_copy_df_inner_0),
14799                 TEST_CASE_NAMED_ST(
14800                         "Tunnel header copy DF (inner 1)",
14801                         ut_setup_security, ut_teardown,
14802                         test_ipsec_proto_copy_df_inner_1),
14803                 TEST_CASE_NAMED_ST(
14804                         "Tunnel header set DF 0 (inner 1)",
14805                         ut_setup_security, ut_teardown,
14806                         test_ipsec_proto_set_df_0_inner_1),
14807                 TEST_CASE_NAMED_ST(
14808                         "Tunnel header set DF 1 (inner 0)",
14809                         ut_setup_security, ut_teardown,
14810                         test_ipsec_proto_set_df_1_inner_0),
14811                 TEST_CASES_END() /**< NULL terminate unit test array */
14812         }
14813 };
14814
14815 static struct unit_test_suite pdcp_proto_testsuite  = {
14816         .suite_name = "PDCP Proto Unit Test Suite",
14817         .setup = pdcp_proto_testsuite_setup,
14818         .unit_test_cases = {
14819                 TEST_CASE_ST(ut_setup_security, ut_teardown,
14820                         test_PDCP_PROTO_all),
14821                 TEST_CASES_END() /**< NULL terminate unit test array */
14822         }
14823 };
14824
14825 #define ADD_UPLINK_TESTCASE(data)                                               \
14826         TEST_CASE_NAMED_WITH_DATA(data.test_descr_uplink, ut_setup_security,    \
14827         ut_teardown, test_docsis_proto_uplink, (const void *) &data),           \
14828
14829 #define ADD_DOWNLINK_TESTCASE(data)                                             \
14830         TEST_CASE_NAMED_WITH_DATA(data.test_descr_downlink, ut_setup_security,  \
14831         ut_teardown, test_docsis_proto_downlink, (const void *) &data),         \
14832
14833 static struct unit_test_suite docsis_proto_testsuite  = {
14834         .suite_name = "DOCSIS Proto Unit Test Suite",
14835         .setup = docsis_proto_testsuite_setup,
14836         .unit_test_cases = {
14837                 /* Uplink */
14838                 ADD_UPLINK_TESTCASE(docsis_test_case_1)
14839                 ADD_UPLINK_TESTCASE(docsis_test_case_2)
14840                 ADD_UPLINK_TESTCASE(docsis_test_case_3)
14841                 ADD_UPLINK_TESTCASE(docsis_test_case_4)
14842                 ADD_UPLINK_TESTCASE(docsis_test_case_5)
14843                 ADD_UPLINK_TESTCASE(docsis_test_case_6)
14844                 ADD_UPLINK_TESTCASE(docsis_test_case_7)
14845                 ADD_UPLINK_TESTCASE(docsis_test_case_8)
14846                 ADD_UPLINK_TESTCASE(docsis_test_case_9)
14847                 ADD_UPLINK_TESTCASE(docsis_test_case_10)
14848                 ADD_UPLINK_TESTCASE(docsis_test_case_11)
14849                 ADD_UPLINK_TESTCASE(docsis_test_case_12)
14850                 ADD_UPLINK_TESTCASE(docsis_test_case_13)
14851                 ADD_UPLINK_TESTCASE(docsis_test_case_14)
14852                 ADD_UPLINK_TESTCASE(docsis_test_case_15)
14853                 ADD_UPLINK_TESTCASE(docsis_test_case_16)
14854                 ADD_UPLINK_TESTCASE(docsis_test_case_17)
14855                 ADD_UPLINK_TESTCASE(docsis_test_case_18)
14856                 ADD_UPLINK_TESTCASE(docsis_test_case_19)
14857                 ADD_UPLINK_TESTCASE(docsis_test_case_20)
14858                 ADD_UPLINK_TESTCASE(docsis_test_case_21)
14859                 ADD_UPLINK_TESTCASE(docsis_test_case_22)
14860                 ADD_UPLINK_TESTCASE(docsis_test_case_23)
14861                 ADD_UPLINK_TESTCASE(docsis_test_case_24)
14862                 ADD_UPLINK_TESTCASE(docsis_test_case_25)
14863                 ADD_UPLINK_TESTCASE(docsis_test_case_26)
14864                 /* Downlink */
14865                 ADD_DOWNLINK_TESTCASE(docsis_test_case_1)
14866                 ADD_DOWNLINK_TESTCASE(docsis_test_case_2)
14867                 ADD_DOWNLINK_TESTCASE(docsis_test_case_3)
14868                 ADD_DOWNLINK_TESTCASE(docsis_test_case_4)
14869                 ADD_DOWNLINK_TESTCASE(docsis_test_case_5)
14870                 ADD_DOWNLINK_TESTCASE(docsis_test_case_6)
14871                 ADD_DOWNLINK_TESTCASE(docsis_test_case_7)
14872                 ADD_DOWNLINK_TESTCASE(docsis_test_case_8)
14873                 ADD_DOWNLINK_TESTCASE(docsis_test_case_9)
14874                 ADD_DOWNLINK_TESTCASE(docsis_test_case_10)
14875                 ADD_DOWNLINK_TESTCASE(docsis_test_case_11)
14876                 ADD_DOWNLINK_TESTCASE(docsis_test_case_12)
14877                 ADD_DOWNLINK_TESTCASE(docsis_test_case_13)
14878                 ADD_DOWNLINK_TESTCASE(docsis_test_case_14)
14879                 ADD_DOWNLINK_TESTCASE(docsis_test_case_15)
14880                 ADD_DOWNLINK_TESTCASE(docsis_test_case_16)
14881                 ADD_DOWNLINK_TESTCASE(docsis_test_case_17)
14882                 ADD_DOWNLINK_TESTCASE(docsis_test_case_18)
14883                 ADD_DOWNLINK_TESTCASE(docsis_test_case_19)
14884                 ADD_DOWNLINK_TESTCASE(docsis_test_case_20)
14885                 ADD_DOWNLINK_TESTCASE(docsis_test_case_21)
14886                 ADD_DOWNLINK_TESTCASE(docsis_test_case_22)
14887                 ADD_DOWNLINK_TESTCASE(docsis_test_case_23)
14888                 ADD_DOWNLINK_TESTCASE(docsis_test_case_24)
14889                 ADD_DOWNLINK_TESTCASE(docsis_test_case_25)
14890                 ADD_DOWNLINK_TESTCASE(docsis_test_case_26)
14891                 TEST_CASES_END() /**< NULL terminate unit test array */
14892         }
14893 };
14894 #endif
14895
14896 static struct unit_test_suite cryptodev_gen_testsuite  = {
14897         .suite_name = "Crypto General Unit Test Suite",
14898         .setup = crypto_gen_testsuite_setup,
14899         .unit_test_cases = {
14900                 TEST_CASE_ST(ut_setup, ut_teardown,
14901                                 test_device_configure_invalid_dev_id),
14902                 TEST_CASE_ST(ut_setup, ut_teardown,
14903                                 test_queue_pair_descriptor_setup),
14904                 TEST_CASE_ST(ut_setup, ut_teardown,
14905                                 test_device_configure_invalid_queue_pair_ids),
14906                 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
14907                 TEST_CASE_ST(ut_setup, ut_teardown, test_enq_callback_setup),
14908                 TEST_CASE_ST(ut_setup, ut_teardown, test_deq_callback_setup),
14909                 TEST_CASES_END() /**< NULL terminate unit test array */
14910         }
14911 };
14912
14913 static struct unit_test_suite cryptodev_negative_hmac_sha1_testsuite = {
14914         .suite_name = "Negative HMAC SHA1 Unit Test Suite",
14915         .setup = negative_hmac_sha1_testsuite_setup,
14916         .unit_test_cases = {
14917                 /** Negative tests */
14918                 TEST_CASE_ST(ut_setup, ut_teardown,
14919                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
14920                 TEST_CASE_ST(ut_setup, ut_teardown,
14921                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
14922                 TEST_CASE_ST(ut_setup, ut_teardown,
14923                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
14924                 TEST_CASE_ST(ut_setup, ut_teardown,
14925                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
14926
14927                 TEST_CASES_END() /**< NULL terminate unit test array */
14928         }
14929 };
14930
14931 static struct unit_test_suite cryptodev_multi_session_testsuite = {
14932         .suite_name = "Multi Session Unit Test Suite",
14933         .setup = multi_session_testsuite_setup,
14934         .unit_test_cases = {
14935                 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
14936                 TEST_CASE_ST(ut_setup, ut_teardown,
14937                                 test_multi_session_random_usage),
14938
14939                 TEST_CASES_END() /**< NULL terminate unit test array */
14940         }
14941 };
14942
14943 static struct unit_test_suite cryptodev_null_testsuite  = {
14944         .suite_name = "NULL Test Suite",
14945         .setup = null_testsuite_setup,
14946         .unit_test_cases = {
14947                 TEST_CASE_ST(ut_setup, ut_teardown,
14948                         test_null_invalid_operation),
14949                 TEST_CASE_ST(ut_setup, ut_teardown, test_null_burst_operation),
14950                 TEST_CASES_END()
14951         }
14952 };
14953
14954 static struct unit_test_suite cryptodev_aes_ccm_auth_testsuite  = {
14955         .suite_name = "AES CCM Authenticated Test Suite",
14956         .setup = aes_ccm_auth_testsuite_setup,
14957         .unit_test_cases = {
14958                 /** AES CCM Authenticated Encryption 128 bits key*/
14959                 TEST_CASE_ST(ut_setup, ut_teardown,
14960                         test_AES_CCM_authenticated_encryption_test_case_128_1),
14961                 TEST_CASE_ST(ut_setup, ut_teardown,
14962                         test_AES_CCM_authenticated_encryption_test_case_128_2),
14963                 TEST_CASE_ST(ut_setup, ut_teardown,
14964                         test_AES_CCM_authenticated_encryption_test_case_128_3),
14965
14966                 /** AES CCM Authenticated Decryption 128 bits key*/
14967                 TEST_CASE_ST(ut_setup, ut_teardown,
14968                         test_AES_CCM_authenticated_decryption_test_case_128_1),
14969                 TEST_CASE_ST(ut_setup, ut_teardown,
14970                         test_AES_CCM_authenticated_decryption_test_case_128_2),
14971                 TEST_CASE_ST(ut_setup, ut_teardown,
14972                         test_AES_CCM_authenticated_decryption_test_case_128_3),
14973
14974                 /** AES CCM Authenticated Encryption 192 bits key */
14975                 TEST_CASE_ST(ut_setup, ut_teardown,
14976                         test_AES_CCM_authenticated_encryption_test_case_192_1),
14977                 TEST_CASE_ST(ut_setup, ut_teardown,
14978                         test_AES_CCM_authenticated_encryption_test_case_192_2),
14979                 TEST_CASE_ST(ut_setup, ut_teardown,
14980                         test_AES_CCM_authenticated_encryption_test_case_192_3),
14981
14982                 /** AES CCM Authenticated Decryption 192 bits key*/
14983                 TEST_CASE_ST(ut_setup, ut_teardown,
14984                         test_AES_CCM_authenticated_decryption_test_case_192_1),
14985                 TEST_CASE_ST(ut_setup, ut_teardown,
14986                         test_AES_CCM_authenticated_decryption_test_case_192_2),
14987                 TEST_CASE_ST(ut_setup, ut_teardown,
14988                         test_AES_CCM_authenticated_decryption_test_case_192_3),
14989
14990                 /** AES CCM Authenticated Encryption 256 bits key */
14991                 TEST_CASE_ST(ut_setup, ut_teardown,
14992                         test_AES_CCM_authenticated_encryption_test_case_256_1),
14993                 TEST_CASE_ST(ut_setup, ut_teardown,
14994                         test_AES_CCM_authenticated_encryption_test_case_256_2),
14995                 TEST_CASE_ST(ut_setup, ut_teardown,
14996                         test_AES_CCM_authenticated_encryption_test_case_256_3),
14997
14998                 /** AES CCM Authenticated Decryption 256 bits key*/
14999                 TEST_CASE_ST(ut_setup, ut_teardown,
15000                         test_AES_CCM_authenticated_decryption_test_case_256_1),
15001                 TEST_CASE_ST(ut_setup, ut_teardown,
15002                         test_AES_CCM_authenticated_decryption_test_case_256_2),
15003                 TEST_CASE_ST(ut_setup, ut_teardown,
15004                         test_AES_CCM_authenticated_decryption_test_case_256_3),
15005                 TEST_CASES_END()
15006         }
15007 };
15008
15009 static struct unit_test_suite cryptodev_aes_gcm_auth_testsuite  = {
15010         .suite_name = "AES GCM Authenticated Test Suite",
15011         .setup = aes_gcm_auth_testsuite_setup,
15012         .unit_test_cases = {
15013                 /** AES GCM Authenticated Encryption */
15014                 TEST_CASE_ST(ut_setup, ut_teardown,
15015                         test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
15016                 TEST_CASE_ST(ut_setup, ut_teardown,
15017                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
15018                 TEST_CASE_ST(ut_setup, ut_teardown,
15019                         test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
15020                 TEST_CASE_ST(ut_setup, ut_teardown,
15021                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
15022                 TEST_CASE_ST(ut_setup, ut_teardown,
15023                         test_AES_GCM_authenticated_encryption_test_case_1),
15024                 TEST_CASE_ST(ut_setup, ut_teardown,
15025                         test_AES_GCM_authenticated_encryption_test_case_2),
15026                 TEST_CASE_ST(ut_setup, ut_teardown,
15027                         test_AES_GCM_authenticated_encryption_test_case_3),
15028                 TEST_CASE_ST(ut_setup, ut_teardown,
15029                         test_AES_GCM_authenticated_encryption_test_case_4),
15030                 TEST_CASE_ST(ut_setup, ut_teardown,
15031                         test_AES_GCM_authenticated_encryption_test_case_5),
15032                 TEST_CASE_ST(ut_setup, ut_teardown,
15033                         test_AES_GCM_authenticated_encryption_test_case_6),
15034                 TEST_CASE_ST(ut_setup, ut_teardown,
15035                         test_AES_GCM_authenticated_encryption_test_case_7),
15036                 TEST_CASE_ST(ut_setup, ut_teardown,
15037                         test_AES_GCM_authenticated_encryption_test_case_8),
15038                 TEST_CASE_ST(ut_setup, ut_teardown,
15039                         test_AES_GCM_J0_authenticated_encryption_test_case_1),
15040
15041                 /** AES GCM Authenticated Decryption */
15042                 TEST_CASE_ST(ut_setup, ut_teardown,
15043                         test_AES_GCM_authenticated_decryption_test_case_1),
15044                 TEST_CASE_ST(ut_setup, ut_teardown,
15045                         test_AES_GCM_authenticated_decryption_test_case_2),
15046                 TEST_CASE_ST(ut_setup, ut_teardown,
15047                         test_AES_GCM_authenticated_decryption_test_case_3),
15048                 TEST_CASE_ST(ut_setup, ut_teardown,
15049                         test_AES_GCM_authenticated_decryption_test_case_4),
15050                 TEST_CASE_ST(ut_setup, ut_teardown,
15051                         test_AES_GCM_authenticated_decryption_test_case_5),
15052                 TEST_CASE_ST(ut_setup, ut_teardown,
15053                         test_AES_GCM_authenticated_decryption_test_case_6),
15054                 TEST_CASE_ST(ut_setup, ut_teardown,
15055                         test_AES_GCM_authenticated_decryption_test_case_7),
15056                 TEST_CASE_ST(ut_setup, ut_teardown,
15057                         test_AES_GCM_authenticated_decryption_test_case_8),
15058                 TEST_CASE_ST(ut_setup, ut_teardown,
15059                         test_AES_GCM_J0_authenticated_decryption_test_case_1),
15060
15061                 /** AES GCM Authenticated Encryption 192 bits key */
15062                 TEST_CASE_ST(ut_setup, ut_teardown,
15063                         test_AES_GCM_auth_encryption_test_case_192_1),
15064                 TEST_CASE_ST(ut_setup, ut_teardown,
15065                         test_AES_GCM_auth_encryption_test_case_192_2),
15066                 TEST_CASE_ST(ut_setup, ut_teardown,
15067                         test_AES_GCM_auth_encryption_test_case_192_3),
15068                 TEST_CASE_ST(ut_setup, ut_teardown,
15069                         test_AES_GCM_auth_encryption_test_case_192_4),
15070                 TEST_CASE_ST(ut_setup, ut_teardown,
15071                         test_AES_GCM_auth_encryption_test_case_192_5),
15072                 TEST_CASE_ST(ut_setup, ut_teardown,
15073                         test_AES_GCM_auth_encryption_test_case_192_6),
15074                 TEST_CASE_ST(ut_setup, ut_teardown,
15075                         test_AES_GCM_auth_encryption_test_case_192_7),
15076
15077                 /** AES GCM Authenticated Decryption 192 bits key */
15078                 TEST_CASE_ST(ut_setup, ut_teardown,
15079                         test_AES_GCM_auth_decryption_test_case_192_1),
15080                 TEST_CASE_ST(ut_setup, ut_teardown,
15081                         test_AES_GCM_auth_decryption_test_case_192_2),
15082                 TEST_CASE_ST(ut_setup, ut_teardown,
15083                         test_AES_GCM_auth_decryption_test_case_192_3),
15084                 TEST_CASE_ST(ut_setup, ut_teardown,
15085                         test_AES_GCM_auth_decryption_test_case_192_4),
15086                 TEST_CASE_ST(ut_setup, ut_teardown,
15087                         test_AES_GCM_auth_decryption_test_case_192_5),
15088                 TEST_CASE_ST(ut_setup, ut_teardown,
15089                         test_AES_GCM_auth_decryption_test_case_192_6),
15090                 TEST_CASE_ST(ut_setup, ut_teardown,
15091                         test_AES_GCM_auth_decryption_test_case_192_7),
15092
15093                 /** AES GCM Authenticated Encryption 256 bits key */
15094                 TEST_CASE_ST(ut_setup, ut_teardown,
15095                         test_AES_GCM_auth_encryption_test_case_256_1),
15096                 TEST_CASE_ST(ut_setup, ut_teardown,
15097                         test_AES_GCM_auth_encryption_test_case_256_2),
15098                 TEST_CASE_ST(ut_setup, ut_teardown,
15099                         test_AES_GCM_auth_encryption_test_case_256_3),
15100                 TEST_CASE_ST(ut_setup, ut_teardown,
15101                         test_AES_GCM_auth_encryption_test_case_256_4),
15102                 TEST_CASE_ST(ut_setup, ut_teardown,
15103                         test_AES_GCM_auth_encryption_test_case_256_5),
15104                 TEST_CASE_ST(ut_setup, ut_teardown,
15105                         test_AES_GCM_auth_encryption_test_case_256_6),
15106                 TEST_CASE_ST(ut_setup, ut_teardown,
15107                         test_AES_GCM_auth_encryption_test_case_256_7),
15108
15109                 /** AES GCM Authenticated Decryption 256 bits key */
15110                 TEST_CASE_ST(ut_setup, ut_teardown,
15111                         test_AES_GCM_auth_decryption_test_case_256_1),
15112                 TEST_CASE_ST(ut_setup, ut_teardown,
15113                         test_AES_GCM_auth_decryption_test_case_256_2),
15114                 TEST_CASE_ST(ut_setup, ut_teardown,
15115                         test_AES_GCM_auth_decryption_test_case_256_3),
15116                 TEST_CASE_ST(ut_setup, ut_teardown,
15117                         test_AES_GCM_auth_decryption_test_case_256_4),
15118                 TEST_CASE_ST(ut_setup, ut_teardown,
15119                         test_AES_GCM_auth_decryption_test_case_256_5),
15120                 TEST_CASE_ST(ut_setup, ut_teardown,
15121                         test_AES_GCM_auth_decryption_test_case_256_6),
15122                 TEST_CASE_ST(ut_setup, ut_teardown,
15123                         test_AES_GCM_auth_decryption_test_case_256_7),
15124
15125                 /** AES GCM Authenticated Encryption big aad size */
15126                 TEST_CASE_ST(ut_setup, ut_teardown,
15127                         test_AES_GCM_auth_encryption_test_case_aad_1),
15128                 TEST_CASE_ST(ut_setup, ut_teardown,
15129                         test_AES_GCM_auth_encryption_test_case_aad_2),
15130
15131                 /** AES GCM Authenticated Decryption big aad size */
15132                 TEST_CASE_ST(ut_setup, ut_teardown,
15133                         test_AES_GCM_auth_decryption_test_case_aad_1),
15134                 TEST_CASE_ST(ut_setup, ut_teardown,
15135                         test_AES_GCM_auth_decryption_test_case_aad_2),
15136
15137                 /** Out of place tests */
15138                 TEST_CASE_ST(ut_setup, ut_teardown,
15139                         test_AES_GCM_authenticated_encryption_oop_test_case_1),
15140                 TEST_CASE_ST(ut_setup, ut_teardown,
15141                         test_AES_GCM_authenticated_decryption_oop_test_case_1),
15142
15143                 /** Session-less tests */
15144                 TEST_CASE_ST(ut_setup, ut_teardown,
15145                         test_AES_GCM_authenticated_encryption_sessionless_test_case_1),
15146                 TEST_CASE_ST(ut_setup, ut_teardown,
15147                         test_AES_GCM_authenticated_decryption_sessionless_test_case_1),
15148
15149                 TEST_CASES_END()
15150         }
15151 };
15152
15153 static struct unit_test_suite cryptodev_aes_gmac_auth_testsuite  = {
15154         .suite_name = "AES GMAC Authentication Test Suite",
15155         .setup = aes_gmac_auth_testsuite_setup,
15156         .unit_test_cases = {
15157                 TEST_CASE_ST(ut_setup, ut_teardown,
15158                         test_AES_GMAC_authentication_test_case_1),
15159                 TEST_CASE_ST(ut_setup, ut_teardown,
15160                         test_AES_GMAC_authentication_verify_test_case_1),
15161                 TEST_CASE_ST(ut_setup, ut_teardown,
15162                         test_AES_GMAC_authentication_test_case_2),
15163                 TEST_CASE_ST(ut_setup, ut_teardown,
15164                         test_AES_GMAC_authentication_verify_test_case_2),
15165                 TEST_CASE_ST(ut_setup, ut_teardown,
15166                         test_AES_GMAC_authentication_test_case_3),
15167                 TEST_CASE_ST(ut_setup, ut_teardown,
15168                         test_AES_GMAC_authentication_verify_test_case_3),
15169                 TEST_CASE_ST(ut_setup, ut_teardown,
15170                         test_AES_GMAC_authentication_test_case_4),
15171                 TEST_CASE_ST(ut_setup, ut_teardown,
15172                         test_AES_GMAC_authentication_verify_test_case_4),
15173                 TEST_CASE_ST(ut_setup, ut_teardown,
15174                         test_AES_GMAC_authentication_SGL_40B),
15175                 TEST_CASE_ST(ut_setup, ut_teardown,
15176                         test_AES_GMAC_authentication_SGL_80B),
15177                 TEST_CASE_ST(ut_setup, ut_teardown,
15178                         test_AES_GMAC_authentication_SGL_2048B),
15179                 TEST_CASE_ST(ut_setup, ut_teardown,
15180                         test_AES_GMAC_authentication_SGL_2047B),
15181
15182                 TEST_CASES_END()
15183         }
15184 };
15185
15186 static struct unit_test_suite cryptodev_chacha20_poly1305_testsuite  = {
15187         .suite_name = "Chacha20-Poly1305 Test Suite",
15188         .setup = chacha20_poly1305_testsuite_setup,
15189         .unit_test_cases = {
15190                 TEST_CASE_ST(ut_setup, ut_teardown,
15191                         test_chacha20_poly1305_encrypt_test_case_rfc8439),
15192                 TEST_CASE_ST(ut_setup, ut_teardown,
15193                         test_chacha20_poly1305_decrypt_test_case_rfc8439),
15194                 TEST_CASE_ST(ut_setup, ut_teardown,
15195                         test_chacha20_poly1305_encrypt_SGL_out_of_place),
15196                 TEST_CASES_END()
15197         }
15198 };
15199
15200 static struct unit_test_suite cryptodev_snow3g_testsuite  = {
15201         .suite_name = "SNOW 3G Test Suite",
15202         .setup = snow3g_testsuite_setup,
15203         .unit_test_cases = {
15204                 /** SNOW 3G encrypt only (UEA2) */
15205                 TEST_CASE_ST(ut_setup, ut_teardown,
15206                         test_snow3g_encryption_test_case_1),
15207                 TEST_CASE_ST(ut_setup, ut_teardown,
15208                         test_snow3g_encryption_test_case_2),
15209                 TEST_CASE_ST(ut_setup, ut_teardown,
15210                         test_snow3g_encryption_test_case_3),
15211                 TEST_CASE_ST(ut_setup, ut_teardown,
15212                         test_snow3g_encryption_test_case_4),
15213                 TEST_CASE_ST(ut_setup, ut_teardown,
15214                         test_snow3g_encryption_test_case_5),
15215
15216                 TEST_CASE_ST(ut_setup, ut_teardown,
15217                         test_snow3g_encryption_test_case_1_oop),
15218                 TEST_CASE_ST(ut_setup, ut_teardown,
15219                         test_snow3g_encryption_test_case_1_oop_sgl),
15220                 TEST_CASE_ST(ut_setup, ut_teardown,
15221                         test_snow3g_encryption_test_case_1_offset_oop),
15222                 TEST_CASE_ST(ut_setup, ut_teardown,
15223                         test_snow3g_decryption_test_case_1_oop),
15224
15225                 /** SNOW 3G generate auth, then encrypt (UEA2) */
15226                 TEST_CASE_ST(ut_setup, ut_teardown,
15227                         test_snow3g_auth_cipher_test_case_1),
15228                 TEST_CASE_ST(ut_setup, ut_teardown,
15229                         test_snow3g_auth_cipher_test_case_2),
15230                 TEST_CASE_ST(ut_setup, ut_teardown,
15231                         test_snow3g_auth_cipher_test_case_2_oop),
15232                 TEST_CASE_ST(ut_setup, ut_teardown,
15233                         test_snow3g_auth_cipher_part_digest_enc),
15234                 TEST_CASE_ST(ut_setup, ut_teardown,
15235                         test_snow3g_auth_cipher_part_digest_enc_oop),
15236                 TEST_CASE_ST(ut_setup, ut_teardown,
15237                         test_snow3g_auth_cipher_test_case_3_sgl),
15238                 TEST_CASE_ST(ut_setup, ut_teardown,
15239                         test_snow3g_auth_cipher_test_case_3_oop_sgl),
15240                 TEST_CASE_ST(ut_setup, ut_teardown,
15241                         test_snow3g_auth_cipher_part_digest_enc_sgl),
15242                 TEST_CASE_ST(ut_setup, ut_teardown,
15243                         test_snow3g_auth_cipher_part_digest_enc_oop_sgl),
15244
15245                 /** SNOW 3G decrypt (UEA2), then verify auth */
15246                 TEST_CASE_ST(ut_setup, ut_teardown,
15247                         test_snow3g_auth_cipher_verify_test_case_1),
15248                 TEST_CASE_ST(ut_setup, ut_teardown,
15249                         test_snow3g_auth_cipher_verify_test_case_2),
15250                 TEST_CASE_ST(ut_setup, ut_teardown,
15251                         test_snow3g_auth_cipher_verify_test_case_2_oop),
15252                 TEST_CASE_ST(ut_setup, ut_teardown,
15253                         test_snow3g_auth_cipher_verify_part_digest_enc),
15254                 TEST_CASE_ST(ut_setup, ut_teardown,
15255                         test_snow3g_auth_cipher_verify_part_digest_enc_oop),
15256                 TEST_CASE_ST(ut_setup, ut_teardown,
15257                         test_snow3g_auth_cipher_verify_test_case_3_sgl),
15258                 TEST_CASE_ST(ut_setup, ut_teardown,
15259                         test_snow3g_auth_cipher_verify_test_case_3_oop_sgl),
15260                 TEST_CASE_ST(ut_setup, ut_teardown,
15261                         test_snow3g_auth_cipher_verify_part_digest_enc_sgl),
15262                 TEST_CASE_ST(ut_setup, ut_teardown,
15263                         test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl),
15264
15265                 /** SNOW 3G decrypt only (UEA2) */
15266                 TEST_CASE_ST(ut_setup, ut_teardown,
15267                         test_snow3g_decryption_test_case_1),
15268                 TEST_CASE_ST(ut_setup, ut_teardown,
15269                         test_snow3g_decryption_test_case_2),
15270                 TEST_CASE_ST(ut_setup, ut_teardown,
15271                         test_snow3g_decryption_test_case_3),
15272                 TEST_CASE_ST(ut_setup, ut_teardown,
15273                         test_snow3g_decryption_test_case_4),
15274                 TEST_CASE_ST(ut_setup, ut_teardown,
15275                         test_snow3g_decryption_test_case_5),
15276                 TEST_CASE_ST(ut_setup, ut_teardown,
15277                         test_snow3g_decryption_with_digest_test_case_1),
15278                 TEST_CASE_ST(ut_setup, ut_teardown,
15279                         test_snow3g_hash_generate_test_case_1),
15280                 TEST_CASE_ST(ut_setup, ut_teardown,
15281                         test_snow3g_hash_generate_test_case_2),
15282                 TEST_CASE_ST(ut_setup, ut_teardown,
15283                         test_snow3g_hash_generate_test_case_3),
15284
15285                 /* Tests with buffers which length is not byte-aligned */
15286                 TEST_CASE_ST(ut_setup, ut_teardown,
15287                         test_snow3g_hash_generate_test_case_4),
15288                 TEST_CASE_ST(ut_setup, ut_teardown,
15289                         test_snow3g_hash_generate_test_case_5),
15290                 TEST_CASE_ST(ut_setup, ut_teardown,
15291                         test_snow3g_hash_generate_test_case_6),
15292                 TEST_CASE_ST(ut_setup, ut_teardown,
15293                         test_snow3g_hash_verify_test_case_1),
15294                 TEST_CASE_ST(ut_setup, ut_teardown,
15295                         test_snow3g_hash_verify_test_case_2),
15296                 TEST_CASE_ST(ut_setup, ut_teardown,
15297                         test_snow3g_hash_verify_test_case_3),
15298
15299                 /* Tests with buffers which length is not byte-aligned */
15300                 TEST_CASE_ST(ut_setup, ut_teardown,
15301                         test_snow3g_hash_verify_test_case_4),
15302                 TEST_CASE_ST(ut_setup, ut_teardown,
15303                         test_snow3g_hash_verify_test_case_5),
15304                 TEST_CASE_ST(ut_setup, ut_teardown,
15305                         test_snow3g_hash_verify_test_case_6),
15306                 TEST_CASE_ST(ut_setup, ut_teardown,
15307                         test_snow3g_cipher_auth_test_case_1),
15308                 TEST_CASE_ST(ut_setup, ut_teardown,
15309                         test_snow3g_auth_cipher_with_digest_test_case_1),
15310                 TEST_CASES_END()
15311         }
15312 };
15313
15314 static struct unit_test_suite cryptodev_zuc_testsuite  = {
15315         .suite_name = "ZUC Test Suite",
15316         .setup = zuc_testsuite_setup,
15317         .unit_test_cases = {
15318                 /** ZUC encrypt only (EEA3) */
15319                 TEST_CASE_ST(ut_setup, ut_teardown,
15320                         test_zuc_encryption_test_case_1),
15321                 TEST_CASE_ST(ut_setup, ut_teardown,
15322                         test_zuc_encryption_test_case_2),
15323                 TEST_CASE_ST(ut_setup, ut_teardown,
15324                         test_zuc_encryption_test_case_3),
15325                 TEST_CASE_ST(ut_setup, ut_teardown,
15326                         test_zuc_encryption_test_case_4),
15327                 TEST_CASE_ST(ut_setup, ut_teardown,
15328                         test_zuc_encryption_test_case_5),
15329                 TEST_CASE_ST(ut_setup, ut_teardown,
15330                         test_zuc_encryption_test_case_6_sgl),
15331
15332                 /** ZUC authenticate (EIA3) */
15333                 TEST_CASE_ST(ut_setup, ut_teardown,
15334                         test_zuc_hash_generate_test_case_1),
15335                 TEST_CASE_ST(ut_setup, ut_teardown,
15336                         test_zuc_hash_generate_test_case_2),
15337                 TEST_CASE_ST(ut_setup, ut_teardown,
15338                         test_zuc_hash_generate_test_case_3),
15339                 TEST_CASE_ST(ut_setup, ut_teardown,
15340                         test_zuc_hash_generate_test_case_4),
15341                 TEST_CASE_ST(ut_setup, ut_teardown,
15342                         test_zuc_hash_generate_test_case_5),
15343                 TEST_CASE_ST(ut_setup, ut_teardown,
15344                         test_zuc_hash_generate_test_case_6),
15345                 TEST_CASE_ST(ut_setup, ut_teardown,
15346                         test_zuc_hash_generate_test_case_7),
15347                 TEST_CASE_ST(ut_setup, ut_teardown,
15348                         test_zuc_hash_generate_test_case_8),
15349                 TEST_CASE_ST(ut_setup, ut_teardown,
15350                         test_zuc_hash_generate_test_case_9),
15351                 TEST_CASE_ST(ut_setup, ut_teardown,
15352                         test_zuc_hash_generate_test_case_10),
15353                 TEST_CASE_ST(ut_setup, ut_teardown,
15354                         test_zuc_hash_generate_test_case_11),
15355
15356
15357                 /** ZUC alg-chain (EEA3/EIA3) */
15358                 TEST_CASE_ST(ut_setup, ut_teardown,
15359                         test_zuc_cipher_auth_test_case_1),
15360                 TEST_CASE_ST(ut_setup, ut_teardown,
15361                         test_zuc_cipher_auth_test_case_2),
15362
15363                 /** ZUC generate auth, then encrypt (EEA3) */
15364                 TEST_CASE_ST(ut_setup, ut_teardown,
15365                         test_zuc_auth_cipher_test_case_1),
15366                 TEST_CASE_ST(ut_setup, ut_teardown,
15367                         test_zuc_auth_cipher_test_case_1_oop),
15368                 TEST_CASE_ST(ut_setup, ut_teardown,
15369                         test_zuc_auth_cipher_test_case_1_sgl),
15370                 TEST_CASE_ST(ut_setup, ut_teardown,
15371                         test_zuc_auth_cipher_test_case_1_oop_sgl),
15372
15373                 /** ZUC decrypt (EEA3), then verify auth */
15374                 TEST_CASE_ST(ut_setup, ut_teardown,
15375                         test_zuc_auth_cipher_verify_test_case_1),
15376                 TEST_CASE_ST(ut_setup, ut_teardown,
15377                         test_zuc_auth_cipher_verify_test_case_1_oop),
15378                 TEST_CASE_ST(ut_setup, ut_teardown,
15379                         test_zuc_auth_cipher_verify_test_case_1_sgl),
15380                 TEST_CASE_ST(ut_setup, ut_teardown,
15381                         test_zuc_auth_cipher_verify_test_case_1_oop_sgl),
15382
15383                 /** ZUC-256 encrypt only **/
15384                 TEST_CASE_ST(ut_setup, ut_teardown,
15385                         test_zuc256_encryption_test_case_1),
15386                 TEST_CASE_ST(ut_setup, ut_teardown,
15387                         test_zuc256_encryption_test_case_2),
15388
15389                 /** ZUC-256 authentication only **/
15390                 TEST_CASE_ST(ut_setup, ut_teardown,
15391                         test_zuc256_authentication_test_case_1),
15392                 TEST_CASE_ST(ut_setup, ut_teardown,
15393                         test_zuc256_authentication_test_case_2),
15394
15395                 TEST_CASES_END()
15396         }
15397 };
15398
15399 static struct unit_test_suite cryptodev_hmac_md5_auth_testsuite  = {
15400         .suite_name = "HMAC_MD5 Authentication Test Suite",
15401         .setup = hmac_md5_auth_testsuite_setup,
15402         .unit_test_cases = {
15403                 TEST_CASE_ST(ut_setup, ut_teardown,
15404                         test_MD5_HMAC_generate_case_1),
15405                 TEST_CASE_ST(ut_setup, ut_teardown,
15406                         test_MD5_HMAC_verify_case_1),
15407                 TEST_CASE_ST(ut_setup, ut_teardown,
15408                         test_MD5_HMAC_generate_case_2),
15409                 TEST_CASE_ST(ut_setup, ut_teardown,
15410                         test_MD5_HMAC_verify_case_2),
15411                 TEST_CASES_END()
15412         }
15413 };
15414
15415 static struct unit_test_suite cryptodev_kasumi_testsuite  = {
15416         .suite_name = "Kasumi Test Suite",
15417         .setup = kasumi_testsuite_setup,
15418         .unit_test_cases = {
15419                 /** KASUMI hash only (UIA1) */
15420                 TEST_CASE_ST(ut_setup, ut_teardown,
15421                         test_kasumi_hash_generate_test_case_1),
15422                 TEST_CASE_ST(ut_setup, ut_teardown,
15423                         test_kasumi_hash_generate_test_case_2),
15424                 TEST_CASE_ST(ut_setup, ut_teardown,
15425                         test_kasumi_hash_generate_test_case_3),
15426                 TEST_CASE_ST(ut_setup, ut_teardown,
15427                         test_kasumi_hash_generate_test_case_4),
15428                 TEST_CASE_ST(ut_setup, ut_teardown,
15429                         test_kasumi_hash_generate_test_case_5),
15430                 TEST_CASE_ST(ut_setup, ut_teardown,
15431                         test_kasumi_hash_generate_test_case_6),
15432
15433                 TEST_CASE_ST(ut_setup, ut_teardown,
15434                         test_kasumi_hash_verify_test_case_1),
15435                 TEST_CASE_ST(ut_setup, ut_teardown,
15436                         test_kasumi_hash_verify_test_case_2),
15437                 TEST_CASE_ST(ut_setup, ut_teardown,
15438                         test_kasumi_hash_verify_test_case_3),
15439                 TEST_CASE_ST(ut_setup, ut_teardown,
15440                         test_kasumi_hash_verify_test_case_4),
15441                 TEST_CASE_ST(ut_setup, ut_teardown,
15442                         test_kasumi_hash_verify_test_case_5),
15443
15444                 /** KASUMI encrypt only (UEA1) */
15445                 TEST_CASE_ST(ut_setup, ut_teardown,
15446                         test_kasumi_encryption_test_case_1),
15447                 TEST_CASE_ST(ut_setup, ut_teardown,
15448                         test_kasumi_encryption_test_case_1_sgl),
15449                 TEST_CASE_ST(ut_setup, ut_teardown,
15450                         test_kasumi_encryption_test_case_1_oop),
15451                 TEST_CASE_ST(ut_setup, ut_teardown,
15452                         test_kasumi_encryption_test_case_1_oop_sgl),
15453                 TEST_CASE_ST(ut_setup, ut_teardown,
15454                         test_kasumi_encryption_test_case_2),
15455                 TEST_CASE_ST(ut_setup, ut_teardown,
15456                         test_kasumi_encryption_test_case_3),
15457                 TEST_CASE_ST(ut_setup, ut_teardown,
15458                         test_kasumi_encryption_test_case_4),
15459                 TEST_CASE_ST(ut_setup, ut_teardown,
15460                         test_kasumi_encryption_test_case_5),
15461
15462                 /** KASUMI decrypt only (UEA1) */
15463                 TEST_CASE_ST(ut_setup, ut_teardown,
15464                         test_kasumi_decryption_test_case_1),
15465                 TEST_CASE_ST(ut_setup, ut_teardown,
15466                         test_kasumi_decryption_test_case_2),
15467                 TEST_CASE_ST(ut_setup, ut_teardown,
15468                         test_kasumi_decryption_test_case_3),
15469                 TEST_CASE_ST(ut_setup, ut_teardown,
15470                         test_kasumi_decryption_test_case_4),
15471                 TEST_CASE_ST(ut_setup, ut_teardown,
15472                         test_kasumi_decryption_test_case_5),
15473                 TEST_CASE_ST(ut_setup, ut_teardown,
15474                         test_kasumi_decryption_test_case_1_oop),
15475                 TEST_CASE_ST(ut_setup, ut_teardown,
15476                         test_kasumi_cipher_auth_test_case_1),
15477
15478                 /** KASUMI generate auth, then encrypt (F8) */
15479                 TEST_CASE_ST(ut_setup, ut_teardown,
15480                         test_kasumi_auth_cipher_test_case_1),
15481                 TEST_CASE_ST(ut_setup, ut_teardown,
15482                         test_kasumi_auth_cipher_test_case_2),
15483                 TEST_CASE_ST(ut_setup, ut_teardown,
15484                         test_kasumi_auth_cipher_test_case_2_oop),
15485                 TEST_CASE_ST(ut_setup, ut_teardown,
15486                         test_kasumi_auth_cipher_test_case_2_sgl),
15487                 TEST_CASE_ST(ut_setup, ut_teardown,
15488                         test_kasumi_auth_cipher_test_case_2_oop_sgl),
15489
15490                 /** KASUMI decrypt (F8), then verify auth */
15491                 TEST_CASE_ST(ut_setup, ut_teardown,
15492                         test_kasumi_auth_cipher_verify_test_case_1),
15493                 TEST_CASE_ST(ut_setup, ut_teardown,
15494                         test_kasumi_auth_cipher_verify_test_case_2),
15495                 TEST_CASE_ST(ut_setup, ut_teardown,
15496                         test_kasumi_auth_cipher_verify_test_case_2_oop),
15497                 TEST_CASE_ST(ut_setup, ut_teardown,
15498                         test_kasumi_auth_cipher_verify_test_case_2_sgl),
15499                 TEST_CASE_ST(ut_setup, ut_teardown,
15500                         test_kasumi_auth_cipher_verify_test_case_2_oop_sgl),
15501
15502                 TEST_CASES_END()
15503         }
15504 };
15505
15506 static struct unit_test_suite cryptodev_esn_testsuite  = {
15507         .suite_name = "ESN Test Suite",
15508         .setup = esn_testsuite_setup,
15509         .unit_test_cases = {
15510                 TEST_CASE_ST(ut_setup, ut_teardown,
15511                         auth_encrypt_AES128CBC_HMAC_SHA1_esn_check),
15512                 TEST_CASE_ST(ut_setup, ut_teardown,
15513                         auth_decrypt_AES128CBC_HMAC_SHA1_esn_check),
15514                 TEST_CASES_END()
15515         }
15516 };
15517
15518 static struct unit_test_suite cryptodev_negative_aes_gcm_testsuite  = {
15519         .suite_name = "Negative AES GCM Test Suite",
15520         .setup = negative_aes_gcm_testsuite_setup,
15521         .unit_test_cases = {
15522                 TEST_CASE_ST(ut_setup, ut_teardown,
15523                         test_AES_GCM_auth_encryption_fail_iv_corrupt),
15524                 TEST_CASE_ST(ut_setup, ut_teardown,
15525                         test_AES_GCM_auth_encryption_fail_in_data_corrupt),
15526                 TEST_CASE_ST(ut_setup, ut_teardown,
15527                         test_AES_GCM_auth_encryption_fail_out_data_corrupt),
15528                 TEST_CASE_ST(ut_setup, ut_teardown,
15529                         test_AES_GCM_auth_encryption_fail_aad_len_corrupt),
15530                 TEST_CASE_ST(ut_setup, ut_teardown,
15531                         test_AES_GCM_auth_encryption_fail_aad_corrupt),
15532                 TEST_CASE_ST(ut_setup, ut_teardown,
15533                         test_AES_GCM_auth_encryption_fail_tag_corrupt),
15534                 TEST_CASE_ST(ut_setup, ut_teardown,
15535                         test_AES_GCM_auth_decryption_fail_iv_corrupt),
15536                 TEST_CASE_ST(ut_setup, ut_teardown,
15537                         test_AES_GCM_auth_decryption_fail_in_data_corrupt),
15538                 TEST_CASE_ST(ut_setup, ut_teardown,
15539                         test_AES_GCM_auth_decryption_fail_out_data_corrupt),
15540                 TEST_CASE_ST(ut_setup, ut_teardown,
15541                         test_AES_GCM_auth_decryption_fail_aad_len_corrupt),
15542                 TEST_CASE_ST(ut_setup, ut_teardown,
15543                         test_AES_GCM_auth_decryption_fail_aad_corrupt),
15544                 TEST_CASE_ST(ut_setup, ut_teardown,
15545                         test_AES_GCM_auth_decryption_fail_tag_corrupt),
15546
15547                 TEST_CASES_END()
15548         }
15549 };
15550
15551 static struct unit_test_suite cryptodev_negative_aes_gmac_testsuite  = {
15552         .suite_name = "Negative AES GMAC Test Suite",
15553         .setup = negative_aes_gmac_testsuite_setup,
15554         .unit_test_cases = {
15555                 TEST_CASE_ST(ut_setup, ut_teardown,
15556                         authentication_verify_AES128_GMAC_fail_data_corrupt),
15557                 TEST_CASE_ST(ut_setup, ut_teardown,
15558                         authentication_verify_AES128_GMAC_fail_tag_corrupt),
15559
15560                 TEST_CASES_END()
15561         }
15562 };
15563
15564 static struct unit_test_suite cryptodev_mixed_cipher_hash_testsuite  = {
15565         .suite_name = "Mixed CIPHER + HASH algorithms Test Suite",
15566         .setup = mixed_cipher_hash_testsuite_setup,
15567         .unit_test_cases = {
15568                 /** AUTH AES CMAC + CIPHER AES CTR */
15569                 TEST_CASE_ST(ut_setup, ut_teardown,
15570                         test_aes_cmac_aes_ctr_digest_enc_test_case_1),
15571                 TEST_CASE_ST(ut_setup, ut_teardown,
15572                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
15573                 TEST_CASE_ST(ut_setup, ut_teardown,
15574                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
15575                 TEST_CASE_ST(ut_setup, ut_teardown,
15576                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
15577                 TEST_CASE_ST(ut_setup, ut_teardown,
15578                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1),
15579                 TEST_CASE_ST(ut_setup, ut_teardown,
15580                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
15581                 TEST_CASE_ST(ut_setup, ut_teardown,
15582                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
15583                 TEST_CASE_ST(ut_setup, ut_teardown,
15584                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
15585
15586                 /** AUTH ZUC + CIPHER SNOW3G */
15587                 TEST_CASE_ST(ut_setup, ut_teardown,
15588                         test_auth_zuc_cipher_snow_test_case_1),
15589                 TEST_CASE_ST(ut_setup, ut_teardown,
15590                         test_verify_auth_zuc_cipher_snow_test_case_1),
15591                 /** AUTH AES CMAC + CIPHER SNOW3G */
15592                 TEST_CASE_ST(ut_setup, ut_teardown,
15593                         test_auth_aes_cmac_cipher_snow_test_case_1),
15594                 TEST_CASE_ST(ut_setup, ut_teardown,
15595                         test_verify_auth_aes_cmac_cipher_snow_test_case_1),
15596                 /** AUTH ZUC + CIPHER AES CTR */
15597                 TEST_CASE_ST(ut_setup, ut_teardown,
15598                         test_auth_zuc_cipher_aes_ctr_test_case_1),
15599                 TEST_CASE_ST(ut_setup, ut_teardown,
15600                         test_verify_auth_zuc_cipher_aes_ctr_test_case_1),
15601                 /** AUTH SNOW3G + CIPHER AES CTR */
15602                 TEST_CASE_ST(ut_setup, ut_teardown,
15603                         test_auth_snow_cipher_aes_ctr_test_case_1),
15604                 TEST_CASE_ST(ut_setup, ut_teardown,
15605                         test_verify_auth_snow_cipher_aes_ctr_test_case_1),
15606                 /** AUTH SNOW3G + CIPHER ZUC */
15607                 TEST_CASE_ST(ut_setup, ut_teardown,
15608                         test_auth_snow_cipher_zuc_test_case_1),
15609                 TEST_CASE_ST(ut_setup, ut_teardown,
15610                         test_verify_auth_snow_cipher_zuc_test_case_1),
15611                 /** AUTH AES CMAC + CIPHER ZUC */
15612                 TEST_CASE_ST(ut_setup, ut_teardown,
15613                         test_auth_aes_cmac_cipher_zuc_test_case_1),
15614                 TEST_CASE_ST(ut_setup, ut_teardown,
15615                         test_verify_auth_aes_cmac_cipher_zuc_test_case_1),
15616
15617                 /** AUTH NULL + CIPHER SNOW3G */
15618                 TEST_CASE_ST(ut_setup, ut_teardown,
15619                         test_auth_null_cipher_snow_test_case_1),
15620                 TEST_CASE_ST(ut_setup, ut_teardown,
15621                         test_verify_auth_null_cipher_snow_test_case_1),
15622                 /** AUTH NULL + CIPHER ZUC */
15623                 TEST_CASE_ST(ut_setup, ut_teardown,
15624                         test_auth_null_cipher_zuc_test_case_1),
15625                 TEST_CASE_ST(ut_setup, ut_teardown,
15626                         test_verify_auth_null_cipher_zuc_test_case_1),
15627                 /** AUTH SNOW3G + CIPHER NULL */
15628                 TEST_CASE_ST(ut_setup, ut_teardown,
15629                         test_auth_snow_cipher_null_test_case_1),
15630                 TEST_CASE_ST(ut_setup, ut_teardown,
15631                         test_verify_auth_snow_cipher_null_test_case_1),
15632                 /** AUTH ZUC + CIPHER NULL */
15633                 TEST_CASE_ST(ut_setup, ut_teardown,
15634                         test_auth_zuc_cipher_null_test_case_1),
15635                 TEST_CASE_ST(ut_setup, ut_teardown,
15636                         test_verify_auth_zuc_cipher_null_test_case_1),
15637                 /** AUTH NULL + CIPHER AES CTR */
15638                 TEST_CASE_ST(ut_setup, ut_teardown,
15639                         test_auth_null_cipher_aes_ctr_test_case_1),
15640                 TEST_CASE_ST(ut_setup, ut_teardown,
15641                         test_verify_auth_null_cipher_aes_ctr_test_case_1),
15642                 /** AUTH AES CMAC + CIPHER NULL */
15643                 TEST_CASE_ST(ut_setup, ut_teardown,
15644                         test_auth_aes_cmac_cipher_null_test_case_1),
15645                 TEST_CASE_ST(ut_setup, ut_teardown,
15646                         test_verify_auth_aes_cmac_cipher_null_test_case_1),
15647                 TEST_CASES_END()
15648         }
15649 };
15650
15651 static int
15652 run_cryptodev_testsuite(const char *pmd_name)
15653 {
15654         uint8_t ret, j, i = 0, blk_start_idx = 0;
15655         const enum blockcipher_test_type blk_suites[] = {
15656                 BLKCIPHER_AES_CHAIN_TYPE,
15657                 BLKCIPHER_AES_CIPHERONLY_TYPE,
15658                 BLKCIPHER_AES_DOCSIS_TYPE,
15659                 BLKCIPHER_3DES_CHAIN_TYPE,
15660                 BLKCIPHER_3DES_CIPHERONLY_TYPE,
15661                 BLKCIPHER_DES_CIPHERONLY_TYPE,
15662                 BLKCIPHER_DES_DOCSIS_TYPE,
15663                 BLKCIPHER_AUTHONLY_TYPE};
15664         struct unit_test_suite *static_suites[] = {
15665                 &cryptodev_multi_session_testsuite,
15666                 &cryptodev_null_testsuite,
15667                 &cryptodev_aes_ccm_auth_testsuite,
15668                 &cryptodev_aes_gcm_auth_testsuite,
15669                 &cryptodev_aes_gmac_auth_testsuite,
15670                 &cryptodev_snow3g_testsuite,
15671                 &cryptodev_chacha20_poly1305_testsuite,
15672                 &cryptodev_zuc_testsuite,
15673                 &cryptodev_hmac_md5_auth_testsuite,
15674                 &cryptodev_kasumi_testsuite,
15675                 &cryptodev_esn_testsuite,
15676                 &cryptodev_negative_aes_gcm_testsuite,
15677                 &cryptodev_negative_aes_gmac_testsuite,
15678                 &cryptodev_mixed_cipher_hash_testsuite,
15679                 &cryptodev_negative_hmac_sha1_testsuite,
15680                 &cryptodev_gen_testsuite,
15681 #ifdef RTE_LIB_SECURITY
15682                 &ipsec_proto_testsuite,
15683                 &pdcp_proto_testsuite,
15684                 &docsis_proto_testsuite,
15685 #endif
15686                 &end_testsuite
15687         };
15688         static struct unit_test_suite ts = {
15689                 .suite_name = "Cryptodev Unit Test Suite",
15690                 .setup = testsuite_setup,
15691                 .teardown = testsuite_teardown,
15692                 .unit_test_cases = {TEST_CASES_END()}
15693         };
15694
15695         gbl_driver_id = rte_cryptodev_driver_id_get(pmd_name);
15696
15697         if (gbl_driver_id == -1) {
15698                 RTE_LOG(ERR, USER1, "%s PMD must be loaded.\n", pmd_name);
15699                 return TEST_SKIPPED;
15700         }
15701
15702         ts.unit_test_suites = malloc(sizeof(struct unit_test_suite *) *
15703                         (RTE_DIM(blk_suites) + RTE_DIM(static_suites)));
15704
15705         ADD_BLOCKCIPHER_TESTSUITE(i, ts, blk_suites, RTE_DIM(blk_suites));
15706         ADD_STATIC_TESTSUITE(i, ts, static_suites, RTE_DIM(static_suites));
15707         ret = unit_test_suite_runner(&ts);
15708
15709         FREE_BLOCKCIPHER_TESTSUITE(blk_start_idx, ts, RTE_DIM(blk_suites));
15710         free(ts.unit_test_suites);
15711         return ret;
15712 }
15713
15714 static int
15715 require_feature_flag(const char *pmd_name, uint64_t flag, const char *flag_name)
15716 {
15717         struct rte_cryptodev_info dev_info;
15718         uint8_t i, nb_devs;
15719         int driver_id;
15720
15721         driver_id = rte_cryptodev_driver_id_get(pmd_name);
15722         if (driver_id == -1) {
15723                 RTE_LOG(WARNING, USER1, "%s PMD must be loaded.\n", pmd_name);
15724                 return TEST_SKIPPED;
15725         }
15726
15727         nb_devs = rte_cryptodev_count();
15728         if (nb_devs < 1) {
15729                 RTE_LOG(WARNING, USER1, "No crypto devices found?\n");
15730                 return TEST_SKIPPED;
15731         }
15732
15733         for (i = 0; i < nb_devs; i++) {
15734                 rte_cryptodev_info_get(i, &dev_info);
15735                 if (dev_info.driver_id == driver_id) {
15736                         if (!(dev_info.feature_flags & flag)) {
15737                                 RTE_LOG(INFO, USER1, "%s not supported\n",
15738                                                 flag_name);
15739                                 return TEST_SKIPPED;
15740                         }
15741                         return 0; /* found */
15742                 }
15743         }
15744
15745         RTE_LOG(INFO, USER1, "%s not supported\n", flag_name);
15746         return TEST_SKIPPED;
15747 }
15748
15749 static int
15750 test_cryptodev_qat(void)
15751 {
15752         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
15753 }
15754
15755 static int
15756 test_cryptodev_virtio(void)
15757 {
15758         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD));
15759 }
15760
15761 static int
15762 test_cryptodev_aesni_mb(void)
15763 {
15764         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
15765 }
15766
15767 static int
15768 test_cryptodev_cpu_aesni_mb(void)
15769 {
15770         int32_t rc;
15771         enum rte_security_session_action_type at = gbl_action_type;
15772         gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
15773         rc = run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
15774         gbl_action_type = at;
15775         return rc;
15776 }
15777
15778 static int
15779 test_cryptodev_chacha_poly_mb(void)
15780 {
15781         int32_t rc;
15782         enum rte_security_session_action_type at = gbl_action_type;
15783         rc = run_cryptodev_testsuite(
15784                         RTE_STR(CRYPTODEV_NAME_CHACHA20_POLY1305_PMD));
15785         gbl_action_type = at;
15786         return rc;
15787 }
15788
15789 static int
15790 test_cryptodev_openssl(void)
15791 {
15792         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
15793 }
15794
15795 static int
15796 test_cryptodev_aesni_gcm(void)
15797 {
15798         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
15799 }
15800
15801 static int
15802 test_cryptodev_cpu_aesni_gcm(void)
15803 {
15804         int32_t rc;
15805         enum rte_security_session_action_type at = gbl_action_type;
15806         gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
15807         rc  = run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
15808         gbl_action_type = at;
15809         return rc;
15810 }
15811
15812 static int
15813 test_cryptodev_mlx5(void)
15814 {
15815         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_MLX5_PMD));
15816 }
15817
15818 static int
15819 test_cryptodev_null(void)
15820 {
15821         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_NULL_PMD));
15822 }
15823
15824 static int
15825 test_cryptodev_sw_snow3g(void)
15826 {
15827         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
15828 }
15829
15830 static int
15831 test_cryptodev_sw_kasumi(void)
15832 {
15833         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
15834 }
15835
15836 static int
15837 test_cryptodev_sw_zuc(void)
15838 {
15839         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
15840 }
15841
15842 static int
15843 test_cryptodev_armv8(void)
15844 {
15845         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
15846 }
15847
15848 static int
15849 test_cryptodev_mrvl(void)
15850 {
15851         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
15852 }
15853
15854 #ifdef RTE_CRYPTO_SCHEDULER
15855
15856 static int
15857 test_cryptodev_scheduler(void)
15858 {
15859         uint8_t ret, sched_i, j, i = 0, blk_start_idx = 0;
15860         const enum blockcipher_test_type blk_suites[] = {
15861                 BLKCIPHER_AES_CHAIN_TYPE,
15862                 BLKCIPHER_AES_CIPHERONLY_TYPE,
15863                 BLKCIPHER_AUTHONLY_TYPE
15864         };
15865         static struct unit_test_suite scheduler_multicore = {
15866                 .suite_name = "Scheduler Multicore Unit Test Suite",
15867                 .setup = scheduler_multicore_testsuite_setup,
15868                 .teardown = scheduler_mode_testsuite_teardown,
15869                 .unit_test_cases = {TEST_CASES_END()}
15870         };
15871         static struct unit_test_suite scheduler_round_robin = {
15872                 .suite_name = "Scheduler Round Robin Unit Test Suite",
15873                 .setup = scheduler_roundrobin_testsuite_setup,
15874                 .teardown = scheduler_mode_testsuite_teardown,
15875                 .unit_test_cases = {TEST_CASES_END()}
15876         };
15877         static struct unit_test_suite scheduler_failover = {
15878                 .suite_name = "Scheduler Failover Unit Test Suite",
15879                 .setup = scheduler_failover_testsuite_setup,
15880                 .teardown = scheduler_mode_testsuite_teardown,
15881                 .unit_test_cases = {TEST_CASES_END()}
15882         };
15883         static struct unit_test_suite scheduler_pkt_size_distr = {
15884                 .suite_name = "Scheduler Pkt Size Distr Unit Test Suite",
15885                 .setup = scheduler_pkt_size_distr_testsuite_setup,
15886                 .teardown = scheduler_mode_testsuite_teardown,
15887                 .unit_test_cases = {TEST_CASES_END()}
15888         };
15889         struct unit_test_suite *sched_mode_suites[] = {
15890                 &scheduler_multicore,
15891                 &scheduler_round_robin,
15892                 &scheduler_failover,
15893                 &scheduler_pkt_size_distr
15894         };
15895         static struct unit_test_suite scheduler_config = {
15896                 .suite_name = "Crypto Device Scheduler Config Unit Test Suite",
15897                 .unit_test_cases = {
15898                         TEST_CASE(test_scheduler_attach_worker_op),
15899                         TEST_CASE(test_scheduler_mode_multicore_op),
15900                         TEST_CASE(test_scheduler_mode_roundrobin_op),
15901                         TEST_CASE(test_scheduler_mode_failover_op),
15902                         TEST_CASE(test_scheduler_mode_pkt_size_distr_op),
15903                         TEST_CASE(test_scheduler_detach_worker_op),
15904
15905                         TEST_CASES_END() /**< NULL terminate array */
15906                 }
15907         };
15908         struct unit_test_suite *static_suites[] = {
15909                 &scheduler_config,
15910                 &end_testsuite
15911         };
15912         static struct unit_test_suite ts = {
15913                 .suite_name = "Scheduler Unit Test Suite",
15914                 .setup = scheduler_testsuite_setup,
15915                 .teardown = testsuite_teardown,
15916                 .unit_test_cases = {TEST_CASES_END()}
15917         };
15918
15919         gbl_driver_id = rte_cryptodev_driver_id_get(
15920                         RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
15921
15922         if (gbl_driver_id == -1) {
15923                 RTE_LOG(ERR, USER1, "SCHEDULER PMD must be loaded.\n");
15924                 return TEST_SKIPPED;
15925         }
15926
15927         if (rte_cryptodev_driver_id_get(
15928                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) == -1) {
15929                 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded.\n");
15930                 return TEST_SKIPPED;
15931         }
15932
15933         for (sched_i = 0; sched_i < RTE_DIM(sched_mode_suites); sched_i++) {
15934                 uint8_t blk_i = 0;
15935                 sched_mode_suites[sched_i]->unit_test_suites = malloc(sizeof
15936                                 (struct unit_test_suite *) *
15937                                 (RTE_DIM(blk_suites) + 1));
15938                 ADD_BLOCKCIPHER_TESTSUITE(blk_i, (*sched_mode_suites[sched_i]),
15939                                 blk_suites, RTE_DIM(blk_suites));
15940                 sched_mode_suites[sched_i]->unit_test_suites[blk_i] = &end_testsuite;
15941         }
15942
15943         ts.unit_test_suites = malloc(sizeof(struct unit_test_suite *) *
15944                         (RTE_DIM(static_suites) + RTE_DIM(sched_mode_suites)));
15945         ADD_STATIC_TESTSUITE(i, ts, sched_mode_suites,
15946                         RTE_DIM(sched_mode_suites));
15947         ADD_STATIC_TESTSUITE(i, ts, static_suites, RTE_DIM(static_suites));
15948         ret = unit_test_suite_runner(&ts);
15949
15950         for (sched_i = 0; sched_i < RTE_DIM(sched_mode_suites); sched_i++) {
15951                 FREE_BLOCKCIPHER_TESTSUITE(blk_start_idx,
15952                                 (*sched_mode_suites[sched_i]),
15953                                 RTE_DIM(blk_suites));
15954                 free(sched_mode_suites[sched_i]->unit_test_suites);
15955         }
15956         free(ts.unit_test_suites);
15957         return ret;
15958 }
15959
15960 REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler);
15961
15962 #endif
15963
15964 static int
15965 test_cryptodev_dpaa2_sec(void)
15966 {
15967         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
15968 }
15969
15970 static int
15971 test_cryptodev_dpaa_sec(void)
15972 {
15973         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD));
15974 }
15975
15976 static int
15977 test_cryptodev_ccp(void)
15978 {
15979         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CCP_PMD));
15980 }
15981
15982 static int
15983 test_cryptodev_octeontx(void)
15984 {
15985         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD));
15986 }
15987
15988 static int
15989 test_cryptodev_caam_jr(void)
15990 {
15991         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD));
15992 }
15993
15994 static int
15995 test_cryptodev_nitrox(void)
15996 {
15997         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_NITROX_PMD));
15998 }
15999
16000 static int
16001 test_cryptodev_bcmfs(void)
16002 {
16003         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_BCMFS_PMD));
16004 }
16005
16006 static int
16007 test_cryptodev_qat_raw_api(void)
16008 {
16009         static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD);
16010         int ret;
16011
16012         ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
16013                         "RAW API");
16014         if (ret)
16015                 return ret;
16016
16017         global_api_test_type = CRYPTODEV_RAW_API_TEST;
16018         ret = run_cryptodev_testsuite(pmd_name);
16019         global_api_test_type = CRYPTODEV_API_TEST;
16020
16021         return ret;
16022 }
16023
16024 static int
16025 test_cryptodev_cn9k(void)
16026 {
16027         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CN9K_PMD));
16028 }
16029
16030 static int
16031 test_cryptodev_cn10k(void)
16032 {
16033         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CN10K_PMD));
16034 }
16035
16036 static int
16037 test_cryptodev_dpaa2_sec_raw_api(void)
16038 {
16039         static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD);
16040         int ret;
16041
16042         ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
16043                         "RAW API");
16044         if (ret)
16045                 return ret;
16046
16047         global_api_test_type = CRYPTODEV_RAW_API_TEST;
16048         ret = run_cryptodev_testsuite(pmd_name);
16049         global_api_test_type = CRYPTODEV_API_TEST;
16050
16051         return ret;
16052 }
16053
16054 static int
16055 test_cryptodev_dpaa_sec_raw_api(void)
16056 {
16057         static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD);
16058         int ret;
16059
16060         ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
16061                         "RAW API");
16062         if (ret)
16063                 return ret;
16064
16065         global_api_test_type = CRYPTODEV_RAW_API_TEST;
16066         ret = run_cryptodev_testsuite(pmd_name);
16067         global_api_test_type = CRYPTODEV_API_TEST;
16068
16069         return ret;
16070 }
16071
16072 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_raw_api_autotest,
16073                 test_cryptodev_dpaa2_sec_raw_api);
16074 REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_raw_api_autotest,
16075                 test_cryptodev_dpaa_sec_raw_api);
16076 REGISTER_TEST_COMMAND(cryptodev_qat_raw_api_autotest,
16077                 test_cryptodev_qat_raw_api);
16078 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
16079 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
16080 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_mb_autotest,
16081         test_cryptodev_cpu_aesni_mb);
16082 REGISTER_TEST_COMMAND(cryptodev_chacha_poly_mb_autotest,
16083         test_cryptodev_chacha_poly_mb);
16084 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl);
16085 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm);
16086 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_gcm_autotest,
16087         test_cryptodev_cpu_aesni_gcm);
16088 REGISTER_TEST_COMMAND(cryptodev_mlx5_autotest, test_cryptodev_mlx5);
16089 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null);
16090 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
16091 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);
16092 REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc);
16093 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_autotest, test_cryptodev_armv8);
16094 REGISTER_TEST_COMMAND(cryptodev_sw_mvsam_autotest, test_cryptodev_mrvl);
16095 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_autotest, test_cryptodev_dpaa2_sec);
16096 REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_autotest, test_cryptodev_dpaa_sec);
16097 REGISTER_TEST_COMMAND(cryptodev_ccp_autotest, test_cryptodev_ccp);
16098 REGISTER_TEST_COMMAND(cryptodev_virtio_autotest, test_cryptodev_virtio);
16099 REGISTER_TEST_COMMAND(cryptodev_octeontx_autotest, test_cryptodev_octeontx);
16100 REGISTER_TEST_COMMAND(cryptodev_caam_jr_autotest, test_cryptodev_caam_jr);
16101 REGISTER_TEST_COMMAND(cryptodev_nitrox_autotest, test_cryptodev_nitrox);
16102 REGISTER_TEST_COMMAND(cryptodev_bcmfs_autotest, test_cryptodev_bcmfs);
16103 REGISTER_TEST_COMMAND(cryptodev_cn9k_autotest, test_cryptodev_cn9k);
16104 REGISTER_TEST_COMMAND(cryptodev_cn10k_autotest, test_cryptodev_cn10k);
16105
16106 #endif /* !RTE_EXEC_ENV_WINDOWS */