app/test/test_cryptodev.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2015-2020 Intel Corporation
   3  */
   4
   5 #include <time.h>
   6
   7 #include <rte_common.h>
   8 #include <rte_hexdump.h>
   9 #include <rte_mbuf.h>
  10 #include <rte_malloc.h>
  11 #include <rte_memcpy.h>
  12 #include <rte_pause.h>
  13 #include <rte_bus_vdev.h>
  14
  15 #include <rte_crypto.h>
  16 #include <rte_cryptodev.h>
  17 #include <rte_cryptodev_pmd.h>
  18 #include <rte_string_fns.h>
  19
  20 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
  21 #include <rte_cryptodev_scheduler.h>
  22 #include <rte_cryptodev_scheduler_operations.h>
  23 #endif
  24
  25 #include <rte_lcore.h>
  26
  27 #include "test.h"
  28 #include "test_cryptodev.h"
  29
  30 #include "test_cryptodev_blockcipher.h"
  31 #include "test_cryptodev_aes_test_vectors.h"
  32 #include "test_cryptodev_des_test_vectors.h"
  33 #include "test_cryptodev_hash_test_vectors.h"
  34 #include "test_cryptodev_kasumi_test_vectors.h"
  35 #include "test_cryptodev_kasumi_hash_test_vectors.h"
  36 #include "test_cryptodev_snow3g_test_vectors.h"
  37 #include "test_cryptodev_snow3g_hash_test_vectors.h"
  38 #include "test_cryptodev_zuc_test_vectors.h"
  39 #include "test_cryptodev_aead_test_vectors.h"
  40 #include "test_cryptodev_hmac_test_vectors.h"
  41 #include "test_cryptodev_mixed_test_vectors.h"
  42 #ifdef RTE_LIBRTE_SECURITY
  43 #include "test_cryptodev_security_pdcp_test_vectors.h"
  44 #include "test_cryptodev_security_pdcp_test_func.h"
  45 #endif
  46
  47 #define VDEV_ARGS_SIZE 100
  48 #define MAX_NB_SESSIONS 4
  49
  50 #define IN_PLACE 0
  51 #define OUT_OF_PLACE 1
  52
  53 static int gbl_driver_id;
  54
  55 static enum rte_security_session_action_type gbl_action_type =
  56         RTE_SECURITY_ACTION_TYPE_NONE;
  57
  58 struct crypto_testsuite_params {
  59         struct rte_mempool *mbuf_pool;
  60         struct rte_mempool *large_mbuf_pool;
  61         struct rte_mempool *op_mpool;
  62         struct rte_mempool *session_mpool;
  63         struct rte_mempool *session_priv_mpool;
  64         struct rte_cryptodev_config conf;
  65         struct rte_cryptodev_qp_conf qp_conf;
  66
  67         uint8_t valid_devs[RTE_CRYPTO_MAX_DEVS];
  68         uint8_t valid_dev_count;
  69 };
  70
  71 struct crypto_unittest_params {
  72         struct rte_crypto_sym_xform cipher_xform;
  73         struct rte_crypto_sym_xform auth_xform;
  74         struct rte_crypto_sym_xform aead_xform;
  75
  76         union {
  77                 struct rte_cryptodev_sym_session *sess;
  78 #ifdef RTE_LIBRTE_SECURITY
  79                 struct rte_security_session *sec_session;
  80 #endif
  81         };
  82 #ifdef RTE_LIBRTE_SECURITY
  83         enum rte_security_session_action_type type;
  84 #endif
  85         struct rte_crypto_op *op;
  86
  87         struct rte_mbuf *obuf, *ibuf;
  88
  89         uint8_t *digest;
  90 };
  91
  92 #define ALIGN_POW2_ROUNDUP(num, align) \
  93         (((num) + (align) - 1) & ~((align) - 1))
  94
  95 /*
  96  * Forward declarations.
  97  */
  98 static int
  99 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
 100                 struct crypto_unittest_params *ut_params, uint8_t *cipher_key,
 101                 uint8_t *hmac_key);
 102
 103 static int
 104 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
 105                 struct crypto_unittest_params *ut_params,
 106                 struct crypto_testsuite_params *ts_param,
 107                 const uint8_t *cipher,
 108                 const uint8_t *digest,
 109                 const uint8_t *iv);
 110
 111 static struct rte_mbuf *
 112 setup_test_string(struct rte_mempool *mpool,
 113                 const char *string, size_t len, uint8_t blocksize)
 114 {
 115         struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
 116         size_t t_len = len - (blocksize ? (len % blocksize) : 0);
 117
 118         memset(m->buf_addr, 0, m->buf_len);
 119         if (m) {
 120                 char *dst = rte_pktmbuf_append(m, t_len);
 121
 122                 if (!dst) {
 123                         rte_pktmbuf_free(m);
 124                         return NULL;
 125                 }
 126                 if (string != NULL)
 127                         rte_memcpy(dst, string, t_len);
 128                 else
 129                         memset(dst, 0, t_len);
 130         }
 131
 132         return m;
 133 }
 134
 135 /* Get number of bytes in X bits (rounding up) */
 136 static uint32_t
 137 ceil_byte_length(uint32_t num_bits)
 138 {
 139         if (num_bits % 8)
 140                 return ((num_bits >> 3) + 1);
 141         else
 142                 return (num_bits >> 3);
 143 }
 144
 145 static void
 146 process_cpu_aead_op(uint8_t dev_id, struct rte_crypto_op *op)
 147 {
 148         int32_t n, st;
 149         void *iv;
 150         struct rte_crypto_sym_op *sop;
 151         union rte_crypto_sym_ofs ofs;
 152         struct rte_crypto_sgl sgl;
 153         struct rte_crypto_sym_vec symvec;
 154         struct rte_crypto_vec vec[UINT8_MAX];
 155
 156         sop = op->sym;
 157
 158         n = rte_crypto_mbuf_to_vec(sop->m_src, sop->aead.data.offset,
 159                 sop->aead.data.length, vec, RTE_DIM(vec));
 160
 161         if (n < 0 || n != sop->m_src->nb_segs) {
 162                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 163                 return;
 164         }
 165
 166         sgl.vec = vec;
 167         sgl.num = n;
 168         symvec.sgl = &sgl;
 169         iv = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 170         symvec.iv = &iv;
 171         symvec.aad = (void **)&sop->aead.aad.data;
 172         symvec.digest = (void **)&sop->aead.digest.data;
 173         symvec.status = &st;
 174         symvec.num = 1;
 175
 176         ofs.raw = 0;
 177
 178         n = rte_cryptodev_sym_cpu_crypto_process(dev_id, sop->session, ofs,
 179                 &symvec);
 180
 181         if (n != 1)
 182                 op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
 183         else
 184                 op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
 185 }
 186
 187 static void
 188 process_cpu_crypt_auth_op(uint8_t dev_id, struct rte_crypto_op *op)
 189 {
 190         int32_t n, st;
 191         void *iv;
 192         struct rte_crypto_sym_op *sop;
 193         union rte_crypto_sym_ofs ofs;
 194         struct rte_crypto_sgl sgl;
 195         struct rte_crypto_sym_vec symvec;
 196         struct rte_crypto_vec vec[UINT8_MAX];
 197
 198         sop = op->sym;
 199
 200         n = rte_crypto_mbuf_to_vec(sop->m_src, sop->auth.data.offset,
 201                 sop->auth.data.length, vec, RTE_DIM(vec));
 202
 203         if (n < 0 || n != sop->m_src->nb_segs) {
 204                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 205                 return;
 206         }
 207
 208         sgl.vec = vec;
 209         sgl.num = n;
 210         symvec.sgl = &sgl;
 211         iv = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 212         symvec.iv = &iv;
 213         symvec.aad = (void **)&sop->aead.aad.data;
 214         symvec.digest = (void **)&sop->auth.digest.data;
 215         symvec.status = &st;
 216         symvec.num = 1;
 217
 218         ofs.raw = 0;
 219         ofs.ofs.cipher.head = sop->cipher.data.offset - sop->auth.data.offset;
 220         ofs.ofs.cipher.tail = (sop->auth.data.offset + sop->auth.data.length) -
 221                 (sop->cipher.data.offset + sop->cipher.data.length);
 222
 223         n = rte_cryptodev_sym_cpu_crypto_process(dev_id, sop->session, ofs,
 224                 &symvec);
 225
 226         if (n != 1)
 227                 op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
 228         else
 229                 op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
 230 }
 231
 232 static struct rte_crypto_op *
 233 process_crypto_request(uint8_t dev_id, struct rte_crypto_op *op)
 234 {
 235
 236         RTE_VERIFY(gbl_action_type != RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO);
 237
 238         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
 239                 RTE_LOG(ERR, USER1, "Error sending packet for encryption\n");
 240                 return NULL;
 241         }
 242
 243         op = NULL;
 244
 245         while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0)
 246                 rte_pause();
 247
 248         if (op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
 249                 RTE_LOG(DEBUG, USER1, "Operation status %d\n", op->status);
 250                 return NULL;
 251         }
 252
 253         return op;
 254 }
 255
 256 static struct crypto_testsuite_params testsuite_params = { NULL };
 257 static struct crypto_unittest_params unittest_params;
 258
 259 static int
 260 testsuite_setup(void)
 261 {
 262         struct crypto_testsuite_params *ts_params = &testsuite_params;
 263         struct rte_cryptodev_info info;
 264         uint32_t i = 0, nb_devs, dev_id;
 265         int ret;
 266         uint16_t qp_id;
 267
 268         memset(ts_params, 0, sizeof(*ts_params));
 269
 270         ts_params->mbuf_pool = rte_mempool_lookup("CRYPTO_MBUFPOOL");
 271         if (ts_params->mbuf_pool == NULL) {
 272                 /* Not already created so create */
 273                 ts_params->mbuf_pool = rte_pktmbuf_pool_create(
 274                                 "CRYPTO_MBUFPOOL",
 275                                 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
 276                                 rte_socket_id());
 277                 if (ts_params->mbuf_pool == NULL) {
 278                         RTE_LOG(ERR, USER1, "Can't create CRYPTO_MBUFPOOL\n");
 279                         return TEST_FAILED;
 280                 }
 281         }
 282
 283         ts_params->large_mbuf_pool = rte_mempool_lookup(
 284                         "CRYPTO_LARGE_MBUFPOOL");
 285         if (ts_params->large_mbuf_pool == NULL) {
 286                 /* Not already created so create */
 287                 ts_params->large_mbuf_pool = rte_pktmbuf_pool_create(
 288                                 "CRYPTO_LARGE_MBUFPOOL",
 289                                 1, 0, 0, UINT16_MAX,
 290                                 rte_socket_id());
 291                 if (ts_params->large_mbuf_pool == NULL) {
 292                         RTE_LOG(ERR, USER1,
 293                                 "Can't create CRYPTO_LARGE_MBUFPOOL\n");
 294                         return TEST_FAILED;
 295                 }
 296         }
 297
 298         ts_params->op_mpool = rte_crypto_op_pool_create(
 299                         "MBUF_CRYPTO_SYM_OP_POOL",
 300                         RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 301                         NUM_MBUFS, MBUF_CACHE_SIZE,
 302                         DEFAULT_NUM_XFORMS *
 303                         sizeof(struct rte_crypto_sym_xform) +
 304                         MAXIMUM_IV_LENGTH,
 305                         rte_socket_id());
 306         if (ts_params->op_mpool == NULL) {
 307                 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
 308                 return TEST_FAILED;
 309         }
 310
 311         /* Create an AESNI MB device if required */
 312         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 313                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD))) {
 314                 nb_devs = rte_cryptodev_device_count_by_driver(
 315                                 rte_cryptodev_driver_id_get(
 316                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)));
 317                 if (nb_devs < 1) {
 318                         ret = rte_vdev_init(
 319                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL);
 320
 321                         TEST_ASSERT(ret == 0,
 322                                 "Failed to create instance of"
 323                                 " pmd : %s",
 324                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
 325                 }
 326         }
 327
 328         /* Create an AESNI GCM device if required */
 329         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 330                         RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD))) {
 331                 nb_devs = rte_cryptodev_device_count_by_driver(
 332                                 rte_cryptodev_driver_id_get(
 333                                 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD)));
 334                 if (nb_devs < 1) {
 335                         TEST_ASSERT_SUCCESS(rte_vdev_init(
 336                                 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD), NULL),
 337                                 "Failed to create instance of"
 338                                 " pmd : %s",
 339                                 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
 340                 }
 341         }
 342
 343         /* Create a SNOW 3G device if required */
 344         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 345                         RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD))) {
 346                 nb_devs = rte_cryptodev_device_count_by_driver(
 347                                 rte_cryptodev_driver_id_get(
 348                                 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD)));
 349                 if (nb_devs < 1) {
 350                         TEST_ASSERT_SUCCESS(rte_vdev_init(
 351                                 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD), NULL),
 352                                 "Failed to create instance of"
 353                                 " pmd : %s",
 354                                 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
 355                 }
 356         }
 357
 358         /* Create a KASUMI device if required */
 359         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 360                         RTE_STR(CRYPTODEV_NAME_KASUMI_PMD))) {
 361                 nb_devs = rte_cryptodev_device_count_by_driver(
 362                                 rte_cryptodev_driver_id_get(
 363                                 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD)));
 364                 if (nb_devs < 1) {
 365                         TEST_ASSERT_SUCCESS(rte_vdev_init(
 366                                 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD), NULL),
 367                                 "Failed to create instance of"
 368                                 " pmd : %s",
 369                                 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
 370                 }
 371         }
 372
 373         /* Create a ZUC device if required */
 374         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 375                         RTE_STR(CRYPTODEV_NAME_ZUC_PMD))) {
 376                 nb_devs = rte_cryptodev_device_count_by_driver(
 377                                 rte_cryptodev_driver_id_get(
 378                                 RTE_STR(CRYPTODEV_NAME_ZUC_PMD)));
 379                 if (nb_devs < 1) {
 380                         TEST_ASSERT_SUCCESS(rte_vdev_init(
 381                                 RTE_STR(CRYPTODEV_NAME_ZUC_PMD), NULL),
 382                                 "Failed to create instance of"
 383                                 " pmd : %s",
 384                                 RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
 385                 }
 386         }
 387
 388         /* Create a NULL device if required */
 389         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 390                         RTE_STR(CRYPTODEV_NAME_NULL_PMD))) {
 391                 nb_devs = rte_cryptodev_device_count_by_driver(
 392                                 rte_cryptodev_driver_id_get(
 393                                 RTE_STR(CRYPTODEV_NAME_NULL_PMD)));
 394                 if (nb_devs < 1) {
 395                         ret = rte_vdev_init(
 396                                 RTE_STR(CRYPTODEV_NAME_NULL_PMD), NULL);
 397
 398                         TEST_ASSERT(ret == 0,
 399                                 "Failed to create instance of"
 400                                 " pmd : %s",
 401                                 RTE_STR(CRYPTODEV_NAME_NULL_PMD));
 402                 }
 403         }
 404
 405         /* Create an OPENSSL device if required */
 406         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 407                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD))) {
 408                 nb_devs = rte_cryptodev_device_count_by_driver(
 409                                 rte_cryptodev_driver_id_get(
 410                                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)));
 411                 if (nb_devs < 1) {
 412                         ret = rte_vdev_init(
 413                                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD),
 414                                 NULL);
 415
 416                         TEST_ASSERT(ret == 0, "Failed to create "
 417                                 "instance of pmd : %s",
 418                                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
 419                 }
 420         }
 421
 422         /* Create a ARMv8 device if required */
 423         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 424                         RTE_STR(CRYPTODEV_NAME_ARMV8_PMD))) {
 425                 nb_devs = rte_cryptodev_device_count_by_driver(
 426                                 rte_cryptodev_driver_id_get(
 427                                 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD)));
 428                 if (nb_devs < 1) {
 429                         ret = rte_vdev_init(
 430                                 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD),
 431                                 NULL);
 432
 433                         TEST_ASSERT(ret == 0, "Failed to create "
 434                                 "instance of pmd : %s",
 435                                 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
 436                 }
 437         }
 438
 439         /* Create a MVSAM device if required */
 440         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 441                         RTE_STR(CRYPTODEV_NAME_MVSAM_PMD))) {
 442                 nb_devs = rte_cryptodev_device_count_by_driver(
 443                                 rte_cryptodev_driver_id_get(
 444                                 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)));
 445                 if (nb_devs < 1) {
 446                         ret = rte_vdev_init(
 447                                 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD),
 448                                 NULL);
 449
 450                         TEST_ASSERT(ret == 0, "Failed to create "
 451                                 "instance of pmd : %s",
 452                                 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
 453                 }
 454         }
 455
 456         /* Create an CCP device if required */
 457         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 458                         RTE_STR(CRYPTODEV_NAME_CCP_PMD))) {
 459                 nb_devs = rte_cryptodev_device_count_by_driver(
 460                                 rte_cryptodev_driver_id_get(
 461                                 RTE_STR(CRYPTODEV_NAME_CCP_PMD)));
 462                 if (nb_devs < 1) {
 463                         ret = rte_vdev_init(
 464                                 RTE_STR(CRYPTODEV_NAME_CCP_PMD),
 465                                 NULL);
 466
 467                         TEST_ASSERT(ret == 0, "Failed to create "
 468                                 "instance of pmd : %s",
 469                                 RTE_STR(CRYPTODEV_NAME_CCP_PMD));
 470                 }
 471         }
 472
 473 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
 474         char vdev_args[VDEV_ARGS_SIZE] = {""};
 475         char temp_str[VDEV_ARGS_SIZE] = {"mode=multi-core,"
 476                 "ordering=enable,name=cryptodev_test_scheduler,corelist="};
 477         uint16_t slave_core_count = 0;
 478         uint16_t socket_id = 0;
 479
 480         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 481                         RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD))) {
 482
 483                 /* Identify the Slave Cores
 484                  * Use 2 slave cores for the device args
 485                  */
 486                 RTE_LCORE_FOREACH_SLAVE(i) {
 487                         if (slave_core_count > 1)
 488                                 break;
 489                         snprintf(vdev_args, sizeof(vdev_args),
 490                                         "%s%d", temp_str, i);
 491                         strcpy(temp_str, vdev_args);
 492                         strlcat(temp_str, ";", sizeof(temp_str));
 493                         slave_core_count++;
 494                         socket_id = rte_lcore_to_socket_id(i);
 495                 }
 496                 if (slave_core_count != 2) {
 497                         RTE_LOG(ERR, USER1,
 498                                 "Cryptodev scheduler test require at least "
 499                                 "two slave cores to run. "
 500                                 "Please use the correct coremask.\n");
 501                         return TEST_FAILED;
 502                 }
 503                 strcpy(temp_str, vdev_args);
 504                 snprintf(vdev_args, sizeof(vdev_args), "%s,socket_id=%d",
 505                                 temp_str, socket_id);
 506                 RTE_LOG(DEBUG, USER1, "vdev_args: %s\n", vdev_args);
 507                 nb_devs = rte_cryptodev_device_count_by_driver(
 508                                 rte_cryptodev_driver_id_get(
 509                                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)));
 510                 if (nb_devs < 1) {
 511                         ret = rte_vdev_init(
 512                                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),
 513                                         vdev_args);
 514                         TEST_ASSERT(ret == 0,
 515                                 "Failed to create instance %u of"
 516                                 " pmd : %s",
 517                                 i, RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
 518                 }
 519         }
 520 #endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
 521
 522         nb_devs = rte_cryptodev_count();
 523         if (nb_devs < 1) {
 524                 RTE_LOG(WARNING, USER1, "No crypto devices found?\n");
 525                 return TEST_SKIPPED;
 526         }
 527
 528         /* Create list of valid crypto devs */
 529         for (i = 0; i < nb_devs; i++) {
 530                 rte_cryptodev_info_get(i, &info);
 531                 if (info.driver_id == gbl_driver_id)
 532                         ts_params->valid_devs[ts_params->valid_dev_count++] = i;
 533         }
 534
 535         if (ts_params->valid_dev_count < 1)
 536                 return TEST_FAILED;
 537
 538         /* Set up all the qps on the first of the valid devices found */
 539
 540         dev_id = ts_params->valid_devs[0];
 541
 542         rte_cryptodev_info_get(dev_id, &info);
 543
 544         ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
 545         ts_params->conf.socket_id = SOCKET_ID_ANY;
 546         ts_params->conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY;
 547
 548         unsigned int session_size =
 549                 rte_cryptodev_sym_get_private_session_size(dev_id);
 550
 551         /*
 552          * Create mempool with maximum number of sessions * 2,
 553          * to include the session headers
 554          */
 555         if (info.sym.max_nb_sessions != 0 &&
 556                         info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
 557                 RTE_LOG(ERR, USER1, "Device does not support "
 558                                 "at least %u sessions\n",
 559                                 MAX_NB_SESSIONS);
 560                 return TEST_FAILED;
 561         }
 562
 563         ts_params->session_mpool = rte_cryptodev_sym_session_pool_create(
 564                         "test_sess_mp", MAX_NB_SESSIONS, 0, 0, 0,
 565                         SOCKET_ID_ANY);
 566         TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
 567                         "session mempool allocation failed");
 568
 569         ts_params->session_priv_mpool = rte_mempool_create(
 570                         "test_sess_mp_priv",
 571                         MAX_NB_SESSIONS,
 572                         session_size,
 573                         0, 0, NULL, NULL, NULL,
 574                         NULL, SOCKET_ID_ANY,
 575                         0);
 576         TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
 577                         "session mempool allocation failed");
 578
 579
 580
 581         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id,
 582                         &ts_params->conf),
 583                         "Failed to configure cryptodev %u with %u qps",
 584                         dev_id, ts_params->conf.nb_queue_pairs);
 585
 586         ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
 587         ts_params->qp_conf.mp_session = ts_params->session_mpool;
 588         ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
 589
 590         for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) {
 591                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 592                         dev_id, qp_id, &ts_params->qp_conf,
 593                         rte_cryptodev_socket_id(dev_id)),
 594                         "Failed to setup queue pair %u on cryptodev %u",
 595                         qp_id, dev_id);
 596         }
 597
 598         return TEST_SUCCESS;
 599 }
 600
 601 static void
 602 testsuite_teardown(void)
 603 {
 604         struct crypto_testsuite_params *ts_params = &testsuite_params;
 605
 606         if (ts_params->mbuf_pool != NULL) {
 607                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
 608                 rte_mempool_avail_count(ts_params->mbuf_pool));
 609         }
 610
 611         if (ts_params->op_mpool != NULL) {
 612                 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n",
 613                 rte_mempool_avail_count(ts_params->op_mpool));
 614         }
 615
 616         /* Free session mempools */
 617         if (ts_params->session_priv_mpool != NULL) {
 618                 rte_mempool_free(ts_params->session_priv_mpool);
 619                 ts_params->session_priv_mpool = NULL;
 620         }
 621
 622         if (ts_params->session_mpool != NULL) {
 623                 rte_mempool_free(ts_params->session_mpool);
 624                 ts_params->session_mpool = NULL;
 625         }
 626 }
 627
 628 static int
 629 ut_setup(void)
 630 {
 631         struct crypto_testsuite_params *ts_params = &testsuite_params;
 632         struct crypto_unittest_params *ut_params = &unittest_params;
 633
 634         uint16_t qp_id;
 635
 636         /* Clear unit test parameters before running test */
 637         memset(ut_params, 0, sizeof(*ut_params));
 638
 639         /* Reconfigure device to default parameters */
 640         ts_params->conf.socket_id = SOCKET_ID_ANY;
 641         ts_params->conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY;
 642         ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
 643         ts_params->qp_conf.mp_session = ts_params->session_mpool;
 644         ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
 645
 646         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 647                         &ts_params->conf),
 648                         "Failed to configure cryptodev %u",
 649                         ts_params->valid_devs[0]);
 650
 651         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
 652                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 653                         ts_params->valid_devs[0], qp_id,
 654                         &ts_params->qp_conf,
 655                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
 656                         "Failed to setup queue pair %u on cryptodev %u",
 657                         qp_id, ts_params->valid_devs[0]);
 658         }
 659
 660
 661         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
 662
 663         /* Start the device */
 664         TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
 665                         "Failed to start cryptodev %u",
 666                         ts_params->valid_devs[0]);
 667
 668         return TEST_SUCCESS;
 669 }
 670
 671 static void
 672 ut_teardown(void)
 673 {
 674         struct crypto_testsuite_params *ts_params = &testsuite_params;
 675         struct crypto_unittest_params *ut_params = &unittest_params;
 676         struct rte_cryptodev_stats stats;
 677
 678         /* free crypto session structure */
 679 #ifdef RTE_LIBRTE_SECURITY
 680         if (ut_params->type == RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL) {
 681                 if (ut_params->sec_session) {
 682                         rte_security_session_destroy(rte_cryptodev_get_sec_ctx
 683                                                 (ts_params->valid_devs[0]),
 684                                                 ut_params->sec_session);
 685                         ut_params->sec_session = NULL;
 686                 }
 687         } else
 688 #endif
 689         {
 690                 if (ut_params->sess) {
 691                         rte_cryptodev_sym_session_clear(
 692                                         ts_params->valid_devs[0],
 693                                         ut_params->sess);
 694                         rte_cryptodev_sym_session_free(ut_params->sess);
 695                         ut_params->sess = NULL;
 696                 }
 697         }
 698
 699         /* free crypto operation structure */
 700         if (ut_params->op)
 701                 rte_crypto_op_free(ut_params->op);
 702
 703         /*
 704          * free mbuf - both obuf and ibuf are usually the same,
 705          * so check if they point at the same address is necessary,
 706          * to avoid freeing the mbuf twice.
 707          */
 708         if (ut_params->obuf) {
 709                 rte_pktmbuf_free(ut_params->obuf);
 710                 if (ut_params->ibuf == ut_params->obuf)
 711                         ut_params->ibuf = 0;
 712                 ut_params->obuf = 0;
 713         }
 714         if (ut_params->ibuf) {
 715                 rte_pktmbuf_free(ut_params->ibuf);
 716                 ut_params->ibuf = 0;
 717         }
 718
 719         if (ts_params->mbuf_pool != NULL)
 720                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
 721                         rte_mempool_avail_count(ts_params->mbuf_pool));
 722
 723         rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats);
 724
 725         /* Stop the device */
 726         rte_cryptodev_stop(ts_params->valid_devs[0]);
 727 }
 728
 729 static int
 730 test_device_configure_invalid_dev_id(void)
 731 {
 732         struct crypto_testsuite_params *ts_params = &testsuite_params;
 733         uint16_t dev_id, num_devs = 0;
 734
 735         TEST_ASSERT((num_devs = rte_cryptodev_count()) >= 1,
 736                         "Need at least %d devices for test", 1);
 737
 738         /* valid dev_id values */
 739         dev_id = ts_params->valid_devs[ts_params->valid_dev_count - 1];
 740
 741         /* Stop the device in case it's started so it can be configured */
 742         rte_cryptodev_stop(dev_id);
 743
 744         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf),
 745                         "Failed test for rte_cryptodev_configure: "
 746                         "invalid dev_num %u", dev_id);
 747
 748         /* invalid dev_id values */
 749         dev_id = num_devs;
 750
 751         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
 752                         "Failed test for rte_cryptodev_configure: "
 753                         "invalid dev_num %u", dev_id);
 754
 755         dev_id = 0xff;
 756
 757         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
 758                         "Failed test for rte_cryptodev_configure:"
 759                         "invalid dev_num %u", dev_id);
 760
 761         return TEST_SUCCESS;
 762 }
 763
 764 static int
 765 test_device_configure_invalid_queue_pair_ids(void)
 766 {
 767         struct crypto_testsuite_params *ts_params = &testsuite_params;
 768         uint16_t orig_nb_qps = ts_params->conf.nb_queue_pairs;
 769
 770         /* Stop the device in case it's started so it can be configured */
 771         rte_cryptodev_stop(ts_params->valid_devs[0]);
 772
 773         /* valid - max value queue pairs */
 774         ts_params->conf.nb_queue_pairs = orig_nb_qps;
 775
 776         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 777                         &ts_params->conf),
 778                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
 779                         ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
 780
 781         /* valid - one queue pairs */
 782         ts_params->conf.nb_queue_pairs = 1;
 783
 784         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 785                         &ts_params->conf),
 786                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
 787                         ts_params->valid_devs[0],
 788                         ts_params->conf.nb_queue_pairs);
 789
 790
 791         /* invalid - zero queue pairs */
 792         ts_params->conf.nb_queue_pairs = 0;
 793
 794         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
 795                         &ts_params->conf),
 796                         "Failed test for rte_cryptodev_configure, dev_id %u,"
 797                         " invalid qps: %u",
 798                         ts_params->valid_devs[0],
 799                         ts_params->conf.nb_queue_pairs);
 800
 801
 802         /* invalid - max value supported by field queue pairs */
 803         ts_params->conf.nb_queue_pairs = UINT16_MAX;
 804
 805         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
 806                         &ts_params->conf),
 807                         "Failed test for rte_cryptodev_configure, dev_id %u,"
 808                         " invalid qps: %u",
 809                         ts_params->valid_devs[0],
 810                         ts_params->conf.nb_queue_pairs);
 811
 812
 813         /* invalid - max value + 1 queue pairs */
 814         ts_params->conf.nb_queue_pairs = orig_nb_qps + 1;
 815
 816         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
 817                         &ts_params->conf),
 818                         "Failed test for rte_cryptodev_configure, dev_id %u,"
 819                         " invalid qps: %u",
 820                         ts_params->valid_devs[0],
 821                         ts_params->conf.nb_queue_pairs);
 822
 823         /* revert to original testsuite value */
 824         ts_params->conf.nb_queue_pairs = orig_nb_qps;
 825
 826         return TEST_SUCCESS;
 827 }
 828
 829 static int
 830 test_queue_pair_descriptor_setup(void)
 831 {
 832         struct crypto_testsuite_params *ts_params = &testsuite_params;
 833         struct rte_cryptodev_qp_conf qp_conf = {
 834                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
 835         };
 836         uint16_t qp_id;
 837
 838         /* Stop the device in case it's started so it can be configured */
 839         rte_cryptodev_stop(ts_params->valid_devs[0]);
 840
 841         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 842                         &ts_params->conf),
 843                         "Failed to configure cryptodev %u",
 844                         ts_params->valid_devs[0]);
 845
 846         /*
 847          * Test various ring sizes on this device. memzones can't be
 848          * freed so are re-used if ring is released and re-created.
 849          */
 850         qp_conf.nb_descriptors = MIN_NUM_OPS_INFLIGHT; /* min size*/
 851         qp_conf.mp_session = ts_params->session_mpool;
 852         qp_conf.mp_session_private = ts_params->session_priv_mpool;
 853
 854         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 855                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 856                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 857                                 rte_cryptodev_socket_id(
 858                                                 ts_params->valid_devs[0])),
 859                                 "Failed test for "
 860                                 "rte_cryptodev_queue_pair_setup: num_inflights "
 861                                 "%u on qp %u on cryptodev %u",
 862                                 qp_conf.nb_descriptors, qp_id,
 863                                 ts_params->valid_devs[0]);
 864         }
 865
 866         qp_conf.nb_descriptors = (uint32_t)(MAX_NUM_OPS_INFLIGHT / 2);
 867
 868         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 869                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 870                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 871                                 rte_cryptodev_socket_id(
 872                                                 ts_params->valid_devs[0])),
 873                                 "Failed test for"
 874                                 " rte_cryptodev_queue_pair_setup: num_inflights"
 875                                 " %u on qp %u on cryptodev %u",
 876                                 qp_conf.nb_descriptors, qp_id,
 877                                 ts_params->valid_devs[0]);
 878         }
 879
 880         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; /* valid */
 881
 882         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 883                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 884                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 885                                 rte_cryptodev_socket_id(
 886                                                 ts_params->valid_devs[0])),
 887                                 "Failed test for "
 888                                 "rte_cryptodev_queue_pair_setup: num_inflights"
 889                                 " %u on qp %u on cryptodev %u",
 890                                 qp_conf.nb_descriptors, qp_id,
 891                                 ts_params->valid_devs[0]);
 892         }
 893
 894         /* invalid number of descriptors - max supported + 2 */
 895         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT + 2;
 896
 897         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 898                 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 899                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 900                                 rte_cryptodev_socket_id(
 901                                                 ts_params->valid_devs[0])),
 902                                 "Unexpectedly passed test for "
 903                                 "rte_cryptodev_queue_pair_setup:"
 904                                 "num_inflights %u on qp %u on cryptodev %u",
 905                                 qp_conf.nb_descriptors, qp_id,
 906                                 ts_params->valid_devs[0]);
 907         }
 908
 909         /* invalid number of descriptors - max value of parameter */
 910         qp_conf.nb_descriptors = UINT32_MAX-1;
 911
 912         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 913                 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 914                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 915                                 rte_cryptodev_socket_id(
 916                                                 ts_params->valid_devs[0])),
 917                                 "Unexpectedly passed test for "
 918                                 "rte_cryptodev_queue_pair_setup:"
 919                                 "num_inflights %u on qp %u on cryptodev %u",
 920                                 qp_conf.nb_descriptors, qp_id,
 921                                 ts_params->valid_devs[0]);
 922         }
 923
 924         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
 925
 926         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 927                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 928                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 929                                 rte_cryptodev_socket_id(
 930                                                 ts_params->valid_devs[0])),
 931                                 "Failed test for"
 932                                 " rte_cryptodev_queue_pair_setup:"
 933                                 "num_inflights %u on qp %u on cryptodev %u",
 934                                 qp_conf.nb_descriptors, qp_id,
 935                                 ts_params->valid_devs[0]);
 936         }
 937
 938         /* invalid number of descriptors - max supported + 1 */
 939         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT + 1;
 940
 941         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 942                 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 943                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 944                                 rte_cryptodev_socket_id(
 945                                                 ts_params->valid_devs[0])),
 946                                 "Unexpectedly passed test for "
 947                                 "rte_cryptodev_queue_pair_setup:"
 948                                 "num_inflights %u on qp %u on cryptodev %u",
 949                                 qp_conf.nb_descriptors, qp_id,
 950                                 ts_params->valid_devs[0]);
 951         }
 952
 953         /* test invalid queue pair id */
 954         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;      /*valid */
 955
 956         qp_id = ts_params->conf.nb_queue_pairs;         /*invalid */
 957
 958         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 959                         ts_params->valid_devs[0],
 960                         qp_id, &qp_conf,
 961                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
 962                         "Failed test for rte_cryptodev_queue_pair_setup:"
 963                         "invalid qp %u on cryptodev %u",
 964                         qp_id, ts_params->valid_devs[0]);
 965
 966         qp_id = 0xffff; /*invalid*/
 967
 968         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 969                         ts_params->valid_devs[0],
 970                         qp_id, &qp_conf,
 971                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
 972                         "Failed test for rte_cryptodev_queue_pair_setup:"
 973                         "invalid qp %u on cryptodev %u",
 974                         qp_id, ts_params->valid_devs[0]);
 975
 976         return TEST_SUCCESS;
 977 }
 978
 979 /* ***** Plaintext data for tests ***** */
 980
 981 const char catch_22_quote_1[] =
 982                 "There was only one catch and that was Catch-22, which "
 983                 "specified that a concern for one's safety in the face of "
 984                 "dangers that were real and immediate was the process of a "
 985                 "rational mind. Orr was crazy and could be grounded. All he "
 986                 "had to do was ask; and as soon as he did, he would no longer "
 987                 "be crazy and would have to fly more missions. Orr would be "
 988                 "crazy to fly more missions and sane if he didn't, but if he "
 989                 "was sane he had to fly them. If he flew them he was crazy "
 990                 "and didn't have to; but if he didn't want to he was sane and "
 991                 "had to. Yossarian was moved very deeply by the absolute "
 992                 "simplicity of this clause of Catch-22 and let out a "
 993                 "respectful whistle. \"That's some catch, that Catch-22\", he "
 994                 "observed. \"It's the best there is,\" Doc Daneeka agreed.";
 995
 996 const char catch_22_quote[] =
 997                 "What a lousy earth! He wondered how many people were "
 998                 "destitute that same night even in his own prosperous country, "
 999                 "how many homes were shanties, how many husbands were drunk "
1000                 "and wives socked, and how many children were bullied, abused, "
1001                 "or abandoned. How many families hungered for food they could "
1002                 "not afford to buy? How many hearts were broken? How many "
1003                 "suicides would take place that same night, how many people "
1004                 "would go insane? How many cockroaches and landlords would "
1005                 "triumph? How many winners were losers, successes failures, "
1006                 "and rich men poor men? How many wise guys were stupid? How "
1007                 "many happy endings were unhappy endings? How many honest men "
1008                 "were liars, brave men cowards, loyal men traitors, how many "
1009                 "sainted men were corrupt, how many people in positions of "
1010                 "trust had sold their souls to bodyguards, how many had never "
1011                 "had souls? How many straight-and-narrow paths were crooked "
1012                 "paths? How many best families were worst families and how "
1013                 "many good people were bad people? When you added them all up "
1014                 "and then subtracted, you might be left with only the children, "
1015                 "and perhaps with Albert Einstein and an old violinist or "
1016                 "sculptor somewhere.";
1017
1018 #define QUOTE_480_BYTES         (480)
1019 #define QUOTE_512_BYTES         (512)
1020 #define QUOTE_768_BYTES         (768)
1021 #define QUOTE_1024_BYTES        (1024)
1022
1023
1024
1025 /* ***** SHA1 Hash Tests ***** */
1026
1027 #define HMAC_KEY_LENGTH_SHA1    (DIGEST_BYTE_LENGTH_SHA1)
1028
1029 static uint8_t hmac_sha1_key[] = {
1030         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
1031         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
1032         0xDE, 0xF4, 0xDE, 0xAD };
1033
1034 /* ***** SHA224 Hash Tests ***** */
1035
1036 #define HMAC_KEY_LENGTH_SHA224  (DIGEST_BYTE_LENGTH_SHA224)
1037
1038
1039 /* ***** AES-CBC Cipher Tests ***** */
1040
1041 #define CIPHER_KEY_LENGTH_AES_CBC       (16)
1042 #define CIPHER_IV_LENGTH_AES_CBC        (CIPHER_KEY_LENGTH_AES_CBC)
1043
1044 static uint8_t aes_cbc_key[] = {
1045         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
1046         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A };
1047
1048 static uint8_t aes_cbc_iv[] = {
1049         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1050         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
1051
1052
1053 /* ***** AES-CBC / HMAC-SHA1 Hash Tests ***** */
1054
1055 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_ciphertext[] = {
1056         0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31,
1057         0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76,
1058         0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E,
1059         0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A,
1060         0x3F, 0x6B, 0x5D, 0xDF, 0x52, 0x85, 0x5F, 0x8E,
1061         0x42, 0x3C, 0xFB, 0xE9, 0x1A, 0x24, 0xD6, 0x08,
1062         0xDD, 0xFD, 0x16, 0xFB, 0xE9, 0x55, 0xEF, 0xF0,
1063         0xA0, 0x8D, 0x13, 0xAB, 0x81, 0xC6, 0x90, 0x01,
1064         0xB5, 0x18, 0x84, 0xB3, 0xF6, 0xE6, 0x11, 0x57,
1065         0xD6, 0x71, 0xC6, 0x3C, 0x3F, 0x2F, 0x33, 0xEE,
1066         0x24, 0x42, 0x6E, 0xAC, 0x0B, 0xCA, 0xEC, 0xF9,
1067         0x84, 0xF8, 0x22, 0xAA, 0x60, 0xF0, 0x32, 0xA9,
1068         0x75, 0x75, 0x3B, 0xCB, 0x70, 0x21, 0x0A, 0x8D,
1069         0x0F, 0xE0, 0xC4, 0x78, 0x2B, 0xF8, 0x97, 0xE3,
1070         0xE4, 0x26, 0x4B, 0x29, 0xDA, 0x88, 0xCD, 0x46,
1071         0xEC, 0xAA, 0xF9, 0x7F, 0xF1, 0x15, 0xEA, 0xC3,
1072         0x87, 0xE6, 0x31, 0xF2, 0xCF, 0xDE, 0x4D, 0x80,
1073         0x70, 0x91, 0x7E, 0x0C, 0xF7, 0x26, 0x3A, 0x92,
1074         0x4F, 0x18, 0x83, 0xC0, 0x8F, 0x59, 0x01, 0xA5,
1075         0x88, 0xD1, 0xDB, 0x26, 0x71, 0x27, 0x16, 0xF5,
1076         0xEE, 0x10, 0x82, 0xAC, 0x68, 0x26, 0x9B, 0xE2,
1077         0x6D, 0xD8, 0x9A, 0x80, 0xDF, 0x04, 0x31, 0xD5,
1078         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1079         0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
1080         0x73, 0x02, 0x42, 0xC9, 0x23, 0x18, 0x8E, 0xB4,
1081         0x6F, 0xB4, 0xA3, 0x54, 0x6E, 0x88, 0x3B, 0x62,
1082         0x7C, 0x02, 0x8D, 0x4C, 0x9F, 0xC8, 0x45, 0xF4,
1083         0xC9, 0xDE, 0x4F, 0xEB, 0x22, 0x83, 0x1B, 0xE4,
1084         0x49, 0x37, 0xE4, 0xAD, 0xE7, 0xCD, 0x21, 0x54,
1085         0xBC, 0x1C, 0xC2, 0x04, 0x97, 0xB4, 0x10, 0x61,
1086         0xF0, 0xE4, 0xEF, 0x27, 0x63, 0x3A, 0xDA, 0x91,
1087         0x41, 0x25, 0x62, 0x1C, 0x5C, 0xB6, 0x38, 0x4A,
1088         0x88, 0x71, 0x59, 0x5A, 0x8D, 0xA0, 0x09, 0xAF,
1089         0x72, 0x94, 0xD7, 0x79, 0x5C, 0x60, 0x7C, 0x8F,
1090         0x4C, 0xF5, 0xD9, 0xA1, 0x39, 0x6D, 0x81, 0x28,
1091         0xEF, 0x13, 0x28, 0xDF, 0xF5, 0x3E, 0xF7, 0x8E,
1092         0x09, 0x9C, 0x78, 0x18, 0x79, 0xB8, 0x68, 0xD7,
1093         0xA8, 0x29, 0x62, 0xAD, 0xDE, 0xE1, 0x61, 0x76,
1094         0x1B, 0x05, 0x16, 0xCD, 0xBF, 0x02, 0x8E, 0xA6,
1095         0x43, 0x6E, 0x92, 0x55, 0x4F, 0x60, 0x9C, 0x03,
1096         0xB8, 0x4F, 0xA3, 0x02, 0xAC, 0xA8, 0xA7, 0x0C,
1097         0x1E, 0xB5, 0x6B, 0xF8, 0xC8, 0x4D, 0xDE, 0xD2,
1098         0xB0, 0x29, 0x6E, 0x40, 0xE6, 0xD6, 0xC9, 0xE6,
1099         0xB9, 0x0F, 0xB6, 0x63, 0xF5, 0xAA, 0x2B, 0x96,
1100         0xA7, 0x16, 0xAC, 0x4E, 0x0A, 0x33, 0x1C, 0xA6,
1101         0xE6, 0xBD, 0x8A, 0xCF, 0x40, 0xA9, 0xB2, 0xFA,
1102         0x63, 0x27, 0xFD, 0x9B, 0xD9, 0xFC, 0xD5, 0x87,
1103         0x8D, 0x4C, 0xB6, 0xA4, 0xCB, 0xE7, 0x74, 0x55,
1104         0xF4, 0xFB, 0x41, 0x25, 0xB5, 0x4B, 0x0A, 0x1B,
1105         0xB1, 0xD6, 0xB7, 0xD9, 0x47, 0x2A, 0xC3, 0x98,
1106         0x6A, 0xC4, 0x03, 0x73, 0x1F, 0x93, 0x6E, 0x53,
1107         0x19, 0x25, 0x64, 0x15, 0x83, 0xF9, 0x73, 0x2A,
1108         0x74, 0xB4, 0x93, 0x69, 0xC4, 0x72, 0xFC, 0x26,
1109         0xA2, 0x9F, 0x43, 0x45, 0xDD, 0xB9, 0xEF, 0x36,
1110         0xC8, 0x3A, 0xCD, 0x99, 0x9B, 0x54, 0x1A, 0x36,
1111         0xC1, 0x59, 0xF8, 0x98, 0xA8, 0xCC, 0x28, 0x0D,
1112         0x73, 0x4C, 0xEE, 0x98, 0xCB, 0x7C, 0x58, 0x7E,
1113         0x20, 0x75, 0x1E, 0xB7, 0xC9, 0xF8, 0xF2, 0x0E,
1114         0x63, 0x9E, 0x05, 0x78, 0x1A, 0xB6, 0xA8, 0x7A,
1115         0xF9, 0x98, 0x6A, 0xA6, 0x46, 0x84, 0x2E, 0xF6,
1116         0x4B, 0xDC, 0x9B, 0x8F, 0x9B, 0x8F, 0xEE, 0xB4,
1117         0xAA, 0x3F, 0xEE, 0xC0, 0x37, 0x27, 0x76, 0xC7,
1118         0x95, 0xBB, 0x26, 0x74, 0x69, 0x12, 0x7F, 0xF1,
1119         0xBB, 0xFF, 0xAE, 0xB5, 0x99, 0x6E, 0xCB, 0x0C
1120 };
1121
1122 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest[] = {
1123         0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60,
1124         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1125         0x18, 0x8c, 0x1d, 0x32
1126 };
1127
1128
1129 /* Multisession Vector context Test */
1130 /*Begin Session 0 */
1131 static uint8_t ms_aes_cbc_key0[] = {
1132         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1133         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1134 };
1135
1136 static uint8_t ms_aes_cbc_iv0[] = {
1137         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1138         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1139 };
1140
1141 static const uint8_t ms_aes_cbc_cipher0[] = {
1142                 0x3C, 0xE4, 0xEE, 0x42, 0xB6, 0x9B, 0xC3, 0x38,
1143                 0x5F, 0xAD, 0x54, 0xDC, 0xA8, 0x32, 0x81, 0xDC,
1144                 0x7A, 0x6F, 0x85, 0x58, 0x07, 0x35, 0xED, 0xEB,
1145                 0xAD, 0x79, 0x79, 0x96, 0xD3, 0x0E, 0xA6, 0xD9,
1146                 0xAA, 0x86, 0xA4, 0x8F, 0xB5, 0xD6, 0x6E, 0x6D,
1147                 0x0C, 0x91, 0x2F, 0xC4, 0x67, 0x98, 0x0E, 0xC4,
1148                 0x8D, 0x83, 0x68, 0x69, 0xC4, 0xD3, 0x94, 0x34,
1149                 0xC4, 0x5D, 0x60, 0x55, 0x22, 0x87, 0x8F, 0x6F,
1150                 0x17, 0x8E, 0x75, 0xE4, 0x02, 0xF5, 0x1B, 0x99,
1151                 0xC8, 0x39, 0xA9, 0xAB, 0x23, 0x91, 0x12, 0xED,
1152                 0x08, 0xE7, 0xD9, 0x25, 0x89, 0x24, 0x4F, 0x8D,
1153                 0x68, 0xF3, 0x10, 0x39, 0x0A, 0xEE, 0x45, 0x24,
1154                 0xDF, 0x7A, 0x9D, 0x00, 0x25, 0xE5, 0x35, 0x71,
1155                 0x4E, 0x40, 0x59, 0x6F, 0x0A, 0x13, 0xB3, 0x72,
1156                 0x1D, 0x98, 0x63, 0x94, 0x89, 0xA5, 0x39, 0x8E,
1157                 0xD3, 0x9C, 0x8A, 0x7F, 0x71, 0x2F, 0xC7, 0xCD,
1158                 0x81, 0x05, 0xDC, 0xC0, 0x8D, 0xCE, 0x6D, 0x18,
1159                 0x30, 0xC4, 0x72, 0x51, 0xF0, 0x27, 0xC8, 0xF6,
1160                 0x60, 0x5B, 0x7C, 0xB2, 0xE3, 0x49, 0x0C, 0x29,
1161                 0xC6, 0x9F, 0x39, 0x57, 0x80, 0x55, 0x24, 0x2C,
1162                 0x9B, 0x0F, 0x5A, 0xB3, 0x89, 0x55, 0x31, 0x96,
1163                 0x0D, 0xCD, 0xF6, 0x51, 0x03, 0x2D, 0x89, 0x26,
1164                 0x74, 0x44, 0xD6, 0xE8, 0xDC, 0xEA, 0x44, 0x55,
1165                 0x64, 0x71, 0x9C, 0x9F, 0x5D, 0xBA, 0x39, 0x46,
1166                 0xA8, 0x17, 0xA1, 0x9C, 0x52, 0x9D, 0xBC, 0x6B,
1167                 0x4A, 0x98, 0xE6, 0xEA, 0x33, 0xEC, 0x58, 0xB4,
1168                 0x43, 0xF0, 0x32, 0x45, 0xA4, 0xC1, 0x55, 0xB7,
1169                 0x5D, 0xB5, 0x59, 0xB2, 0xE3, 0x96, 0xFF, 0xA5,
1170                 0xAF, 0xE1, 0x86, 0x1B, 0x42, 0xE6, 0x3B, 0xA0,
1171                 0x90, 0x4A, 0xE8, 0x8C, 0x21, 0x7F, 0x36, 0x1E,
1172                 0x5B, 0x65, 0x25, 0xD1, 0xC1, 0x5A, 0xCA, 0x3D,
1173                 0x10, 0xED, 0x2D, 0x79, 0xD0, 0x0F, 0x58, 0x44,
1174                 0x69, 0x81, 0xF5, 0xD4, 0xC9, 0x0F, 0x90, 0x76,
1175                 0x1F, 0x54, 0xD2, 0xD5, 0x97, 0xCE, 0x2C, 0xE3,
1176                 0xEF, 0xF4, 0xB7, 0xC6, 0x3A, 0x87, 0x7F, 0x83,
1177                 0x2A, 0xAF, 0xCD, 0x90, 0x12, 0xA7, 0x7D, 0x85,
1178                 0x1D, 0x62, 0xD3, 0x85, 0x25, 0x05, 0xDB, 0x45,
1179                 0x92, 0xA3, 0xF6, 0xA2, 0xA8, 0x41, 0xE4, 0x25,
1180                 0x86, 0x87, 0x67, 0x24, 0xEC, 0x89, 0x23, 0x2A,
1181                 0x9B, 0x20, 0x4D, 0x93, 0xEE, 0xE2, 0x2E, 0xC1,
1182                 0x0B, 0x15, 0x33, 0xCF, 0x00, 0xD1, 0x1A, 0xDA,
1183                 0x93, 0xFD, 0x28, 0x21, 0x5B, 0xCF, 0xD1, 0xF3,
1184                 0x5A, 0x81, 0xBA, 0x82, 0x5E, 0x2F, 0x61, 0xB4,
1185                 0x05, 0x71, 0xB5, 0xF4, 0x39, 0x3C, 0x1F, 0x60,
1186                 0x00, 0x7A, 0xC4, 0xF8, 0x35, 0x20, 0x6C, 0x3A,
1187                 0xCC, 0x03, 0x8F, 0x7B, 0xA2, 0xB6, 0x65, 0x8A,
1188                 0xB6, 0x5F, 0xFD, 0x25, 0xD3, 0x5F, 0x92, 0xF9,
1189                 0xAE, 0x17, 0x9B, 0x5E, 0x6E, 0x9A, 0xE4, 0x55,
1190                 0x10, 0x25, 0x07, 0xA4, 0xAF, 0x21, 0x69, 0x13,
1191                 0xD8, 0xFA, 0x31, 0xED, 0xF7, 0xA7, 0xA7, 0x3B,
1192                 0xB8, 0x96, 0x8E, 0x10, 0x86, 0x74, 0xD8, 0xB1,
1193                 0x34, 0x9E, 0x9B, 0x6A, 0x26, 0xA8, 0xD4, 0xD0,
1194                 0xB5, 0xF6, 0xDE, 0xE7, 0xCA, 0x06, 0xDC, 0xA3,
1195                 0x6F, 0xEE, 0x6B, 0x1E, 0xB5, 0x30, 0x99, 0x23,
1196                 0xF9, 0x76, 0xF0, 0xA0, 0xCF, 0x3B, 0x94, 0x7B,
1197                 0x19, 0x8D, 0xA5, 0x0C, 0x18, 0xA6, 0x1D, 0x07,
1198                 0x89, 0xBE, 0x5B, 0x61, 0xE5, 0xF1, 0x42, 0xDB,
1199                 0xD4, 0x2E, 0x02, 0x1F, 0xCE, 0xEF, 0x92, 0xB1,
1200                 0x1B, 0x56, 0x50, 0xF2, 0x16, 0xE5, 0xE7, 0x4F,
1201                 0xFD, 0xBB, 0x3E, 0xD2, 0xFC, 0x3C, 0xC6, 0x0F,
1202                 0xF9, 0x12, 0x4E, 0xCB, 0x1E, 0x0C, 0x15, 0x84,
1203                 0x2A, 0x14, 0x8A, 0x02, 0xE4, 0x7E, 0x95, 0x5B,
1204                 0x86, 0xDB, 0x9B, 0x62, 0x5B, 0x19, 0xD2, 0x17,
1205                 0xFA, 0x13, 0xBB, 0x6B, 0x3F, 0x45, 0x9F, 0xBF
1206 };
1207
1208
1209 static  uint8_t ms_hmac_key0[] = {
1210                 0xFF, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1211                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1212                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1213                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1214                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1215                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1216                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1217                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1218 };
1219
1220 static const uint8_t ms_hmac_digest0[] = {
1221                 0x43, 0x52, 0xED, 0x34, 0xAB, 0x36, 0xB2, 0x51,
1222                 0xFB, 0xA3, 0xA6, 0x7C, 0x38, 0xFC, 0x42, 0x8F,
1223                 0x57, 0x64, 0xAB, 0x81, 0xA7, 0x89, 0xB7, 0x6C,
1224                 0xA0, 0xDC, 0xB9, 0x4D, 0xC4, 0x30, 0xF9, 0xD4,
1225                 0x10, 0x82, 0x55, 0xD0, 0xAB, 0x32, 0xFB, 0x56,
1226                 0x0D, 0xE4, 0x68, 0x3D, 0x76, 0xD0, 0x7B, 0xE4,
1227                 0xA6, 0x2C, 0x34, 0x9E, 0x8C, 0x41, 0xF8, 0x23,
1228                 0x28, 0x1B, 0x3A, 0x90, 0x26, 0x34, 0x47, 0x90
1229                 };
1230
1231 /* End Session 0 */
1232 /* Begin session 1 */
1233
1234 static  uint8_t ms_aes_cbc_key1[] = {
1235                 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1236                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1237 };
1238
1239 static  uint8_t ms_aes_cbc_iv1[] = {
1240         0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1241         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1242 };
1243
1244 static const uint8_t ms_aes_cbc_cipher1[] = {
1245                 0x5A, 0x7A, 0x67, 0x5D, 0xB8, 0xE1, 0xDC, 0x71,
1246                 0x39, 0xA8, 0x74, 0x93, 0x9C, 0x4C, 0xFE, 0x23,
1247                 0x61, 0xCD, 0xA4, 0xB3, 0xD9, 0xCE, 0x99, 0x09,
1248                 0x2A, 0x23, 0xF3, 0x29, 0xBF, 0x4C, 0xB4, 0x6A,
1249                 0x1B, 0x6B, 0x73, 0x4D, 0x48, 0x0C, 0xCF, 0x6C,
1250                 0x5E, 0x34, 0x9E, 0x7F, 0xBC, 0x8F, 0xCC, 0x8F,
1251                 0x75, 0x1D, 0x3D, 0x77, 0x10, 0x76, 0xC8, 0xB9,
1252                 0x99, 0x6F, 0xD6, 0x56, 0x75, 0xA9, 0xB2, 0x66,
1253                 0xC2, 0x24, 0x2B, 0x9C, 0xFE, 0x40, 0x8E, 0x43,
1254                 0x20, 0x97, 0x1B, 0xFA, 0xD0, 0xCF, 0x04, 0xAB,
1255                 0xBB, 0xF6, 0x5D, 0xF5, 0xA0, 0x19, 0x7C, 0x23,
1256                 0x5D, 0x80, 0x8C, 0x49, 0xF6, 0x76, 0x88, 0x29,
1257                 0x27, 0x4C, 0x59, 0x2B, 0x43, 0xA6, 0xB2, 0x26,
1258                 0x27, 0x78, 0xBE, 0x1B, 0xE1, 0x4F, 0x5A, 0x1F,
1259                 0xFC, 0x68, 0x08, 0xE7, 0xC4, 0xD1, 0x34, 0x68,
1260                 0xB7, 0x13, 0x14, 0x41, 0x62, 0x6B, 0x1F, 0x77,
1261                 0x0C, 0x68, 0x1D, 0x0D, 0xED, 0x89, 0xAA, 0xD8,
1262                 0x97, 0x02, 0xBA, 0x5E, 0xD4, 0x84, 0x25, 0x97,
1263                 0x03, 0xA5, 0xA6, 0x13, 0x66, 0x02, 0xF4, 0xC3,
1264                 0xF3, 0xD3, 0xCC, 0x95, 0xC3, 0x87, 0x46, 0x90,
1265                 0x1F, 0x6E, 0x14, 0xA8, 0x00, 0xF2, 0x6F, 0xD5,
1266                 0xA1, 0xAD, 0xD5, 0x40, 0xA2, 0x0F, 0x32, 0x7E,
1267                 0x99, 0xA3, 0xF5, 0x53, 0xC3, 0x26, 0xA1, 0x45,
1268                 0x01, 0x88, 0x57, 0x84, 0x3E, 0x7B, 0x4E, 0x0B,
1269                 0x3C, 0xB5, 0x3E, 0x9E, 0xE9, 0x78, 0x77, 0xC5,
1270                 0xC0, 0x89, 0xA8, 0xF8, 0xF1, 0xA5, 0x2D, 0x5D,
1271                 0xF9, 0xC6, 0xFB, 0xCB, 0x05, 0x23, 0xBD, 0x6E,
1272                 0x5E, 0x14, 0xC6, 0x57, 0x73, 0xCF, 0x98, 0xBD,
1273                 0x10, 0x8B, 0x18, 0xA6, 0x01, 0x5B, 0x13, 0xAE,
1274                 0x8E, 0xDE, 0x1F, 0xB5, 0xB7, 0x40, 0x6C, 0xC1,
1275                 0x1E, 0xA1, 0x19, 0x20, 0x9E, 0x95, 0xE0, 0x2F,
1276                 0x1C, 0xF5, 0xD9, 0xD0, 0x2B, 0x1E, 0x82, 0x25,
1277                 0x62, 0xB4, 0xEB, 0xA1, 0x1F, 0xCE, 0x44, 0xA1,
1278                 0xCB, 0x92, 0x01, 0x6B, 0xE4, 0x26, 0x23, 0xE3,
1279                 0xC5, 0x67, 0x35, 0x55, 0xDA, 0xE5, 0x27, 0xEE,
1280                 0x8D, 0x12, 0x84, 0xB7, 0xBA, 0xA7, 0x1C, 0xD6,
1281                 0x32, 0x3F, 0x67, 0xED, 0xFB, 0x5B, 0x8B, 0x52,
1282                 0x46, 0x8C, 0xF9, 0x69, 0xCD, 0xAE, 0x79, 0xAA,
1283                 0x37, 0x78, 0x49, 0xEB, 0xC6, 0x8E, 0x76, 0x63,
1284                 0x84, 0xFF, 0x9D, 0x22, 0x99, 0x51, 0xB7, 0x5E,
1285                 0x83, 0x4C, 0x8B, 0xDF, 0x5A, 0x07, 0xCC, 0xBA,
1286                 0x42, 0xA5, 0x98, 0xB6, 0x47, 0x0E, 0x66, 0xEB,
1287                 0x23, 0x0E, 0xBA, 0x44, 0xA8, 0xAA, 0x20, 0x71,
1288                 0x79, 0x9C, 0x77, 0x5F, 0xF5, 0xFE, 0xEC, 0xEF,
1289                 0xC6, 0x64, 0x3D, 0x84, 0xD0, 0x2B, 0xA7, 0x0A,
1290                 0xC3, 0x72, 0x5B, 0x9C, 0xFA, 0xA8, 0x87, 0x95,
1291                 0x94, 0x11, 0x38, 0xA7, 0x1E, 0x58, 0xE3, 0x73,
1292                 0xC6, 0xC9, 0xD1, 0x7B, 0x92, 0xDB, 0x0F, 0x49,
1293                 0x74, 0xC2, 0xA2, 0x0E, 0x35, 0x57, 0xAC, 0xDB,
1294                 0x9A, 0x1C, 0xCF, 0x5A, 0x32, 0x3E, 0x26, 0x9B,
1295                 0xEC, 0xB3, 0xEF, 0x9C, 0xFE, 0xBE, 0x52, 0xAC,
1296                 0xB1, 0x29, 0xDD, 0xFD, 0x07, 0xE2, 0xEE, 0xED,
1297                 0xE4, 0x46, 0x37, 0xFE, 0xD1, 0xDC, 0xCD, 0x02,
1298                 0xF9, 0x31, 0xB0, 0xFB, 0x36, 0xB7, 0x34, 0xA4,
1299                 0x76, 0xE8, 0x57, 0xBF, 0x99, 0x92, 0xC7, 0xAF,
1300                 0x98, 0x10, 0xE2, 0x70, 0xCA, 0xC9, 0x2B, 0x82,
1301                 0x06, 0x96, 0x88, 0x0D, 0xB3, 0xAC, 0x9E, 0x6D,
1302                 0x43, 0xBC, 0x5B, 0x31, 0xCF, 0x65, 0x8D, 0xA6,
1303                 0xC7, 0xFE, 0x73, 0xE1, 0x54, 0xF7, 0x10, 0xF9,
1304                 0x86, 0xF7, 0xDF, 0xA1, 0xA1, 0xD8, 0xAE, 0x35,
1305                 0xB3, 0x90, 0xDC, 0x6F, 0x43, 0x7A, 0x8B, 0xE0,
1306                 0xFE, 0x8F, 0x33, 0x4D, 0x29, 0x6C, 0x45, 0x53,
1307                 0x73, 0xDD, 0x21, 0x0B, 0x85, 0x30, 0xB5, 0xA5,
1308                 0xF3, 0x5D, 0xEC, 0x79, 0x61, 0x9D, 0x9E, 0xB3
1309
1310 };
1311
1312 static uint8_t ms_hmac_key1[] = {
1313                 0xFE, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1314                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1315                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1316                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1317                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1318                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1319                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1320                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1321 };
1322
1323 static const uint8_t ms_hmac_digest1[] = {
1324                 0xCE, 0x6E, 0x5F, 0x77, 0x96, 0x9A, 0xB1, 0x69,
1325                 0x2D, 0x5E, 0xF3, 0x2F, 0x32, 0x10, 0xCB, 0x50,
1326                 0x0E, 0x09, 0x56, 0x25, 0x07, 0x34, 0xC9, 0x20,
1327                 0xEC, 0x13, 0x43, 0x23, 0x5C, 0x08, 0x8B, 0xCD,
1328                 0xDC, 0x86, 0x8C, 0xEE, 0x0A, 0x95, 0x2E, 0xB9,
1329                 0x8C, 0x7B, 0x02, 0x7A, 0xD4, 0xE1, 0x49, 0xB4,
1330                 0x45, 0xB5, 0x52, 0x37, 0xC6, 0xFF, 0xFE, 0xAA,
1331                 0x0A, 0x87, 0xB8, 0x51, 0xF9, 0x2A, 0x01, 0x8F
1332 };
1333 /* End Session 1  */
1334 /* Begin Session 2 */
1335 static  uint8_t ms_aes_cbc_key2[] = {
1336                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1337                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1338 };
1339
1340 static  uint8_t ms_aes_cbc_iv2[] = {
1341                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1342                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1343 };
1344
1345 static const uint8_t ms_aes_cbc_cipher2[] = {
1346                 0xBB, 0x3C, 0x68, 0x25, 0xFD, 0xB6, 0xA2, 0x91,
1347                 0x20, 0x56, 0xF6, 0x30, 0x35, 0xFC, 0x9E, 0x97,
1348                 0xF2, 0x90, 0xFC, 0x7E, 0x3E, 0x0A, 0x75, 0xC8,
1349                 0x4C, 0xF2, 0x2D, 0xAC, 0xD3, 0x93, 0xF0, 0xC5,
1350                 0x14, 0x88, 0x8A, 0x23, 0xC2, 0x59, 0x9A, 0x98,
1351                 0x4B, 0xD5, 0x2C, 0xDA, 0x43, 0xA9, 0x34, 0x69,
1352                 0x7C, 0x6D, 0xDB, 0xDC, 0xCB, 0xC0, 0xA0, 0x09,
1353                 0xA7, 0x86, 0x16, 0x4B, 0xBF, 0xA8, 0xB6, 0xCF,
1354                 0x7F, 0x74, 0x1F, 0x22, 0xF0, 0xF6, 0xBB, 0x44,
1355                 0x8B, 0x4C, 0x9E, 0x23, 0xF8, 0x9F, 0xFC, 0x5B,
1356                 0x9E, 0x9C, 0x2A, 0x79, 0x30, 0x8F, 0xBF, 0xA9,
1357                 0x68, 0xA1, 0x20, 0x71, 0x7C, 0x77, 0x22, 0x34,
1358                 0x07, 0xCD, 0xC6, 0xF6, 0x50, 0x0A, 0x08, 0x99,
1359                 0x17, 0x98, 0xE3, 0x93, 0x8A, 0xB0, 0xEE, 0xDF,
1360                 0xC2, 0xBA, 0x3B, 0x44, 0x73, 0xDF, 0xDD, 0xDC,
1361                 0x14, 0x4D, 0x3B, 0xBB, 0x5E, 0x58, 0xC1, 0x26,
1362                 0xA7, 0xAE, 0x47, 0xF3, 0x24, 0x6D, 0x4F, 0xD3,
1363                 0x6E, 0x3E, 0x33, 0xE6, 0x7F, 0xCA, 0x50, 0xAF,
1364                 0x5D, 0x3D, 0xA0, 0xDD, 0xC9, 0xF3, 0x30, 0xD3,
1365                 0x6E, 0x8B, 0x2E, 0x12, 0x24, 0x34, 0xF0, 0xD3,
1366                 0xC7, 0x8D, 0x23, 0x29, 0xAA, 0x05, 0xE1, 0xFA,
1367                 0x2E, 0xF6, 0x8D, 0x37, 0x86, 0xC0, 0x6D, 0x13,
1368                 0x2D, 0x98, 0xF3, 0x52, 0x39, 0x22, 0xCE, 0x38,
1369                 0xC2, 0x1A, 0x72, 0xED, 0xFB, 0xCC, 0xE4, 0x71,
1370                 0x5A, 0x0C, 0x0D, 0x09, 0xF8, 0xE8, 0x1B, 0xBC,
1371                 0x53, 0xC8, 0xD8, 0x8F, 0xE5, 0x98, 0x5A, 0xB1,
1372                 0x06, 0xA6, 0x5B, 0xE6, 0xA2, 0x88, 0x21, 0x9E,
1373                 0x36, 0xC0, 0x34, 0xF9, 0xFB, 0x3B, 0x0A, 0x22,
1374                 0x00, 0x00, 0x39, 0x48, 0x8D, 0x23, 0x74, 0x62,
1375                 0x72, 0x91, 0xE6, 0x36, 0xAA, 0x77, 0x9C, 0x72,
1376                 0x9D, 0xA8, 0xC3, 0xA9, 0xD5, 0x44, 0x72, 0xA6,
1377                 0xB9, 0x28, 0x8F, 0x64, 0x4C, 0x8A, 0x64, 0xE6,
1378                 0x4E, 0xFA, 0xEF, 0x87, 0xDE, 0x7B, 0x22, 0x44,
1379                 0xB0, 0xDF, 0x2E, 0x5F, 0x0B, 0xA5, 0xF2, 0x24,
1380                 0x07, 0x5C, 0x2D, 0x39, 0xB7, 0x3D, 0x8A, 0xE5,
1381                 0x0E, 0x9D, 0x4E, 0x50, 0xED, 0x03, 0x99, 0x8E,
1382                 0xF0, 0x06, 0x55, 0x4E, 0xA2, 0x24, 0xE7, 0x17,
1383                 0x46, 0xDF, 0x6C, 0xCD, 0xC6, 0x44, 0xE8, 0xF9,
1384                 0xB9, 0x1B, 0x36, 0xF6, 0x7F, 0x10, 0xA4, 0x7D,
1385                 0x90, 0xBD, 0xE4, 0xAA, 0xD6, 0x9E, 0x18, 0x9D,
1386                 0x22, 0x35, 0xD6, 0x55, 0x54, 0xAA, 0xF7, 0x22,
1387                 0xA3, 0x3E, 0xEF, 0xC8, 0xA2, 0x34, 0x8D, 0xA9,
1388                 0x37, 0x63, 0xA6, 0xC3, 0x57, 0xCB, 0x0C, 0x49,
1389                 0x7D, 0x02, 0xBE, 0xAA, 0x13, 0x75, 0xB7, 0x4E,
1390                 0x52, 0x62, 0xA5, 0xC2, 0x33, 0xC7, 0x6C, 0x1B,
1391                 0xF6, 0x34, 0xF6, 0x09, 0xA5, 0x0C, 0xC7, 0xA2,
1392                 0x61, 0x48, 0x62, 0x7D, 0x17, 0x15, 0xE3, 0x95,
1393                 0xC8, 0x63, 0xD2, 0xA4, 0x43, 0xA9, 0x49, 0x07,
1394                 0xB2, 0x3B, 0x2B, 0x62, 0x7D, 0xCB, 0x51, 0xB3,
1395                 0x25, 0x33, 0x47, 0x0E, 0x14, 0x67, 0xDC, 0x6A,
1396                 0x9B, 0x51, 0xAC, 0x9D, 0x8F, 0xA2, 0x2B, 0x57,
1397                 0x8C, 0x5C, 0x5F, 0x76, 0x23, 0x92, 0x0F, 0x84,
1398                 0x46, 0x0E, 0x40, 0x85, 0x38, 0x60, 0xFA, 0x61,
1399                 0x20, 0xC5, 0xE3, 0xF1, 0x70, 0xAC, 0x1B, 0xBF,
1400                 0xC4, 0x2B, 0xC5, 0x67, 0xD1, 0x43, 0xC5, 0x17,
1401                 0x74, 0x71, 0x69, 0x6F, 0x82, 0x89, 0x19, 0x8A,
1402                 0x70, 0x43, 0x92, 0x01, 0xC4, 0x63, 0x7E, 0xB1,
1403                 0x59, 0x4E, 0xCD, 0xEA, 0x93, 0xA4, 0x52, 0x53,
1404                 0x9B, 0x61, 0x5B, 0xD2, 0x3E, 0x19, 0x39, 0xB7,
1405                 0x32, 0xEA, 0x8E, 0xF8, 0x1D, 0x76, 0x5C, 0xB2,
1406                 0x73, 0x2D, 0x91, 0xC0, 0x18, 0xED, 0x25, 0x2A,
1407                 0x53, 0x64, 0xF0, 0x92, 0x31, 0x55, 0x21, 0xA8,
1408                 0x24, 0xA9, 0xD1, 0x02, 0xF6, 0x6C, 0x2B, 0x70,
1409                 0xA9, 0x59, 0xC1, 0xD6, 0xC3, 0x57, 0x5B, 0x92
1410 };
1411
1412 static  uint8_t ms_hmac_key2[] = {
1413                 0xFC, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1414                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1415                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1416                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1417                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1418                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1419                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1420                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1421 };
1422
1423 static const uint8_t ms_hmac_digest2[] = {
1424                 0xA5, 0x0F, 0x9C, 0xFB, 0x08, 0x62, 0x59, 0xFF,
1425                 0x80, 0x2F, 0xEB, 0x4B, 0xE1, 0x46, 0x21, 0xD6,
1426                 0x02, 0x98, 0xF2, 0x8E, 0xF4, 0xEC, 0xD4, 0x77,
1427                 0x86, 0x4C, 0x31, 0x28, 0xC8, 0x25, 0x80, 0x27,
1428                 0x3A, 0x72, 0x5D, 0x6A, 0x56, 0x8A, 0xD3, 0x82,
1429                 0xB0, 0xEC, 0x31, 0x6D, 0x8B, 0x6B, 0xB4, 0x24,
1430                 0xE7, 0x62, 0xC1, 0x52, 0xBC, 0x14, 0x1B, 0x8E,
1431                 0xEC, 0x9A, 0xF1, 0x47, 0x80, 0xD2, 0xB0, 0x59
1432 };
1433
1434 /* End Session 2 */
1435
1436
1437 static int
1438 test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
1439 {
1440         struct crypto_testsuite_params *ts_params = &testsuite_params;
1441         struct crypto_unittest_params *ut_params = &unittest_params;
1442
1443         /* Verify the capabilities */
1444         struct rte_cryptodev_sym_capability_idx cap_idx;
1445         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1446         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
1447         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
1448                         &cap_idx) == NULL)
1449                 return -ENOTSUP;
1450         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1451         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
1452         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
1453                         &cap_idx) == NULL)
1454                 return -ENOTSUP;
1455
1456         /* Generate test mbuf data and space for digest */
1457         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1458                         catch_22_quote, QUOTE_512_BYTES, 0);
1459
1460         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1461                         DIGEST_BYTE_LENGTH_SHA1);
1462         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1463
1464         /* Setup Cipher Parameters */
1465         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1466         ut_params->cipher_xform.next = &ut_params->auth_xform;
1467
1468         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1469         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
1470         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
1471         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1472         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
1473         ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1474
1475         /* Setup HMAC Parameters */
1476         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1477
1478         ut_params->auth_xform.next = NULL;
1479
1480         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
1481         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
1482         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1;
1483         ut_params->auth_xform.auth.key.data = hmac_sha1_key;
1484         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
1485
1486         ut_params->sess = rte_cryptodev_sym_session_create(
1487                         ts_params->session_mpool);
1488
1489         /* Create crypto session*/
1490         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
1491                         ut_params->sess, &ut_params->cipher_xform,
1492                         ts_params->session_priv_mpool);
1493         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1494
1495         /* Generate crypto op data structure */
1496         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1497                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1498         TEST_ASSERT_NOT_NULL(ut_params->op,
1499                         "Failed to allocate symmetric crypto operation struct");
1500
1501         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1502
1503         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1504
1505         /* set crypto operation source mbuf */
1506         sym_op->m_src = ut_params->ibuf;
1507
1508         /* Set crypto operation authentication parameters */
1509         sym_op->auth.digest.data = ut_params->digest;
1510         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
1511                         ut_params->ibuf, QUOTE_512_BYTES);
1512
1513         sym_op->auth.data.offset = 0;
1514         sym_op->auth.data.length = QUOTE_512_BYTES;
1515
1516         /* Copy IV at the end of the crypto operation */
1517         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
1518                         aes_cbc_iv, CIPHER_IV_LENGTH_AES_CBC);
1519
1520         /* Set crypto operation cipher parameters */
1521         sym_op->cipher.data.offset = 0;
1522         sym_op->cipher.data.length = QUOTE_512_BYTES;
1523
1524         /* Process crypto operation */
1525         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
1526                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
1527                         ut_params->op);
1528         else
1529                 TEST_ASSERT_NOT_NULL(
1530                         process_crypto_request(ts_params->valid_devs[0],
1531                                 ut_params->op),
1532                                 "failed to process sym crypto op");
1533
1534         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1535                         "crypto op processing failed");
1536
1537         /* Validate obuf */
1538         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
1539                         uint8_t *);
1540
1541         TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext,
1542                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1543                         QUOTE_512_BYTES,
1544                         "ciphertext data not as expected");
1545
1546         uint8_t *digest = ciphertext + QUOTE_512_BYTES;
1547
1548         TEST_ASSERT_BUFFERS_ARE_EQUAL(digest,
1549                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
1550                         gbl_driver_id == rte_cryptodev_driver_id_get(
1551                                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) ?
1552                                         TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
1553                                         DIGEST_BYTE_LENGTH_SHA1,
1554                         "Generated digest data not as expected");
1555
1556         return TEST_SUCCESS;
1557 }
1558
1559 /* ***** AES-CBC / HMAC-SHA512 Hash Tests ***** */
1560
1561 #define HMAC_KEY_LENGTH_SHA512  (DIGEST_BYTE_LENGTH_SHA512)
1562
1563 static uint8_t hmac_sha512_key[] = {
1564         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1565         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1566         0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1567         0x9a, 0xaf, 0x88, 0x1b, 0xb6, 0x8f, 0xf8, 0x60,
1568         0xa2, 0x5a, 0x7f, 0x3f, 0xf4, 0x72, 0x70, 0xf1,
1569         0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1570         0x47, 0x3a, 0x75, 0x61, 0x5C, 0xa2, 0x10, 0x76,
1571         0x9a, 0xaf, 0x77, 0x5b, 0xb6, 0x7f, 0xf7, 0x60 };
1572
1573 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest[] = {
1574         0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8,
1575         0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48,
1576         0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8,
1577         0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70,
1578         0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8,
1579         0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E,
1580         0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D,
1581         0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A };
1582
1583
1584
1585 static int
1586 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1587                 struct crypto_unittest_params *ut_params,
1588                 uint8_t *cipher_key,
1589                 uint8_t *hmac_key);
1590
1591 static int
1592 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
1593                 struct crypto_unittest_params *ut_params,
1594                 struct crypto_testsuite_params *ts_params,
1595                 const uint8_t *cipher,
1596                 const uint8_t *digest,
1597                 const uint8_t *iv);
1598
1599
1600 static int
1601 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1602                 struct crypto_unittest_params *ut_params,
1603                 uint8_t *cipher_key,
1604                 uint8_t *hmac_key)
1605 {
1606
1607         /* Setup Cipher Parameters */
1608         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1609         ut_params->cipher_xform.next = NULL;
1610
1611         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1612         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
1613         ut_params->cipher_xform.cipher.key.data = cipher_key;
1614         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1615         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
1616         ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1617
1618         /* Setup HMAC Parameters */
1619         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1620         ut_params->auth_xform.next = &ut_params->cipher_xform;
1621
1622         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
1623         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC;
1624         ut_params->auth_xform.auth.key.data = hmac_key;
1625         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512;
1626         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512;
1627
1628         return TEST_SUCCESS;
1629 }
1630
1631
1632 static int
1633 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
1634                 struct crypto_unittest_params *ut_params,
1635                 struct crypto_testsuite_params *ts_params,
1636                 const uint8_t *cipher,
1637                 const uint8_t *digest,
1638                 const uint8_t *iv)
1639 {
1640         /* Generate test mbuf data and digest */
1641         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1642                         (const char *)
1643                         cipher,
1644                         QUOTE_512_BYTES, 0);
1645
1646         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1647                         DIGEST_BYTE_LENGTH_SHA512);
1648         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1649
1650         rte_memcpy(ut_params->digest,
1651                         digest,
1652                         DIGEST_BYTE_LENGTH_SHA512);
1653
1654         /* Generate Crypto op data structure */
1655         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1656                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1657         TEST_ASSERT_NOT_NULL(ut_params->op,
1658                         "Failed to allocate symmetric crypto operation struct");
1659
1660         rte_crypto_op_attach_sym_session(ut_params->op, sess);
1661
1662         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1663
1664         /* set crypto operation source mbuf */
1665         sym_op->m_src = ut_params->ibuf;
1666
1667         sym_op->auth.digest.data = ut_params->digest;
1668         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
1669                         ut_params->ibuf, QUOTE_512_BYTES);
1670
1671         sym_op->auth.data.offset = 0;
1672         sym_op->auth.data.length = QUOTE_512_BYTES;
1673
1674         /* Copy IV at the end of the crypto operation */
1675         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
1676                         iv, CIPHER_IV_LENGTH_AES_CBC);
1677
1678         sym_op->cipher.data.offset = 0;
1679         sym_op->cipher.data.length = QUOTE_512_BYTES;
1680
1681         /* Process crypto operation */
1682         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
1683                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
1684                         ut_params->op);
1685         else
1686                 TEST_ASSERT_NOT_NULL(
1687                                 process_crypto_request(ts_params->valid_devs[0],
1688                                         ut_params->op),
1689                                         "failed to process sym crypto op");
1690
1691         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1692                         "crypto op processing failed");
1693
1694         ut_params->obuf = ut_params->op->sym->m_src;
1695
1696         /* Validate obuf */
1697         TEST_ASSERT_BUFFERS_ARE_EQUAL(
1698                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *),
1699                         catch_22_quote,
1700                         QUOTE_512_BYTES,
1701                         "Plaintext data not as expected");
1702
1703         /* Validate obuf */
1704         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1705                         "Digest verification failed");
1706
1707         return TEST_SUCCESS;
1708 }
1709
1710 static int
1711 test_blockcipher(enum blockcipher_test_type test_type)
1712 {
1713         struct crypto_testsuite_params *ts_params = &testsuite_params;
1714         int status;
1715
1716         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1717                 ts_params->op_mpool,
1718                 ts_params->session_mpool, ts_params->session_priv_mpool,
1719                 ts_params->valid_devs[0],
1720                 test_type);
1721
1722         if (status == -ENOTSUP)
1723                 return status;
1724
1725         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1726
1727         return TEST_SUCCESS;
1728 }
1729
1730 static int
1731 test_AES_cipheronly_all(void)
1732 {
1733         return test_blockcipher(BLKCIPHER_AES_CIPHERONLY_TYPE);
1734 }
1735
1736 static int
1737 test_AES_docsis_all(void)
1738 {
1739         return test_blockcipher(BLKCIPHER_AES_DOCSIS_TYPE);
1740 }
1741
1742 static int
1743 test_DES_docsis_all(void)
1744 {
1745         return test_blockcipher(BLKCIPHER_DES_DOCSIS_TYPE);
1746 }
1747
1748 static int
1749 test_DES_cipheronly_all(void)
1750 {
1751         return test_blockcipher(BLKCIPHER_DES_CIPHERONLY_TYPE);
1752 }
1753
1754 static int
1755 test_authonly_all(void)
1756 {
1757         return test_blockcipher(BLKCIPHER_AUTHONLY_TYPE);
1758 }
1759
1760 static int
1761 test_AES_chain_all(void)
1762 {
1763         return test_blockcipher(BLKCIPHER_AES_CHAIN_TYPE);
1764 }
1765
1766 static int
1767 test_3DES_chain_all(void)
1768 {
1769         return test_blockcipher(BLKCIPHER_3DES_CHAIN_TYPE);
1770 }
1771
1772 static int
1773 test_3DES_cipheronly_all(void)
1774 {
1775         return test_blockcipher(BLKCIPHER_3DES_CIPHERONLY_TYPE);
1776 }
1777
1778 /* ***** SNOW 3G Tests ***** */
1779 static int
1780 create_wireless_algo_hash_session(uint8_t dev_id,
1781         const uint8_t *key, const uint8_t key_len,
1782         const uint8_t iv_len, const uint8_t auth_len,
1783         enum rte_crypto_auth_operation op,
1784         enum rte_crypto_auth_algorithm algo)
1785 {
1786         uint8_t hash_key[key_len];
1787         int status;
1788
1789         struct crypto_testsuite_params *ts_params = &testsuite_params;
1790         struct crypto_unittest_params *ut_params = &unittest_params;
1791
1792         memcpy(hash_key, key, key_len);
1793
1794         debug_hexdump(stdout, "key:", key, key_len);
1795
1796         /* Setup Authentication Parameters */
1797         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1798         ut_params->auth_xform.next = NULL;
1799
1800         ut_params->auth_xform.auth.op = op;
1801         ut_params->auth_xform.auth.algo = algo;
1802         ut_params->auth_xform.auth.key.length = key_len;
1803         ut_params->auth_xform.auth.key.data = hash_key;
1804         ut_params->auth_xform.auth.digest_length = auth_len;
1805         ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
1806         ut_params->auth_xform.auth.iv.length = iv_len;
1807         ut_params->sess = rte_cryptodev_sym_session_create(
1808                         ts_params->session_mpool);
1809
1810         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
1811                         &ut_params->auth_xform,
1812                         ts_params->session_priv_mpool);
1813         TEST_ASSERT_EQUAL(status, 0, "session init failed");
1814         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1815         return 0;
1816 }
1817
1818 static int
1819 create_wireless_algo_cipher_session(uint8_t dev_id,
1820                         enum rte_crypto_cipher_operation op,
1821                         enum rte_crypto_cipher_algorithm algo,
1822                         const uint8_t *key, const uint8_t key_len,
1823                         uint8_t iv_len)
1824 {
1825         uint8_t cipher_key[key_len];
1826         int status;
1827         struct crypto_testsuite_params *ts_params = &testsuite_params;
1828         struct crypto_unittest_params *ut_params = &unittest_params;
1829
1830         memcpy(cipher_key, key, key_len);
1831
1832         /* Setup Cipher Parameters */
1833         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1834         ut_params->cipher_xform.next = NULL;
1835
1836         ut_params->cipher_xform.cipher.algo = algo;
1837         ut_params->cipher_xform.cipher.op = op;
1838         ut_params->cipher_xform.cipher.key.data = cipher_key;
1839         ut_params->cipher_xform.cipher.key.length = key_len;
1840         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
1841         ut_params->cipher_xform.cipher.iv.length = iv_len;
1842
1843         debug_hexdump(stdout, "key:", key, key_len);
1844
1845         /* Create Crypto session */
1846         ut_params->sess = rte_cryptodev_sym_session_create(
1847                         ts_params->session_mpool);
1848
1849         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
1850                         &ut_params->cipher_xform,
1851                         ts_params->session_priv_mpool);
1852         TEST_ASSERT_EQUAL(status, 0, "session init failed");
1853         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1854         return 0;
1855 }
1856
1857 static int
1858 create_wireless_algo_cipher_operation(const uint8_t *iv, uint8_t iv_len,
1859                         unsigned int cipher_len,
1860                         unsigned int cipher_offset)
1861 {
1862         struct crypto_testsuite_params *ts_params = &testsuite_params;
1863         struct crypto_unittest_params *ut_params = &unittest_params;
1864
1865         /* Generate Crypto op data structure */
1866         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1867                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1868         TEST_ASSERT_NOT_NULL(ut_params->op,
1869                                 "Failed to allocate pktmbuf offload");
1870
1871         /* Set crypto operation data parameters */
1872         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1873
1874         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1875
1876         /* set crypto operation source mbuf */
1877         sym_op->m_src = ut_params->ibuf;
1878
1879         /* iv */
1880         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
1881                         iv, iv_len);
1882         sym_op->cipher.data.length = cipher_len;
1883         sym_op->cipher.data.offset = cipher_offset;
1884         return 0;
1885 }
1886
1887 static int
1888 create_wireless_algo_cipher_operation_oop(const uint8_t *iv, uint8_t iv_len,
1889                         unsigned int cipher_len,
1890                         unsigned int cipher_offset)
1891 {
1892         struct crypto_testsuite_params *ts_params = &testsuite_params;
1893         struct crypto_unittest_params *ut_params = &unittest_params;
1894
1895         /* Generate Crypto op data structure */
1896         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1897                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1898         TEST_ASSERT_NOT_NULL(ut_params->op,
1899                                 "Failed to allocate pktmbuf offload");
1900
1901         /* Set crypto operation data parameters */
1902         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1903
1904         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1905
1906         /* set crypto operation source mbuf */
1907         sym_op->m_src = ut_params->ibuf;
1908         sym_op->m_dst = ut_params->obuf;
1909
1910         /* iv */
1911         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
1912                         iv, iv_len);
1913         sym_op->cipher.data.length = cipher_len;
1914         sym_op->cipher.data.offset = cipher_offset;
1915         return 0;
1916 }
1917
1918 static int
1919 create_wireless_algo_cipher_auth_session(uint8_t dev_id,
1920                 enum rte_crypto_cipher_operation cipher_op,
1921                 enum rte_crypto_auth_operation auth_op,
1922                 enum rte_crypto_auth_algorithm auth_algo,
1923                 enum rte_crypto_cipher_algorithm cipher_algo,
1924                 const uint8_t *key, uint8_t key_len,
1925                 uint8_t auth_iv_len, uint8_t auth_len,
1926                 uint8_t cipher_iv_len)
1927
1928 {
1929         uint8_t cipher_auth_key[key_len];
1930         int status;
1931
1932         struct crypto_testsuite_params *ts_params = &testsuite_params;
1933         struct crypto_unittest_params *ut_params = &unittest_params;
1934
1935         memcpy(cipher_auth_key, key, key_len);
1936
1937         /* Setup Authentication Parameters */
1938         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1939         ut_params->auth_xform.next = NULL;
1940
1941         ut_params->auth_xform.auth.op = auth_op;
1942         ut_params->auth_xform.auth.algo = auth_algo;
1943         ut_params->auth_xform.auth.key.length = key_len;
1944         /* Hash key = cipher key */
1945         ut_params->auth_xform.auth.key.data = cipher_auth_key;
1946         ut_params->auth_xform.auth.digest_length = auth_len;
1947         /* Auth IV will be after cipher IV */
1948         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
1949         ut_params->auth_xform.auth.iv.length = auth_iv_len;
1950
1951         /* Setup Cipher Parameters */
1952         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1953         ut_params->cipher_xform.next = &ut_params->auth_xform;
1954
1955         ut_params->cipher_xform.cipher.algo = cipher_algo;
1956         ut_params->cipher_xform.cipher.op = cipher_op;
1957         ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
1958         ut_params->cipher_xform.cipher.key.length = key_len;
1959         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
1960         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
1961
1962         debug_hexdump(stdout, "key:", key, key_len);
1963
1964         /* Create Crypto session*/
1965         ut_params->sess = rte_cryptodev_sym_session_create(
1966                         ts_params->session_mpool);
1967         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1968
1969         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
1970                         &ut_params->cipher_xform,
1971                         ts_params->session_priv_mpool);
1972         if (status == -ENOTSUP)
1973                 return status;
1974
1975         TEST_ASSERT_EQUAL(status, 0, "session init failed");
1976         return 0;
1977 }
1978
1979 static int
1980 create_wireless_cipher_auth_session(uint8_t dev_id,
1981                 enum rte_crypto_cipher_operation cipher_op,
1982                 enum rte_crypto_auth_operation auth_op,
1983                 enum rte_crypto_auth_algorithm auth_algo,
1984                 enum rte_crypto_cipher_algorithm cipher_algo,
1985                 const struct wireless_test_data *tdata)
1986 {
1987         const uint8_t key_len = tdata->key.len;
1988         uint8_t cipher_auth_key[key_len];
1989         int status;
1990
1991         struct crypto_testsuite_params *ts_params = &testsuite_params;
1992         struct crypto_unittest_params *ut_params = &unittest_params;
1993         const uint8_t *key = tdata->key.data;
1994         const uint8_t auth_len = tdata->digest.len;
1995         uint8_t cipher_iv_len = tdata->cipher_iv.len;
1996         uint8_t auth_iv_len = tdata->auth_iv.len;
1997
1998         memcpy(cipher_auth_key, key, key_len);
1999
2000         /* Setup Authentication Parameters */
2001         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2002         ut_params->auth_xform.next = NULL;
2003
2004         ut_params->auth_xform.auth.op = auth_op;
2005         ut_params->auth_xform.auth.algo = auth_algo;
2006         ut_params->auth_xform.auth.key.length = key_len;
2007         /* Hash key = cipher key */
2008         ut_params->auth_xform.auth.key.data = cipher_auth_key;
2009         ut_params->auth_xform.auth.digest_length = auth_len;
2010         /* Auth IV will be after cipher IV */
2011         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2012         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2013
2014         /* Setup Cipher Parameters */
2015         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2016         ut_params->cipher_xform.next = &ut_params->auth_xform;
2017
2018         ut_params->cipher_xform.cipher.algo = cipher_algo;
2019         ut_params->cipher_xform.cipher.op = cipher_op;
2020         ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2021         ut_params->cipher_xform.cipher.key.length = key_len;
2022         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2023         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2024
2025
2026         debug_hexdump(stdout, "key:", key, key_len);
2027
2028         /* Create Crypto session*/
2029         ut_params->sess = rte_cryptodev_sym_session_create(
2030                         ts_params->session_mpool);
2031
2032         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2033                         &ut_params->cipher_xform,
2034                         ts_params->session_priv_mpool);
2035         if (status == -ENOTSUP)
2036                 return status;
2037
2038         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2039         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2040         return 0;
2041 }
2042
2043 static int
2044 create_zuc_cipher_auth_encrypt_generate_session(uint8_t dev_id,
2045                 const struct wireless_test_data *tdata)
2046 {
2047         return create_wireless_cipher_auth_session(dev_id,
2048                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2049                 RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_ZUC_EIA3,
2050                 RTE_CRYPTO_CIPHER_ZUC_EEA3, tdata);
2051 }
2052
2053 static int
2054 create_wireless_algo_auth_cipher_session(uint8_t dev_id,
2055                 enum rte_crypto_cipher_operation cipher_op,
2056                 enum rte_crypto_auth_operation auth_op,
2057                 enum rte_crypto_auth_algorithm auth_algo,
2058                 enum rte_crypto_cipher_algorithm cipher_algo,
2059                 const uint8_t *key, const uint8_t key_len,
2060                 uint8_t auth_iv_len, uint8_t auth_len,
2061                 uint8_t cipher_iv_len)
2062 {
2063         uint8_t auth_cipher_key[key_len];
2064         int status;
2065         struct crypto_testsuite_params *ts_params = &testsuite_params;
2066         struct crypto_unittest_params *ut_params = &unittest_params;
2067
2068         memcpy(auth_cipher_key, key, key_len);
2069
2070         /* Setup Authentication Parameters */
2071         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2072         ut_params->auth_xform.auth.op = auth_op;
2073         ut_params->auth_xform.next = &ut_params->cipher_xform;
2074         ut_params->auth_xform.auth.algo = auth_algo;
2075         ut_params->auth_xform.auth.key.length = key_len;
2076         ut_params->auth_xform.auth.key.data = auth_cipher_key;
2077         ut_params->auth_xform.auth.digest_length = auth_len;
2078         /* Auth IV will be after cipher IV */
2079         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2080         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2081
2082         /* Setup Cipher Parameters */
2083         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2084         ut_params->cipher_xform.next = NULL;
2085         ut_params->cipher_xform.cipher.algo = cipher_algo;
2086         ut_params->cipher_xform.cipher.op = cipher_op;
2087         ut_params->cipher_xform.cipher.key.data = auth_cipher_key;
2088         ut_params->cipher_xform.cipher.key.length = key_len;
2089         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2090         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2091
2092         debug_hexdump(stdout, "key:", key, key_len);
2093
2094         /* Create Crypto session*/
2095         ut_params->sess = rte_cryptodev_sym_session_create(
2096                         ts_params->session_mpool);
2097         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2098
2099         if (cipher_op == RTE_CRYPTO_CIPHER_OP_DECRYPT) {
2100                 ut_params->auth_xform.next = NULL;
2101                 ut_params->cipher_xform.next = &ut_params->auth_xform;
2102                 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2103                                 &ut_params->cipher_xform,
2104                                 ts_params->session_priv_mpool);
2105
2106         } else
2107                 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2108                                 &ut_params->auth_xform,
2109                                 ts_params->session_priv_mpool);
2110
2111         if (status == -ENOTSUP)
2112                 return status;
2113
2114         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2115
2116         return 0;
2117 }
2118
2119 static int
2120 create_wireless_algo_hash_operation(const uint8_t *auth_tag,
2121                 unsigned int auth_tag_len,
2122                 const uint8_t *iv, unsigned int iv_len,
2123                 unsigned int data_pad_len,
2124                 enum rte_crypto_auth_operation op,
2125                 unsigned int auth_len, unsigned int auth_offset)
2126 {
2127         struct crypto_testsuite_params *ts_params = &testsuite_params;
2128
2129         struct crypto_unittest_params *ut_params = &unittest_params;
2130
2131         /* Generate Crypto op data structure */
2132         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2133                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2134         TEST_ASSERT_NOT_NULL(ut_params->op,
2135                 "Failed to allocate pktmbuf offload");
2136
2137         /* Set crypto operation data parameters */
2138         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2139
2140         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2141
2142         /* set crypto operation source mbuf */
2143         sym_op->m_src = ut_params->ibuf;
2144
2145         /* iv */
2146         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2147                         iv, iv_len);
2148         /* digest */
2149         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2150                                         ut_params->ibuf, auth_tag_len);
2151
2152         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2153                                 "no room to append auth tag");
2154         ut_params->digest = sym_op->auth.digest.data;
2155         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2156                         ut_params->ibuf, data_pad_len);
2157         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2158                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2159         else
2160                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2161
2162         debug_hexdump(stdout, "digest:",
2163                 sym_op->auth.digest.data,
2164                 auth_tag_len);
2165
2166         sym_op->auth.data.length = auth_len;
2167         sym_op->auth.data.offset = auth_offset;
2168
2169         return 0;
2170 }
2171
2172 static int
2173 create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata,
2174         enum rte_crypto_auth_operation op)
2175 {
2176         struct crypto_testsuite_params *ts_params = &testsuite_params;
2177         struct crypto_unittest_params *ut_params = &unittest_params;
2178
2179         const uint8_t *auth_tag = tdata->digest.data;
2180         const unsigned int auth_tag_len = tdata->digest.len;
2181         unsigned int plaintext_len = ceil_byte_length(tdata->plaintext.len);
2182         unsigned int data_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2183
2184         const uint8_t *cipher_iv = tdata->cipher_iv.data;
2185         const uint8_t cipher_iv_len = tdata->cipher_iv.len;
2186         const uint8_t *auth_iv = tdata->auth_iv.data;
2187         const uint8_t auth_iv_len = tdata->auth_iv.len;
2188         const unsigned int cipher_len = tdata->validCipherLenInBits.len;
2189         const unsigned int auth_len = tdata->validAuthLenInBits.len;
2190
2191         /* Generate Crypto op data structure */
2192         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2193                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2194         TEST_ASSERT_NOT_NULL(ut_params->op,
2195                         "Failed to allocate pktmbuf offload");
2196         /* Set crypto operation data parameters */
2197         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2198
2199         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2200
2201         /* set crypto operation source mbuf */
2202         sym_op->m_src = ut_params->ibuf;
2203
2204         /* digest */
2205         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2206                         ut_params->ibuf, auth_tag_len);
2207
2208         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2209                         "no room to append auth tag");
2210         ut_params->digest = sym_op->auth.digest.data;
2211         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2212                         ut_params->ibuf, data_pad_len);
2213         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2214                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2215         else
2216                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2217
2218         debug_hexdump(stdout, "digest:",
2219                 sym_op->auth.digest.data,
2220                 auth_tag_len);
2221
2222         /* Copy cipher and auth IVs at the end of the crypto operation */
2223         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2224                                                 IV_OFFSET);
2225         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2226         iv_ptr += cipher_iv_len;
2227         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2228
2229         sym_op->cipher.data.length = cipher_len;
2230         sym_op->cipher.data.offset = 0;
2231         sym_op->auth.data.length = auth_len;
2232         sym_op->auth.data.offset = 0;
2233
2234         return 0;
2235 }
2236
2237 static int
2238 create_zuc_cipher_hash_generate_operation(
2239                 const struct wireless_test_data *tdata)
2240 {
2241         return create_wireless_cipher_hash_operation(tdata,
2242                 RTE_CRYPTO_AUTH_OP_GENERATE);
2243 }
2244
2245 static int
2246 create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
2247                 const unsigned auth_tag_len,
2248                 const uint8_t *auth_iv, uint8_t auth_iv_len,
2249                 unsigned data_pad_len,
2250                 enum rte_crypto_auth_operation op,
2251                 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2252                 const unsigned cipher_len, const unsigned cipher_offset,
2253                 const unsigned auth_len, const unsigned auth_offset)
2254 {
2255         struct crypto_testsuite_params *ts_params = &testsuite_params;
2256         struct crypto_unittest_params *ut_params = &unittest_params;
2257
2258         enum rte_crypto_cipher_algorithm cipher_algo =
2259                         ut_params->cipher_xform.cipher.algo;
2260         enum rte_crypto_auth_algorithm auth_algo =
2261                         ut_params->auth_xform.auth.algo;
2262
2263         /* Generate Crypto op data structure */
2264         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2265                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2266         TEST_ASSERT_NOT_NULL(ut_params->op,
2267                         "Failed to allocate pktmbuf offload");
2268         /* Set crypto operation data parameters */
2269         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2270
2271         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2272
2273         /* set crypto operation source mbuf */
2274         sym_op->m_src = ut_params->ibuf;
2275
2276         /* digest */
2277         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2278                         ut_params->ibuf, auth_tag_len);
2279
2280         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2281                         "no room to append auth tag");
2282         ut_params->digest = sym_op->auth.digest.data;
2283
2284         if (rte_pktmbuf_is_contiguous(ut_params->ibuf)) {
2285                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2286                                 ut_params->ibuf, data_pad_len);
2287         } else {
2288                 struct rte_mbuf *m = ut_params->ibuf;
2289                 unsigned int offset = data_pad_len;
2290
2291                 while (offset > m->data_len && m->next != NULL) {
2292                         offset -= m->data_len;
2293                         m = m->next;
2294                 }
2295                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2296                         m, offset);
2297         }
2298
2299         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2300                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2301         else
2302                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2303
2304         debug_hexdump(stdout, "digest:",
2305                 sym_op->auth.digest.data,
2306                 auth_tag_len);
2307
2308         /* Copy cipher and auth IVs at the end of the crypto operation */
2309         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2310                                                 IV_OFFSET);
2311         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2312         iv_ptr += cipher_iv_len;
2313         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2314
2315         if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
2316                 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
2317                 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
2318                 sym_op->cipher.data.length = cipher_len;
2319                 sym_op->cipher.data.offset = cipher_offset;
2320         } else {
2321                 sym_op->cipher.data.length = cipher_len >> 3;
2322                 sym_op->cipher.data.offset = cipher_offset >> 3;
2323         }
2324
2325         if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
2326                 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
2327                 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
2328                 sym_op->auth.data.length = auth_len;
2329                 sym_op->auth.data.offset = auth_offset;
2330         } else {
2331                 sym_op->auth.data.length = auth_len >> 3;
2332                 sym_op->auth.data.offset = auth_offset >> 3;
2333         }
2334
2335         return 0;
2336 }
2337
2338 static int
2339 create_wireless_algo_auth_cipher_operation(
2340                 const uint8_t *auth_tag, unsigned int auth_tag_len,
2341                 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2342                 const uint8_t *auth_iv, uint8_t auth_iv_len,
2343                 unsigned int data_pad_len,
2344                 unsigned int cipher_len, unsigned int cipher_offset,
2345                 unsigned int auth_len, unsigned int auth_offset,
2346                 uint8_t op_mode, uint8_t do_sgl, uint8_t verify)
2347 {
2348         struct crypto_testsuite_params *ts_params = &testsuite_params;
2349         struct crypto_unittest_params *ut_params = &unittest_params;
2350
2351         enum rte_crypto_cipher_algorithm cipher_algo =
2352                         ut_params->cipher_xform.cipher.algo;
2353         enum rte_crypto_auth_algorithm auth_algo =
2354                         ut_params->auth_xform.auth.algo;
2355
2356         /* Generate Crypto op data structure */
2357         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2358                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2359         TEST_ASSERT_NOT_NULL(ut_params->op,
2360                         "Failed to allocate pktmbuf offload");
2361
2362         /* Set crypto operation data parameters */
2363         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2364
2365         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2366
2367         /* set crypto operation mbufs */
2368         sym_op->m_src = ut_params->ibuf;
2369         if (op_mode == OUT_OF_PLACE)
2370                 sym_op->m_dst = ut_params->obuf;
2371
2372         /* digest */
2373         if (!do_sgl) {
2374                 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(
2375                         (op_mode == IN_PLACE ?
2376                                 ut_params->ibuf : ut_params->obuf),
2377                         uint8_t *, data_pad_len);
2378                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2379                         (op_mode == IN_PLACE ?
2380                                 ut_params->ibuf : ut_params->obuf),
2381                         data_pad_len);
2382                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2383         } else {
2384                 uint16_t remaining_off = (auth_offset >> 3) + (auth_len >> 3);
2385                 struct rte_mbuf *sgl_buf = (op_mode == IN_PLACE ?
2386                                 sym_op->m_src : sym_op->m_dst);
2387                 while (remaining_off >= rte_pktmbuf_data_len(sgl_buf)) {
2388                         remaining_off -= rte_pktmbuf_data_len(sgl_buf);
2389                         sgl_buf = sgl_buf->next;
2390                 }
2391                 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(sgl_buf,
2392                                 uint8_t *, remaining_off);
2393                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(sgl_buf,
2394                                 remaining_off);
2395                 memset(sym_op->auth.digest.data, 0, remaining_off);
2396                 while (sgl_buf->next != NULL) {
2397                         memset(rte_pktmbuf_mtod(sgl_buf, uint8_t *),
2398                                 0, rte_pktmbuf_data_len(sgl_buf));
2399                         sgl_buf = sgl_buf->next;
2400                 }
2401         }
2402
2403         /* Copy digest for the verification */
2404         if (verify)
2405                 memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2406
2407         /* Copy cipher and auth IVs at the end of the crypto operation */
2408         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(
2409                         ut_params->op, uint8_t *, IV_OFFSET);
2410
2411         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2412         iv_ptr += cipher_iv_len;
2413         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2414
2415         if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
2416                 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
2417                 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
2418                 sym_op->cipher.data.length = cipher_len;
2419                 sym_op->cipher.data.offset = cipher_offset;
2420         } else {
2421                 sym_op->cipher.data.length = cipher_len >> 3;
2422                 sym_op->cipher.data.offset = cipher_offset >> 3;
2423         }
2424
2425         if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
2426                 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
2427                 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
2428                 sym_op->auth.data.length = auth_len;
2429                 sym_op->auth.data.offset = auth_offset;
2430         } else {
2431                 sym_op->auth.data.length = auth_len >> 3;
2432                 sym_op->auth.data.offset = auth_offset >> 3;
2433         }
2434
2435         return 0;
2436 }
2437
2438 static int
2439 test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
2440 {
2441         struct crypto_testsuite_params *ts_params = &testsuite_params;
2442         struct crypto_unittest_params *ut_params = &unittest_params;
2443
2444         int retval;
2445         unsigned plaintext_pad_len;
2446         unsigned plaintext_len;
2447         uint8_t *plaintext;
2448         struct rte_cryptodev_info dev_info;
2449
2450         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
2451         uint64_t feat_flags = dev_info.feature_flags;
2452
2453         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
2454                         ((tdata->validAuthLenInBits.len % 8) != 0)) {
2455                 printf("Device doesn't support NON-Byte Aligned Data.\n");
2456                 return -ENOTSUP;
2457         }
2458
2459         /* Verify the capabilities */
2460         struct rte_cryptodev_sym_capability_idx cap_idx;
2461         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2462         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
2463         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2464                         &cap_idx) == NULL)
2465                 return -ENOTSUP;
2466
2467         /* Create SNOW 3G session */
2468         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2469                         tdata->key.data, tdata->key.len,
2470                         tdata->auth_iv.len, tdata->digest.len,
2471                         RTE_CRYPTO_AUTH_OP_GENERATE,
2472                         RTE_CRYPTO_AUTH_SNOW3G_UIA2);
2473         if (retval < 0)
2474                 return retval;
2475
2476         /* alloc mbuf and set payload */
2477         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2478
2479         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2480         rte_pktmbuf_tailroom(ut_params->ibuf));
2481
2482         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2483         /* Append data which is padded to a multiple of */
2484         /* the algorithms block size */
2485         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2486         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2487                                 plaintext_pad_len);
2488         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2489
2490         /* Create SNOW 3G operation */
2491         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
2492                         tdata->auth_iv.data, tdata->auth_iv.len,
2493                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
2494                         tdata->validAuthLenInBits.len,
2495                         0);
2496         if (retval < 0)
2497                 return retval;
2498
2499         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2500                                 ut_params->op);
2501         ut_params->obuf = ut_params->op->sym->m_src;
2502         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2503         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2504                         + plaintext_pad_len;
2505
2506         /* Validate obuf */
2507         TEST_ASSERT_BUFFERS_ARE_EQUAL(
2508         ut_params->digest,
2509         tdata->digest.data,
2510         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
2511         "SNOW 3G Generated auth tag not as expected");
2512
2513         return 0;
2514 }
2515
2516 static int
2517 test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
2518 {
2519         struct crypto_testsuite_params *ts_params = &testsuite_params;
2520         struct crypto_unittest_params *ut_params = &unittest_params;
2521
2522         int retval;
2523         unsigned plaintext_pad_len;
2524         unsigned plaintext_len;
2525         uint8_t *plaintext;
2526         struct rte_cryptodev_info dev_info;
2527
2528         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
2529         uint64_t feat_flags = dev_info.feature_flags;
2530
2531         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
2532                         ((tdata->validAuthLenInBits.len % 8) != 0)) {
2533                 printf("Device doesn't support NON-Byte Aligned Data.\n");
2534                 return -ENOTSUP;
2535         }
2536
2537         /* Verify the capabilities */
2538         struct rte_cryptodev_sym_capability_idx cap_idx;
2539         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2540         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
2541         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2542                         &cap_idx) == NULL)
2543                 return -ENOTSUP;
2544
2545         /* Create SNOW 3G session */
2546         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2547                                 tdata->key.data, tdata->key.len,
2548                                 tdata->auth_iv.len, tdata->digest.len,
2549                                 RTE_CRYPTO_AUTH_OP_VERIFY,
2550                                 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
2551         if (retval < 0)
2552                 return retval;
2553         /* alloc mbuf and set payload */
2554         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2555
2556         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2557         rte_pktmbuf_tailroom(ut_params->ibuf));
2558
2559         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2560         /* Append data which is padded to a multiple of */
2561         /* the algorithms block size */
2562         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2563         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2564                                 plaintext_pad_len);
2565         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2566
2567         /* Create SNOW 3G operation */
2568         retval = create_wireless_algo_hash_operation(tdata->digest.data,
2569                         tdata->digest.len,
2570                         tdata->auth_iv.data, tdata->auth_iv.len,
2571                         plaintext_pad_len,
2572                         RTE_CRYPTO_AUTH_OP_VERIFY,
2573                         tdata->validAuthLenInBits.len,
2574                         0);
2575         if (retval < 0)
2576                 return retval;
2577
2578         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2579                                 ut_params->op);
2580         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2581         ut_params->obuf = ut_params->op->sym->m_src;
2582         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2583                                 + plaintext_pad_len;
2584
2585         /* Validate obuf */
2586         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
2587                 return 0;
2588         else
2589                 return -1;
2590
2591         return 0;
2592 }
2593
2594 static int
2595 test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
2596 {
2597         struct crypto_testsuite_params *ts_params = &testsuite_params;
2598         struct crypto_unittest_params *ut_params = &unittest_params;
2599
2600         int retval;
2601         unsigned plaintext_pad_len;
2602         unsigned plaintext_len;
2603         uint8_t *plaintext;
2604
2605         /* Verify the capabilities */
2606         struct rte_cryptodev_sym_capability_idx cap_idx;
2607         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2608         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
2609         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2610                         &cap_idx) == NULL)
2611                 return -ENOTSUP;
2612
2613         /* Create KASUMI session */
2614         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2615                         tdata->key.data, tdata->key.len,
2616                         0, tdata->digest.len,
2617                         RTE_CRYPTO_AUTH_OP_GENERATE,
2618                         RTE_CRYPTO_AUTH_KASUMI_F9);
2619         if (retval < 0)
2620                 return retval;
2621
2622         /* alloc mbuf and set payload */
2623         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2624
2625         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2626         rte_pktmbuf_tailroom(ut_params->ibuf));
2627
2628         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2629         /* Append data which is padded to a multiple of */
2630         /* the algorithms block size */
2631         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2632         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2633                                 plaintext_pad_len);
2634         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2635
2636         /* Create KASUMI operation */
2637         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
2638                         NULL, 0,
2639                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
2640                         tdata->plaintext.len,
2641                         0);
2642         if (retval < 0)
2643                 return retval;
2644
2645         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2646                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
2647                         ut_params->op);
2648         else
2649                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2650                         ut_params->op);
2651
2652         ut_params->obuf = ut_params->op->sym->m_src;
2653         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2654         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2655                         + plaintext_pad_len;
2656
2657         /* Validate obuf */
2658         TEST_ASSERT_BUFFERS_ARE_EQUAL(
2659         ut_params->digest,
2660         tdata->digest.data,
2661         DIGEST_BYTE_LENGTH_KASUMI_F9,
2662         "KASUMI Generated auth tag not as expected");
2663
2664         return 0;
2665 }
2666
2667 static int
2668 test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
2669 {
2670         struct crypto_testsuite_params *ts_params = &testsuite_params;
2671         struct crypto_unittest_params *ut_params = &unittest_params;
2672
2673         int retval;
2674         unsigned plaintext_pad_len;
2675         unsigned plaintext_len;
2676         uint8_t *plaintext;
2677
2678         /* Verify the capabilities */
2679         struct rte_cryptodev_sym_capability_idx cap_idx;
2680         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2681         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
2682         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2683                         &cap_idx) == NULL)
2684                 return -ENOTSUP;
2685
2686         /* Create KASUMI session */
2687         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2688                                 tdata->key.data, tdata->key.len,
2689                                 0, tdata->digest.len,
2690                                 RTE_CRYPTO_AUTH_OP_VERIFY,
2691                                 RTE_CRYPTO_AUTH_KASUMI_F9);
2692         if (retval < 0)
2693                 return retval;
2694         /* alloc mbuf and set payload */
2695         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2696
2697         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2698         rte_pktmbuf_tailroom(ut_params->ibuf));
2699
2700         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2701         /* Append data which is padded to a multiple */
2702         /* of the algorithms block size */
2703         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2704         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2705                                 plaintext_pad_len);
2706         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2707
2708         /* Create KASUMI operation */
2709         retval = create_wireless_algo_hash_operation(tdata->digest.data,
2710                         tdata->digest.len,
2711                         NULL, 0,
2712                         plaintext_pad_len,
2713                         RTE_CRYPTO_AUTH_OP_VERIFY,
2714                         tdata->plaintext.len,
2715                         0);
2716         if (retval < 0)
2717                 return retval;
2718
2719         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2720                                 ut_params->op);
2721         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2722         ut_params->obuf = ut_params->op->sym->m_src;
2723         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2724                                 + plaintext_pad_len;
2725
2726         /* Validate obuf */
2727         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
2728                 return 0;
2729         else
2730                 return -1;
2731
2732         return 0;
2733 }
2734
2735 static int
2736 test_snow3g_hash_generate_test_case_1(void)
2737 {
2738         return test_snow3g_authentication(&snow3g_hash_test_case_1);
2739 }
2740
2741 static int
2742 test_snow3g_hash_generate_test_case_2(void)
2743 {
2744         return test_snow3g_authentication(&snow3g_hash_test_case_2);
2745 }
2746
2747 static int
2748 test_snow3g_hash_generate_test_case_3(void)
2749 {
2750         return test_snow3g_authentication(&snow3g_hash_test_case_3);
2751 }
2752
2753 static int
2754 test_snow3g_hash_generate_test_case_4(void)
2755 {
2756         return test_snow3g_authentication(&snow3g_hash_test_case_4);
2757 }
2758
2759 static int
2760 test_snow3g_hash_generate_test_case_5(void)
2761 {
2762         return test_snow3g_authentication(&snow3g_hash_test_case_5);
2763 }
2764
2765 static int
2766 test_snow3g_hash_generate_test_case_6(void)
2767 {
2768         return test_snow3g_authentication(&snow3g_hash_test_case_6);
2769 }
2770
2771 static int
2772 test_snow3g_hash_verify_test_case_1(void)
2773 {
2774         return test_snow3g_authentication_verify(&snow3g_hash_test_case_1);
2775
2776 }
2777
2778 static int
2779 test_snow3g_hash_verify_test_case_2(void)
2780 {
2781         return test_snow3g_authentication_verify(&snow3g_hash_test_case_2);
2782 }
2783
2784 static int
2785 test_snow3g_hash_verify_test_case_3(void)
2786 {
2787         return test_snow3g_authentication_verify(&snow3g_hash_test_case_3);
2788 }
2789
2790 static int
2791 test_snow3g_hash_verify_test_case_4(void)
2792 {
2793         return test_snow3g_authentication_verify(&snow3g_hash_test_case_4);
2794 }
2795
2796 static int
2797 test_snow3g_hash_verify_test_case_5(void)
2798 {
2799         return test_snow3g_authentication_verify(&snow3g_hash_test_case_5);
2800 }
2801
2802 static int
2803 test_snow3g_hash_verify_test_case_6(void)
2804 {
2805         return test_snow3g_authentication_verify(&snow3g_hash_test_case_6);
2806 }
2807
2808 static int
2809 test_kasumi_hash_generate_test_case_1(void)
2810 {
2811         return test_kasumi_authentication(&kasumi_hash_test_case_1);
2812 }
2813
2814 static int
2815 test_kasumi_hash_generate_test_case_2(void)
2816 {
2817         return test_kasumi_authentication(&kasumi_hash_test_case_2);
2818 }
2819
2820 static int
2821 test_kasumi_hash_generate_test_case_3(void)
2822 {
2823         return test_kasumi_authentication(&kasumi_hash_test_case_3);
2824 }
2825
2826 static int
2827 test_kasumi_hash_generate_test_case_4(void)
2828 {
2829         return test_kasumi_authentication(&kasumi_hash_test_case_4);
2830 }
2831
2832 static int
2833 test_kasumi_hash_generate_test_case_5(void)
2834 {
2835         return test_kasumi_authentication(&kasumi_hash_test_case_5);
2836 }
2837
2838 static int
2839 test_kasumi_hash_generate_test_case_6(void)
2840 {
2841         return test_kasumi_authentication(&kasumi_hash_test_case_6);
2842 }
2843
2844 static int
2845 test_kasumi_hash_verify_test_case_1(void)
2846 {
2847         return test_kasumi_authentication_verify(&kasumi_hash_test_case_1);
2848 }
2849
2850 static int
2851 test_kasumi_hash_verify_test_case_2(void)
2852 {
2853         return test_kasumi_authentication_verify(&kasumi_hash_test_case_2);
2854 }
2855
2856 static int
2857 test_kasumi_hash_verify_test_case_3(void)
2858 {
2859         return test_kasumi_authentication_verify(&kasumi_hash_test_case_3);
2860 }
2861
2862 static int
2863 test_kasumi_hash_verify_test_case_4(void)
2864 {
2865         return test_kasumi_authentication_verify(&kasumi_hash_test_case_4);
2866 }
2867
2868 static int
2869 test_kasumi_hash_verify_test_case_5(void)
2870 {
2871         return test_kasumi_authentication_verify(&kasumi_hash_test_case_5);
2872 }
2873
2874 static int
2875 test_kasumi_encryption(const struct kasumi_test_data *tdata)
2876 {
2877         struct crypto_testsuite_params *ts_params = &testsuite_params;
2878         struct crypto_unittest_params *ut_params = &unittest_params;
2879
2880         int retval;
2881         uint8_t *plaintext, *ciphertext;
2882         unsigned plaintext_pad_len;
2883         unsigned plaintext_len;
2884
2885         /* Verify the capabilities */
2886         struct rte_cryptodev_sym_capability_idx cap_idx;
2887         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2888         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
2889         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2890                         &cap_idx) == NULL)
2891                 return -ENOTSUP;
2892
2893         /* Create KASUMI session */
2894         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
2895                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2896                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
2897                                         tdata->key.data, tdata->key.len,
2898                                         tdata->cipher_iv.len);
2899         if (retval < 0)
2900                 return retval;
2901
2902         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2903
2904         /* Clear mbuf payload */
2905         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2906                rte_pktmbuf_tailroom(ut_params->ibuf));
2907
2908         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2909         /* Append data which is padded to a multiple */
2910         /* of the algorithms block size */
2911         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2912         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2913                                 plaintext_pad_len);
2914         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2915
2916         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
2917
2918         /* Create KASUMI operation */
2919         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
2920                                 tdata->cipher_iv.len,
2921                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
2922                                 tdata->validCipherOffsetInBits.len);
2923         if (retval < 0)
2924                 return retval;
2925
2926         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2927                                                 ut_params->op);
2928         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2929
2930         ut_params->obuf = ut_params->op->sym->m_dst;
2931         if (ut_params->obuf)
2932                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
2933         else
2934                 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
2935
2936         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
2937
2938         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
2939                                 (tdata->validCipherOffsetInBits.len >> 3);
2940         /* Validate obuf */
2941         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2942                 ciphertext,
2943                 reference_ciphertext,
2944                 tdata->validCipherLenInBits.len,
2945                 "KASUMI Ciphertext data not as expected");
2946         return 0;
2947 }
2948
2949 static int
2950 test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
2951 {
2952         struct crypto_testsuite_params *ts_params = &testsuite_params;
2953         struct crypto_unittest_params *ut_params = &unittest_params;
2954
2955         int retval;
2956
2957         unsigned int plaintext_pad_len;
2958         unsigned int plaintext_len;
2959
2960         uint8_t buffer[10000];
2961         const uint8_t *ciphertext;
2962
2963         struct rte_cryptodev_info dev_info;
2964
2965         /* Verify the capabilities */
2966         struct rte_cryptodev_sym_capability_idx cap_idx;
2967         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2968         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
2969         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2970                         &cap_idx) == NULL)
2971                 return -ENOTSUP;
2972
2973         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
2974
2975         uint64_t feat_flags = dev_info.feature_flags;
2976
2977         if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
2978                 printf("Device doesn't support in-place scatter-gather. "
2979                                 "Test Skipped.\n");
2980                 return -ENOTSUP;
2981         }
2982
2983         /* Create KASUMI session */
2984         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
2985                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2986                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
2987                                         tdata->key.data, tdata->key.len,
2988                                         tdata->cipher_iv.len);
2989         if (retval < 0)
2990                 return retval;
2991
2992         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2993
2994
2995         /* Append data which is padded to a multiple */
2996         /* of the algorithms block size */
2997         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2998
2999         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3000                         plaintext_pad_len, 10, 0);
3001
3002         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3003
3004         /* Create KASUMI operation */
3005         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3006                                 tdata->cipher_iv.len,
3007                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3008                                 tdata->validCipherOffsetInBits.len);
3009         if (retval < 0)
3010                 return retval;
3011
3012         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3013                                                 ut_params->op);
3014         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3015
3016         ut_params->obuf = ut_params->op->sym->m_dst;
3017
3018         if (ut_params->obuf)
3019                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3020                                 plaintext_len, buffer);
3021         else
3022                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3023                                 tdata->validCipherOffsetInBits.len >> 3,
3024                                 plaintext_len, buffer);
3025
3026         /* Validate obuf */
3027         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3028
3029         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3030                                 (tdata->validCipherOffsetInBits.len >> 3);
3031         /* Validate obuf */
3032         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3033                 ciphertext,
3034                 reference_ciphertext,
3035                 tdata->validCipherLenInBits.len,
3036                 "KASUMI Ciphertext data not as expected");
3037         return 0;
3038 }
3039
3040 static int
3041 test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
3042 {
3043         struct crypto_testsuite_params *ts_params = &testsuite_params;
3044         struct crypto_unittest_params *ut_params = &unittest_params;
3045
3046         int retval;
3047         uint8_t *plaintext, *ciphertext;
3048         unsigned plaintext_pad_len;
3049         unsigned plaintext_len;
3050
3051         /* Verify the capabilities */
3052         struct rte_cryptodev_sym_capability_idx cap_idx;
3053         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3054         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3055         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3056                         &cap_idx) == NULL)
3057                 return -ENOTSUP;
3058
3059         /* Create KASUMI session */
3060         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3061                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3062                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3063                                         tdata->key.data, tdata->key.len,
3064                                         tdata->cipher_iv.len);
3065         if (retval < 0)
3066                 return retval;
3067
3068         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3069         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3070
3071         /* Clear mbuf payload */
3072         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3073                rte_pktmbuf_tailroom(ut_params->ibuf));
3074
3075         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3076         /* Append data which is padded to a multiple */
3077         /* of the algorithms block size */
3078         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3079         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3080                                 plaintext_pad_len);
3081         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3082         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3083
3084         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3085
3086         /* Create KASUMI operation */
3087         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3088                                 tdata->cipher_iv.len,
3089                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3090                                 tdata->validCipherOffsetInBits.len);
3091         if (retval < 0)
3092                 return retval;
3093
3094         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3095                                                 ut_params->op);
3096         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3097
3098         ut_params->obuf = ut_params->op->sym->m_dst;
3099         if (ut_params->obuf)
3100                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3101         else
3102                 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3103
3104         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3105
3106         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3107                                 (tdata->validCipherOffsetInBits.len >> 3);
3108         /* Validate obuf */
3109         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3110                 ciphertext,
3111                 reference_ciphertext,
3112                 tdata->validCipherLenInBits.len,
3113                 "KASUMI Ciphertext data not as expected");
3114         return 0;
3115 }
3116
3117 static int
3118 test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
3119 {
3120         struct crypto_testsuite_params *ts_params = &testsuite_params;
3121         struct crypto_unittest_params *ut_params = &unittest_params;
3122
3123         int retval;
3124         unsigned int plaintext_pad_len;
3125         unsigned int plaintext_len;
3126
3127         const uint8_t *ciphertext;
3128         uint8_t buffer[2048];
3129
3130         struct rte_cryptodev_info dev_info;
3131
3132         /* Verify the capabilities */
3133         struct rte_cryptodev_sym_capability_idx cap_idx;
3134         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3135         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3136         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3137                         &cap_idx) == NULL)
3138                 return -ENOTSUP;
3139
3140         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3141
3142         uint64_t feat_flags = dev_info.feature_flags;
3143         if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
3144                 printf("Device doesn't support out-of-place scatter-gather "
3145                                 "in both input and output mbufs. "
3146                                 "Test Skipped.\n");
3147                 return -ENOTSUP;
3148         }
3149
3150         /* Create KASUMI session */
3151         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3152                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3153                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3154                                         tdata->key.data, tdata->key.len,
3155                                         tdata->cipher_iv.len);
3156         if (retval < 0)
3157                 return retval;
3158
3159         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3160         /* Append data which is padded to a multiple */
3161         /* of the algorithms block size */
3162         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3163
3164         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3165                         plaintext_pad_len, 10, 0);
3166         ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
3167                         plaintext_pad_len, 3, 0);
3168
3169         /* Append data which is padded to a multiple */
3170         /* of the algorithms block size */
3171         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3172
3173         /* Create KASUMI operation */
3174         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3175                                 tdata->cipher_iv.len,
3176                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3177                                 tdata->validCipherOffsetInBits.len);
3178         if (retval < 0)
3179                 return retval;
3180
3181         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3182                                                 ut_params->op);
3183         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3184
3185         ut_params->obuf = ut_params->op->sym->m_dst;
3186         if (ut_params->obuf)
3187                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3188                                 plaintext_pad_len, buffer);
3189         else
3190                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3191                                 tdata->validCipherOffsetInBits.len >> 3,
3192                                 plaintext_pad_len, buffer);
3193
3194         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3195                                 (tdata->validCipherOffsetInBits.len >> 3);
3196         /* Validate obuf */
3197         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3198                 ciphertext,
3199                 reference_ciphertext,
3200                 tdata->validCipherLenInBits.len,
3201                 "KASUMI Ciphertext data not as expected");
3202         return 0;
3203 }
3204
3205
3206 static int
3207 test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
3208 {
3209         struct crypto_testsuite_params *ts_params = &testsuite_params;
3210         struct crypto_unittest_params *ut_params = &unittest_params;
3211
3212         int retval;
3213         uint8_t *ciphertext, *plaintext;
3214         unsigned ciphertext_pad_len;
3215         unsigned ciphertext_len;
3216
3217         /* Verify the capabilities */
3218         struct rte_cryptodev_sym_capability_idx cap_idx;
3219         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3220         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3221         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3222                         &cap_idx) == NULL)
3223                 return -ENOTSUP;
3224
3225         /* Create KASUMI session */
3226         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3227                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
3228                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3229                                         tdata->key.data, tdata->key.len,
3230                                         tdata->cipher_iv.len);
3231         if (retval < 0)
3232                 return retval;
3233
3234         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3235         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3236
3237         /* Clear mbuf payload */
3238         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3239                rte_pktmbuf_tailroom(ut_params->ibuf));
3240
3241         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3242         /* Append data which is padded to a multiple */
3243         /* of the algorithms block size */
3244         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
3245         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3246                                 ciphertext_pad_len);
3247         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
3248         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3249
3250         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
3251
3252         /* Create KASUMI operation */
3253         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3254                                 tdata->cipher_iv.len,
3255                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3256                                 tdata->validCipherOffsetInBits.len);
3257         if (retval < 0)
3258                 return retval;
3259
3260         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3261                                                 ut_params->op);
3262         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3263
3264         ut_params->obuf = ut_params->op->sym->m_dst;
3265         if (ut_params->obuf)
3266                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3267         else
3268                 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
3269
3270         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
3271
3272         const uint8_t *reference_plaintext = tdata->plaintext.data +
3273                                 (tdata->validCipherOffsetInBits.len >> 3);
3274         /* Validate obuf */
3275         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3276                 plaintext,
3277                 reference_plaintext,
3278                 tdata->validCipherLenInBits.len,
3279                 "KASUMI Plaintext data not as expected");
3280         return 0;
3281 }
3282
3283 static int
3284 test_kasumi_decryption(const struct kasumi_test_data *tdata)
3285 {
3286         struct crypto_testsuite_params *ts_params = &testsuite_params;
3287         struct crypto_unittest_params *ut_params = &unittest_params;
3288
3289         int retval;
3290         uint8_t *ciphertext, *plaintext;
3291         unsigned ciphertext_pad_len;
3292         unsigned ciphertext_len;
3293
3294         /* Verify the capabilities */
3295         struct rte_cryptodev_sym_capability_idx cap_idx;
3296         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3297         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3298         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3299                         &cap_idx) == NULL)
3300                 return -ENOTSUP;
3301
3302         /* Create KASUMI session */
3303         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3304                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
3305                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3306                                         tdata->key.data, tdata->key.len,
3307                                         tdata->cipher_iv.len);
3308         if (retval < 0)
3309                 return retval;
3310
3311         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3312
3313         /* Clear mbuf payload */
3314         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3315                rte_pktmbuf_tailroom(ut_params->ibuf));
3316
3317         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3318         /* Append data which is padded to a multiple */
3319         /* of the algorithms block size */
3320         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
3321         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3322                                 ciphertext_pad_len);
3323         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3324
3325         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
3326
3327         /* Create KASUMI operation */
3328         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3329                                         tdata->cipher_iv.len,
3330                                         tdata->ciphertext.len,
3331                                         tdata->validCipherOffsetInBits.len);
3332         if (retval < 0)
3333                 return retval;
3334
3335         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3336                                                 ut_params->op);
3337         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3338
3339         ut_params->obuf = ut_params->op->sym->m_dst;
3340         if (ut_params->obuf)
3341                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3342         else
3343                 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
3344
3345         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
3346
3347         const uint8_t *reference_plaintext = tdata->plaintext.data +
3348                                 (tdata->validCipherOffsetInBits.len >> 3);
3349         /* Validate obuf */
3350         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3351                 plaintext,
3352                 reference_plaintext,
3353                 tdata->validCipherLenInBits.len,
3354                 "KASUMI Plaintext data not as expected");
3355         return 0;
3356 }
3357
3358 static int
3359 test_snow3g_encryption(const struct snow3g_test_data *tdata)
3360 {
3361         struct crypto_testsuite_params *ts_params = &testsuite_params;
3362         struct crypto_unittest_params *ut_params = &unittest_params;
3363
3364         int retval;
3365         uint8_t *plaintext, *ciphertext;
3366         unsigned plaintext_pad_len;
3367         unsigned plaintext_len;
3368
3369         /* Verify the capabilities */
3370         struct rte_cryptodev_sym_capability_idx cap_idx;
3371         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3372         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
3373         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3374                         &cap_idx) == NULL)
3375                 return -ENOTSUP;
3376
3377         /* Create SNOW 3G session */
3378         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3379                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3380                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3381                                         tdata->key.data, tdata->key.len,
3382                                         tdata->cipher_iv.len);
3383         if (retval < 0)
3384                 return retval;
3385
3386         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3387
3388         /* Clear mbuf payload */
3389         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3390                rte_pktmbuf_tailroom(ut_params->ibuf));
3391
3392         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3393         /* Append data which is padded to a multiple of */
3394         /* the algorithms block size */
3395         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3396         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3397                                 plaintext_pad_len);
3398         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3399
3400         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3401
3402         /* Create SNOW 3G operation */
3403         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3404                                         tdata->cipher_iv.len,
3405                                         tdata->validCipherLenInBits.len,
3406                                         0);
3407         if (retval < 0)
3408                 return retval;
3409
3410         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3411                                                 ut_params->op);
3412         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3413
3414         ut_params->obuf = ut_params->op->sym->m_dst;
3415         if (ut_params->obuf)
3416                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3417         else
3418                 ciphertext = plaintext;
3419
3420         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3421
3422         /* Validate obuf */
3423         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3424                 ciphertext,
3425                 tdata->ciphertext.data,
3426                 tdata->validDataLenInBits.len,
3427                 "SNOW 3G Ciphertext data not as expected");
3428         return 0;
3429 }
3430
3431
3432 static int
3433 test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
3434 {
3435         struct crypto_testsuite_params *ts_params = &testsuite_params;
3436         struct crypto_unittest_params *ut_params = &unittest_params;
3437         uint8_t *plaintext, *ciphertext;
3438
3439         int retval;
3440         unsigned plaintext_pad_len;
3441         unsigned plaintext_len;
3442
3443         /* Verify the capabilities */
3444         struct rte_cryptodev_sym_capability_idx cap_idx;
3445         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3446         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
3447         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3448                         &cap_idx) == NULL)
3449                 return -ENOTSUP;
3450
3451         /* Create SNOW 3G session */
3452         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3453                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3454                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3455                                         tdata->key.data, tdata->key.len,
3456                                         tdata->cipher_iv.len);
3457         if (retval < 0)
3458                 return retval;
3459
3460         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3461         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3462
3463         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3464                         "Failed to allocate input buffer in mempool");
3465         TEST_ASSERT_NOT_NULL(ut_params->obuf,
3466                         "Failed to allocate output buffer in mempool");
3467
3468         /* Clear mbuf payload */
3469         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3470                rte_pktmbuf_tailroom(ut_params->ibuf));
3471
3472         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3473         /* Append data which is padded to a multiple of */
3474         /* the algorithms block size */
3475         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3476         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3477                                 plaintext_pad_len);
3478         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3479         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3480
3481         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3482
3483         /* Create SNOW 3G operation */
3484         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3485                                         tdata->cipher_iv.len,
3486                                         tdata->validCipherLenInBits.len,
3487                                         0);
3488         if (retval < 0)
3489                 return retval;
3490
3491         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3492                                                 ut_params->op);
3493         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3494
3495         ut_params->obuf = ut_params->op->sym->m_dst;
3496         if (ut_params->obuf)
3497                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3498         else
3499                 ciphertext = plaintext;
3500
3501         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3502
3503         /* Validate obuf */
3504         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3505                 ciphertext,
3506                 tdata->ciphertext.data,
3507                 tdata->validDataLenInBits.len,
3508                 "SNOW 3G Ciphertext data not as expected");
3509         return 0;
3510 }
3511
3512 static int
3513 test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
3514 {
3515         struct crypto_testsuite_params *ts_params = &testsuite_params;
3516         struct crypto_unittest_params *ut_params = &unittest_params;
3517
3518         int retval;
3519         unsigned int plaintext_pad_len;
3520         unsigned int plaintext_len;
3521         uint8_t buffer[10000];
3522         const uint8_t *ciphertext;
3523
3524         struct rte_cryptodev_info dev_info;
3525
3526         /* Verify the capabilities */
3527         struct rte_cryptodev_sym_capability_idx cap_idx;
3528         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3529         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
3530         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3531                         &cap_idx) == NULL)
3532                 return -ENOTSUP;
3533
3534         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3535
3536         uint64_t feat_flags = dev_info.feature_flags;
3537
3538         if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
3539                 printf("Device doesn't support out-of-place scatter-gather "
3540                                 "in both input and output mbufs. "
3541                                 "Test Skipped.\n");
3542                 return -ENOTSUP;
3543         }
3544
3545         /* Create SNOW 3G session */
3546         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3547                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3548                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3549                                         tdata->key.data, tdata->key.len,
3550                                         tdata->cipher_iv.len);
3551         if (retval < 0)
3552                 return retval;
3553
3554         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3555         /* Append data which is padded to a multiple of */
3556         /* the algorithms block size */
3557         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3558
3559         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3560                         plaintext_pad_len, 10, 0);
3561         ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
3562                         plaintext_pad_len, 3, 0);
3563
3564         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3565                         "Failed to allocate input buffer in mempool");
3566         TEST_ASSERT_NOT_NULL(ut_params->obuf,
3567                         "Failed to allocate output buffer in mempool");
3568
3569         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3570
3571         /* Create SNOW 3G operation */
3572         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3573                                         tdata->cipher_iv.len,
3574                                         tdata->validCipherLenInBits.len,
3575                                         0);
3576         if (retval < 0)
3577                 return retval;
3578
3579         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3580                                                 ut_params->op);
3581         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3582
3583         ut_params->obuf = ut_params->op->sym->m_dst;
3584         if (ut_params->obuf)
3585                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3586                                 plaintext_len, buffer);
3587         else
3588                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
3589                                 plaintext_len, buffer);
3590
3591         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3592
3593         /* Validate obuf */
3594         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3595                 ciphertext,
3596                 tdata->ciphertext.data,
3597                 tdata->validDataLenInBits.len,
3598                 "SNOW 3G Ciphertext data not as expected");
3599
3600         return 0;
3601 }
3602
3603 /* Shift right a buffer by "offset" bits, "offset" < 8 */
3604 static void
3605 buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset)
3606 {
3607         uint8_t curr_byte, prev_byte;
3608         uint32_t length_in_bytes = ceil_byte_length(length + offset);
3609         uint8_t lower_byte_mask = (1 << offset) - 1;
3610         unsigned i;
3611
3612         prev_byte = buffer[0];
3613         buffer[0] >>= offset;
3614
3615         for (i = 1; i < length_in_bytes; i++) {
3616                 curr_byte = buffer[i];
3617                 buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) |
3618                                 (curr_byte >> offset);
3619                 prev_byte = curr_byte;
3620         }
3621 }
3622
3623 static int
3624 test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
3625 {
3626         struct crypto_testsuite_params *ts_params = &testsuite_params;
3627         struct crypto_unittest_params *ut_params = &unittest_params;
3628         uint8_t *plaintext, *ciphertext;
3629         int retval;
3630         uint32_t plaintext_len;
3631         uint32_t plaintext_pad_len;
3632         uint8_t extra_offset = 4;
3633         uint8_t *expected_ciphertext_shifted;
3634         struct rte_cryptodev_info dev_info;
3635
3636         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3637         uint64_t feat_flags = dev_info.feature_flags;
3638
3639         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
3640                         ((tdata->validDataLenInBits.len % 8) != 0)) {
3641                 printf("Device doesn't support NON-Byte Aligned Data.\n");
3642                 return -ENOTSUP;
3643         }
3644
3645         /* Verify the capabilities */
3646         struct rte_cryptodev_sym_capability_idx cap_idx;
3647         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3648         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
3649         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3650                         &cap_idx) == NULL)
3651                 return -ENOTSUP;
3652
3653         /* Create SNOW 3G session */
3654         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3655                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3656                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3657                                         tdata->key.data, tdata->key.len,
3658                                         tdata->cipher_iv.len);
3659         if (retval < 0)
3660                 return retval;
3661
3662         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3663         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3664
3665         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3666                         "Failed to allocate input buffer in mempool");
3667         TEST_ASSERT_NOT_NULL(ut_params->obuf,
3668                         "Failed to allocate output buffer in mempool");
3669
3670         /* Clear mbuf payload */
3671         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3672                rte_pktmbuf_tailroom(ut_params->ibuf));
3673
3674         plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset);
3675         /*
3676          * Append data which is padded to a
3677          * multiple of the algorithms block size
3678          */
3679         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3680
3681         plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf,
3682                                                 plaintext_pad_len);
3683
3684         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3685
3686         memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3));
3687         buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset);
3688
3689 #ifdef RTE_APP_TEST_DEBUG
3690         rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
3691 #endif
3692         /* Create SNOW 3G operation */
3693         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3694                                         tdata->cipher_iv.len,
3695                                         tdata->validCipherLenInBits.len,
3696                                         extra_offset);
3697         if (retval < 0)
3698                 return retval;
3699
3700         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3701                                                 ut_params->op);
3702         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3703
3704         ut_params->obuf = ut_params->op->sym->m_dst;
3705         if (ut_params->obuf)
3706                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3707         else
3708                 ciphertext = plaintext;
3709
3710 #ifdef RTE_APP_TEST_DEBUG
3711         rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3712 #endif
3713
3714         expected_ciphertext_shifted = rte_malloc(NULL, plaintext_len, 8);
3715
3716         TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted,
3717                         "failed to reserve memory for ciphertext shifted\n");
3718
3719         memcpy(expected_ciphertext_shifted, tdata->ciphertext.data,
3720                         ceil_byte_length(tdata->ciphertext.len));
3721         buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len,
3722                         extra_offset);
3723         /* Validate obuf */
3724         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
3725                 ciphertext,
3726                 expected_ciphertext_shifted,
3727                 tdata->validDataLenInBits.len,
3728                 extra_offset,
3729                 "SNOW 3G Ciphertext data not as expected");
3730         return 0;
3731 }
3732
3733 static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
3734 {
3735         struct crypto_testsuite_params *ts_params = &testsuite_params;
3736         struct crypto_unittest_params *ut_params = &unittest_params;
3737
3738         int retval;
3739
3740         uint8_t *plaintext, *ciphertext;
3741         unsigned ciphertext_pad_len;
3742         unsigned ciphertext_len;
3743
3744         /* Verify the capabilities */
3745         struct rte_cryptodev_sym_capability_idx cap_idx;
3746         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3747         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
3748         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3749                         &cap_idx) == NULL)
3750                 return -ENOTSUP;
3751
3752         /* Create SNOW 3G session */
3753         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3754                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
3755                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3756                                         tdata->key.data, tdata->key.len,
3757                                         tdata->cipher_iv.len);
3758         if (retval < 0)
3759                 return retval;
3760
3761         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3762
3763         /* Clear mbuf payload */
3764         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3765                rte_pktmbuf_tailroom(ut_params->ibuf));
3766
3767         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3768         /* Append data which is padded to a multiple of */
3769         /* the algorithms block size */
3770         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
3771         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3772                                 ciphertext_pad_len);
3773         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3774
3775         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
3776
3777         /* Create SNOW 3G operation */
3778         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3779                                         tdata->cipher_iv.len,
3780                                         tdata->validCipherLenInBits.len,
3781                                         tdata->cipher.offset_bits);
3782         if (retval < 0)
3783                 return retval;
3784
3785         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3786                                                 ut_params->op);
3787         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3788         ut_params->obuf = ut_params->op->sym->m_dst;
3789         if (ut_params->obuf)
3790                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3791         else
3792                 plaintext = ciphertext;
3793
3794         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
3795
3796         /* Validate obuf */
3797         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
3798                                 tdata->plaintext.data,
3799                                 tdata->validDataLenInBits.len,
3800                                 "SNOW 3G Plaintext data not as expected");
3801         return 0;
3802 }
3803
3804 static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
3805 {
3806         struct crypto_testsuite_params *ts_params = &testsuite_params;
3807         struct crypto_unittest_params *ut_params = &unittest_params;
3808
3809         int retval;
3810
3811         uint8_t *plaintext, *ciphertext;
3812         unsigned ciphertext_pad_len;
3813         unsigned ciphertext_len;
3814
3815         /* Verify the capabilities */
3816         struct rte_cryptodev_sym_capability_idx cap_idx;
3817         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3818         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
3819         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3820                         &cap_idx) == NULL)
3821                 return -ENOTSUP;
3822
3823         /* Create SNOW 3G session */
3824         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3825                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
3826                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3827                                         tdata->key.data, tdata->key.len,
3828                                         tdata->cipher_iv.len);
3829         if (retval < 0)
3830                 return retval;
3831
3832         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3833         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3834
3835         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3836                         "Failed to allocate input buffer");
3837         TEST_ASSERT_NOT_NULL(ut_params->obuf,
3838                         "Failed to allocate output buffer");
3839
3840         /* Clear mbuf payload */
3841         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3842                rte_pktmbuf_tailroom(ut_params->ibuf));
3843
3844         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
3845                        rte_pktmbuf_tailroom(ut_params->obuf));
3846
3847         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3848         /* Append data which is padded to a multiple of */
3849         /* the algorithms block size */
3850         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
3851         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3852                                 ciphertext_pad_len);
3853         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
3854         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3855
3856         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
3857
3858         /* Create SNOW 3G operation */
3859         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3860                                         tdata->cipher_iv.len,
3861                                         tdata->validCipherLenInBits.len,
3862                                         0);
3863         if (retval < 0)
3864                 return retval;
3865
3866         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3867                                                 ut_params->op);
3868         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3869         ut_params->obuf = ut_params->op->sym->m_dst;
3870         if (ut_params->obuf)
3871                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3872         else
3873                 plaintext = ciphertext;
3874
3875         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
3876
3877         /* Validate obuf */
3878         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
3879                                 tdata->plaintext.data,
3880                                 tdata->validDataLenInBits.len,
3881                                 "SNOW 3G Plaintext data not as expected");
3882         return 0;
3883 }
3884
3885 static int
3886 test_zuc_cipher_auth(const struct wireless_test_data *tdata)
3887 {
3888         struct crypto_testsuite_params *ts_params = &testsuite_params;
3889         struct crypto_unittest_params *ut_params = &unittest_params;
3890
3891         int retval;
3892
3893         uint8_t *plaintext, *ciphertext;
3894         unsigned int plaintext_pad_len;
3895         unsigned int plaintext_len;
3896
3897         struct rte_cryptodev_info dev_info;
3898         struct rte_cryptodev_sym_capability_idx cap_idx;
3899
3900         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3901         uint64_t feat_flags = dev_info.feature_flags;
3902
3903         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
3904                         ((tdata->validAuthLenInBits.len % 8 != 0) ||
3905                         (tdata->validDataLenInBits.len % 8 != 0))) {
3906                 printf("Device doesn't support NON-Byte Aligned Data.\n");
3907                 return -ENOTSUP;
3908         }
3909
3910         /* Check if device supports ZUC EEA3 */
3911         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3912         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
3913
3914         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3915                         &cap_idx) == NULL)
3916                 return -ENOTSUP;
3917
3918         /* Check if device supports ZUC EIA3 */
3919         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3920         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
3921
3922         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3923                         &cap_idx) == NULL)
3924                 return -ENOTSUP;
3925
3926         /* Create ZUC session */
3927         retval = create_zuc_cipher_auth_encrypt_generate_session(
3928                         ts_params->valid_devs[0],
3929                         tdata);
3930         if (retval < 0)
3931                 return retval;
3932         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3933
3934         /* clear mbuf payload */
3935         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3936                         rte_pktmbuf_tailroom(ut_params->ibuf));
3937
3938         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3939         /* Append data which is padded to a multiple of */
3940         /* the algorithms block size */
3941         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3942         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3943                                 plaintext_pad_len);
3944         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3945
3946         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3947
3948         /* Create ZUC operation */
3949         retval = create_zuc_cipher_hash_generate_operation(tdata);
3950         if (retval < 0)
3951                 return retval;
3952
3953         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3954                         ut_params->op);
3955         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3956         ut_params->obuf = ut_params->op->sym->m_src;
3957         if (ut_params->obuf)
3958                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3959         else
3960                 ciphertext = plaintext;
3961
3962         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3963         /* Validate obuf */
3964         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3965                         ciphertext,
3966                         tdata->ciphertext.data,
3967                         tdata->validDataLenInBits.len,
3968                         "ZUC Ciphertext data not as expected");
3969
3970         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3971             + plaintext_pad_len;
3972
3973         /* Validate obuf */
3974         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3975                         ut_params->digest,
3976                         tdata->digest.data,
3977                         4,
3978                         "ZUC Generated auth tag not as expected");
3979         return 0;
3980 }
3981
3982 static int
3983 test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
3984 {
3985         struct crypto_testsuite_params *ts_params = &testsuite_params;
3986         struct crypto_unittest_params *ut_params = &unittest_params;
3987
3988         int retval;
3989
3990         uint8_t *plaintext, *ciphertext;
3991         unsigned plaintext_pad_len;
3992         unsigned plaintext_len;
3993
3994         /* Verify the capabilities */
3995         struct rte_cryptodev_sym_capability_idx cap_idx;
3996         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3997         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
3998         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3999                         &cap_idx) == NULL)
4000                 return -ENOTSUP;
4001         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4002         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4003         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4004                         &cap_idx) == NULL)
4005                 return -ENOTSUP;
4006
4007         /* Create SNOW 3G session */
4008         retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0],
4009                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4010                         RTE_CRYPTO_AUTH_OP_GENERATE,
4011                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4012                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4013                         tdata->key.data, tdata->key.len,
4014                         tdata->auth_iv.len, tdata->digest.len,
4015                         tdata->cipher_iv.len);
4016         if (retval < 0)
4017                 return retval;
4018         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4019
4020         /* clear mbuf payload */
4021         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4022                         rte_pktmbuf_tailroom(ut_params->ibuf));
4023
4024         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4025         /* Append data which is padded to a multiple of */
4026         /* the algorithms block size */
4027         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4028         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4029                                 plaintext_pad_len);
4030         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4031
4032         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4033
4034         /* Create SNOW 3G operation */
4035         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
4036                         tdata->digest.len, tdata->auth_iv.data,
4037                         tdata->auth_iv.len,
4038                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
4039                         tdata->cipher_iv.data, tdata->cipher_iv.len,
4040                         tdata->validCipherLenInBits.len,
4041                         0,
4042                         tdata->validAuthLenInBits.len,
4043                         0
4044                         );
4045         if (retval < 0)
4046                 return retval;
4047
4048         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4049                         ut_params->op);
4050         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4051         ut_params->obuf = ut_params->op->sym->m_src;
4052         if (ut_params->obuf)
4053                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4054         else
4055                 ciphertext = plaintext;
4056
4057         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4058         /* Validate obuf */
4059         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4060                         ciphertext,
4061                         tdata->ciphertext.data,
4062                         tdata->validDataLenInBits.len,
4063                         "SNOW 3G Ciphertext data not as expected");
4064
4065         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4066             + plaintext_pad_len;
4067
4068         /* Validate obuf */
4069         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4070                         ut_params->digest,
4071                         tdata->digest.data,
4072                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4073                         "SNOW 3G Generated auth tag not as expected");
4074         return 0;
4075 }
4076
4077 static int
4078 test_snow3g_auth_cipher(const struct snow3g_test_data *tdata,
4079         uint8_t op_mode, uint8_t verify)
4080 {
4081         struct crypto_testsuite_params *ts_params = &testsuite_params;
4082         struct crypto_unittest_params *ut_params = &unittest_params;
4083
4084         int retval;
4085
4086         uint8_t *plaintext = NULL, *ciphertext = NULL;
4087         unsigned int plaintext_pad_len;
4088         unsigned int plaintext_len;
4089         unsigned int ciphertext_pad_len;
4090         unsigned int ciphertext_len;
4091
4092         struct rte_cryptodev_info dev_info;
4093
4094         /* Verify the capabilities */
4095         struct rte_cryptodev_sym_capability_idx cap_idx;
4096         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4097         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
4098         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4099                         &cap_idx) == NULL)
4100                 return -ENOTSUP;
4101         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4102         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4103         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4104                         &cap_idx) == NULL)
4105                 return -ENOTSUP;
4106
4107         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4108
4109         uint64_t feat_flags = dev_info.feature_flags;
4110
4111         if (op_mode == OUT_OF_PLACE) {
4112                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
4113                         printf("Device doesn't support digest encrypted.\n");
4114                         return -ENOTSUP;
4115                 }
4116         }
4117
4118         /* Create SNOW 3G session */
4119         retval = create_wireless_algo_auth_cipher_session(
4120                         ts_params->valid_devs[0],
4121                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
4122                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
4123                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
4124                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
4125                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4126                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4127                         tdata->key.data, tdata->key.len,
4128                         tdata->auth_iv.len, tdata->digest.len,
4129                         tdata->cipher_iv.len);
4130
4131         if (retval < 0)
4132                 return retval;
4133
4134         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4135         if (op_mode == OUT_OF_PLACE)
4136                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4137
4138         /* clear mbuf payload */
4139         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4140                 rte_pktmbuf_tailroom(ut_params->ibuf));
4141         if (op_mode == OUT_OF_PLACE)
4142                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
4143                         rte_pktmbuf_tailroom(ut_params->obuf));
4144
4145         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4146         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4147         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4148         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4149
4150         if (verify) {
4151                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4152                                         ciphertext_pad_len);
4153                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4154                 if (op_mode == OUT_OF_PLACE)
4155                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4156                 debug_hexdump(stdout, "ciphertext:", ciphertext,
4157                         ciphertext_len);
4158         } else {
4159                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4160                                         plaintext_pad_len);
4161                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4162                 if (op_mode == OUT_OF_PLACE)
4163                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4164                 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4165         }
4166
4167         /* Create SNOW 3G operation */
4168         retval = create_wireless_algo_auth_cipher_operation(
4169                 tdata->digest.data, tdata->digest.len,
4170                 tdata->cipher_iv.data, tdata->cipher_iv.len,
4171                 tdata->auth_iv.data, tdata->auth_iv.len,
4172                 (tdata->digest.offset_bytes == 0 ?
4173                 (verify ? ciphertext_pad_len : plaintext_pad_len)
4174                         : tdata->digest.offset_bytes),
4175                 tdata->validCipherLenInBits.len,
4176                 tdata->cipher.offset_bits,
4177                 tdata->validAuthLenInBits.len,
4178                 tdata->auth.offset_bits,
4179                 op_mode, 0, verify);
4180
4181         if (retval < 0)
4182                 return retval;
4183
4184         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4185                         ut_params->op);
4186
4187         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4188
4189         ut_params->obuf = (op_mode == IN_PLACE ?
4190                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
4191
4192         if (verify) {
4193                 if (ut_params->obuf)
4194                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
4195                                                         uint8_t *);
4196                 else
4197                         plaintext = ciphertext +
4198                                 (tdata->cipher.offset_bits >> 3);
4199
4200                 debug_hexdump(stdout, "plaintext:", plaintext,
4201                         (tdata->plaintext.len >> 3) - tdata->digest.len);
4202                 debug_hexdump(stdout, "plaintext expected:",
4203                         tdata->plaintext.data,
4204                         (tdata->plaintext.len >> 3) - tdata->digest.len);
4205         } else {
4206                 if (ut_params->obuf)
4207                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
4208                                                         uint8_t *);
4209                 else
4210                         ciphertext = plaintext;
4211
4212                 debug_hexdump(stdout, "ciphertext:", ciphertext,
4213                         ciphertext_len);
4214                 debug_hexdump(stdout, "ciphertext expected:",
4215                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
4216
4217                 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4218                         + (tdata->digest.offset_bytes == 0 ?
4219                 plaintext_pad_len : tdata->digest.offset_bytes);
4220
4221                 debug_hexdump(stdout, "digest:", ut_params->digest,
4222                         tdata->digest.len);
4223                 debug_hexdump(stdout, "digest expected:", tdata->digest.data,
4224                                 tdata->digest.len);
4225         }
4226
4227         /* Validate obuf */
4228         if (verify) {
4229                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4230                         plaintext,
4231                         tdata->plaintext.data,
4232                         tdata->plaintext.len >> 3,
4233                         "SNOW 3G Plaintext data not as expected");
4234         } else {
4235                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4236                         ciphertext,
4237                         tdata->ciphertext.data,
4238                         tdata->validDataLenInBits.len,
4239                         "SNOW 3G Ciphertext data not as expected");
4240
4241                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4242                         ut_params->digest,
4243                         tdata->digest.data,
4244                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4245                         "SNOW 3G Generated auth tag not as expected");
4246         }
4247         return 0;
4248 }
4249
4250 static int
4251 test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata,
4252         uint8_t op_mode, uint8_t verify)
4253 {
4254         struct crypto_testsuite_params *ts_params = &testsuite_params;
4255         struct crypto_unittest_params *ut_params = &unittest_params;
4256
4257         int retval;
4258
4259         const uint8_t *plaintext = NULL;
4260         const uint8_t *ciphertext = NULL;
4261         const uint8_t *digest = NULL;
4262         unsigned int plaintext_pad_len;
4263         unsigned int plaintext_len;
4264         unsigned int ciphertext_pad_len;
4265         unsigned int ciphertext_len;
4266         uint8_t buffer[10000];
4267         uint8_t digest_buffer[10000];
4268
4269         struct rte_cryptodev_info dev_info;
4270
4271         /* Verify the capabilities */
4272         struct rte_cryptodev_sym_capability_idx cap_idx;
4273         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4274         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
4275         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4276                         &cap_idx) == NULL)
4277                 return -ENOTSUP;
4278         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4279         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4280         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4281                         &cap_idx) == NULL)
4282                 return -ENOTSUP;
4283
4284         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4285
4286         uint64_t feat_flags = dev_info.feature_flags;
4287
4288         if (op_mode == IN_PLACE) {
4289                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
4290                         printf("Device doesn't support in-place scatter-gather "
4291                                         "in both input and output mbufs.\n");
4292                         return -ENOTSUP;
4293                 }
4294         } else {
4295                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
4296                         printf("Device doesn't support out-of-place scatter-gather "
4297                                         "in both input and output mbufs.\n");
4298                         return -ENOTSUP;
4299                 }
4300                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
4301                         printf("Device doesn't support digest encrypted.\n");
4302                         return -ENOTSUP;
4303                 }
4304         }
4305
4306         /* Create SNOW 3G session */
4307         retval = create_wireless_algo_auth_cipher_session(
4308                         ts_params->valid_devs[0],
4309                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
4310                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
4311                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
4312                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
4313                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4314                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4315                         tdata->key.data, tdata->key.len,
4316                         tdata->auth_iv.len, tdata->digest.len,
4317                         tdata->cipher_iv.len);
4318
4319         if (retval < 0)
4320                 return retval;
4321
4322         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4323         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4324         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4325         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4326
4327         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
4328                         plaintext_pad_len, 15, 0);
4329         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4330                         "Failed to allocate input buffer in mempool");
4331
4332         if (op_mode == OUT_OF_PLACE) {
4333                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
4334                                 plaintext_pad_len, 15, 0);
4335                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
4336                                 "Failed to allocate output buffer in mempool");
4337         }
4338
4339         if (verify) {
4340                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
4341                         tdata->ciphertext.data);
4342                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
4343                                         ciphertext_len, buffer);
4344                 debug_hexdump(stdout, "ciphertext:", ciphertext,
4345                         ciphertext_len);
4346         } else {
4347                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
4348                         tdata->plaintext.data);
4349                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
4350                                         plaintext_len, buffer);
4351                 debug_hexdump(stdout, "plaintext:", plaintext,
4352                         plaintext_len);
4353         }
4354         memset(buffer, 0, sizeof(buffer));
4355
4356         /* Create SNOW 3G operation */
4357         retval = create_wireless_algo_auth_cipher_operation(
4358                 tdata->digest.data, tdata->digest.len,
4359                 tdata->cipher_iv.data, tdata->cipher_iv.len,
4360                 tdata->auth_iv.data, tdata->auth_iv.len,
4361                 (tdata->digest.offset_bytes == 0 ?
4362                 (verify ? ciphertext_pad_len : plaintext_pad_len)
4363                         : tdata->digest.offset_bytes),
4364                 tdata->validCipherLenInBits.len,
4365                 tdata->cipher.offset_bits,
4366                 tdata->validAuthLenInBits.len,
4367                 tdata->auth.offset_bits,
4368                 op_mode, 1, verify);
4369
4370         if (retval < 0)
4371                 return retval;
4372
4373         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4374                         ut_params->op);
4375
4376         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4377
4378         ut_params->obuf = (op_mode == IN_PLACE ?
4379                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
4380
4381         if (verify) {
4382                 if (ut_params->obuf)
4383                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
4384                                         plaintext_len, buffer);
4385                 else
4386                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
4387                                         plaintext_len, buffer);
4388
4389                 debug_hexdump(stdout, "plaintext:", plaintext,
4390                         (tdata->plaintext.len >> 3) - tdata->digest.len);
4391                 debug_hexdump(stdout, "plaintext expected:",
4392                         tdata->plaintext.data,
4393                         (tdata->plaintext.len >> 3) - tdata->digest.len);
4394         } else {
4395                 if (ut_params->obuf)
4396                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
4397                                         ciphertext_len, buffer);
4398                 else
4399                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
4400                                         ciphertext_len, buffer);
4401
4402                 debug_hexdump(stdout, "ciphertext:", ciphertext,
4403                         ciphertext_len);
4404                 debug_hexdump(stdout, "ciphertext expected:",
4405                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
4406
4407                 if (ut_params->obuf)
4408                         digest = rte_pktmbuf_read(ut_params->obuf,
4409                                 (tdata->digest.offset_bytes == 0 ?
4410                                 plaintext_pad_len : tdata->digest.offset_bytes),
4411                                 tdata->digest.len, digest_buffer);
4412                 else
4413                         digest = rte_pktmbuf_read(ut_params->ibuf,
4414                                 (tdata->digest.offset_bytes == 0 ?
4415                                 plaintext_pad_len : tdata->digest.offset_bytes),
4416                                 tdata->digest.len, digest_buffer);
4417
4418                 debug_hexdump(stdout, "digest:", digest,
4419                         tdata->digest.len);
4420                 debug_hexdump(stdout, "digest expected:",
4421                         tdata->digest.data, tdata->digest.len);
4422         }
4423
4424         /* Validate obuf */
4425         if (verify) {
4426                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4427                         plaintext,
4428                         tdata->plaintext.data,
4429                         tdata->plaintext.len >> 3,
4430                         "SNOW 3G Plaintext data not as expected");
4431         } else {
4432                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4433                         ciphertext,
4434                         tdata->ciphertext.data,
4435                         tdata->validDataLenInBits.len,
4436                         "SNOW 3G Ciphertext data not as expected");
4437
4438                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4439                         digest,
4440                         tdata->digest.data,
4441                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4442                         "SNOW 3G Generated auth tag not as expected");
4443         }
4444         return 0;
4445 }
4446
4447 static int
4448 test_kasumi_auth_cipher(const struct kasumi_test_data *tdata,
4449         uint8_t op_mode, uint8_t verify)
4450 {
4451         struct crypto_testsuite_params *ts_params = &testsuite_params;
4452         struct crypto_unittest_params *ut_params = &unittest_params;
4453
4454         int retval;
4455
4456         uint8_t *plaintext = NULL, *ciphertext = NULL;
4457         unsigned int plaintext_pad_len;
4458         unsigned int plaintext_len;
4459         unsigned int ciphertext_pad_len;
4460         unsigned int ciphertext_len;
4461
4462         struct rte_cryptodev_info dev_info;
4463
4464         /* Verify the capabilities */
4465         struct rte_cryptodev_sym_capability_idx cap_idx;
4466         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4467         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
4468         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4469                         &cap_idx) == NULL)
4470                 return -ENOTSUP;
4471         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4472         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
4473         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4474                         &cap_idx) == NULL)
4475                 return -ENOTSUP;
4476
4477         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4478
4479         uint64_t feat_flags = dev_info.feature_flags;
4480
4481         if (op_mode == OUT_OF_PLACE) {
4482                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
4483                         printf("Device doesn't support digest encrypted.\n");
4484                         return -ENOTSUP;
4485                 }
4486         }
4487
4488         /* Create KASUMI session */
4489         retval = create_wireless_algo_auth_cipher_session(
4490                         ts_params->valid_devs[0],
4491                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
4492                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
4493                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
4494                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
4495                         RTE_CRYPTO_AUTH_KASUMI_F9,
4496                         RTE_CRYPTO_CIPHER_KASUMI_F8,
4497                         tdata->key.data, tdata->key.len,
4498                         0, tdata->digest.len,
4499                         tdata->cipher_iv.len);
4500
4501         if (retval < 0)
4502                 return retval;
4503
4504         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4505         if (op_mode == OUT_OF_PLACE)
4506                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4507
4508         /* clear mbuf payload */
4509         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4510                 rte_pktmbuf_tailroom(ut_params->ibuf));
4511         if (op_mode == OUT_OF_PLACE)
4512                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
4513                         rte_pktmbuf_tailroom(ut_params->obuf));
4514
4515         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4516         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4517         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4518         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4519
4520         if (verify) {
4521                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4522                                         ciphertext_pad_len);
4523                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4524                 if (op_mode == OUT_OF_PLACE)
4525                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4526                 debug_hexdump(stdout, "ciphertext:", ciphertext,
4527                         ciphertext_len);
4528         } else {
4529                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4530                                         plaintext_pad_len);
4531                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4532                 if (op_mode == OUT_OF_PLACE)
4533                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4534                 debug_hexdump(stdout, "plaintext:", plaintext,
4535                         plaintext_len);
4536         }
4537
4538         /* Create KASUMI operation */
4539         retval = create_wireless_algo_auth_cipher_operation(
4540                 tdata->digest.data, tdata->digest.len,
4541                 tdata->cipher_iv.data, tdata->cipher_iv.len,
4542                 NULL, 0,
4543                 (tdata->digest.offset_bytes == 0 ?
4544                 (verify ? ciphertext_pad_len : plaintext_pad_len)
4545                         : tdata->digest.offset_bytes),
4546                 tdata->validCipherLenInBits.len,
4547                 tdata->validCipherOffsetInBits.len,
4548                 tdata->validAuthLenInBits.len,
4549                 0,
4550                 op_mode, 0, verify);
4551
4552         if (retval < 0)
4553                 return retval;
4554
4555         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4556                         ut_params->op);
4557
4558         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4559
4560         ut_params->obuf = (op_mode == IN_PLACE ?
4561                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
4562
4563
4564         if (verify) {
4565                 if (ut_params->obuf)
4566                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
4567                                                         uint8_t *);
4568                 else
4569                         plaintext = ciphertext;
4570
4571                 debug_hexdump(stdout, "plaintext:", plaintext,
4572                         (tdata->plaintext.len >> 3) - tdata->digest.len);
4573                 debug_hexdump(stdout, "plaintext expected:",
4574                         tdata->plaintext.data,
4575                         (tdata->plaintext.len >> 3) - tdata->digest.len);
4576         } else {
4577                 if (ut_params->obuf)
4578                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
4579                                                         uint8_t *);
4580                 else
4581                         ciphertext = plaintext;
4582
4583                 debug_hexdump(stdout, "ciphertext:", ciphertext,
4584                         ciphertext_len);
4585                 debug_hexdump(stdout, "ciphertext expected:",
4586                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
4587
4588                 ut_params->digest = rte_pktmbuf_mtod(
4589                         ut_params->obuf, uint8_t *) +
4590                         (tdata->digest.offset_bytes == 0 ?
4591                         plaintext_pad_len : tdata->digest.offset_bytes);
4592
4593                 debug_hexdump(stdout, "digest:", ut_params->digest,
4594                         tdata->digest.len);
4595                 debug_hexdump(stdout, "digest expected:",
4596                         tdata->digest.data, tdata->digest.len);
4597         }
4598
4599         /* Validate obuf */
4600         if (verify) {
4601                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4602                         plaintext,
4603                         tdata->plaintext.data,
4604                         tdata->plaintext.len >> 3,
4605                         "KASUMI Plaintext data not as expected");
4606         } else {
4607                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4608                         ciphertext,
4609                         tdata->ciphertext.data,
4610                         tdata->ciphertext.len >> 3,
4611                         "KASUMI Ciphertext data not as expected");
4612
4613                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4614                         ut_params->digest,
4615                         tdata->digest.data,
4616                         DIGEST_BYTE_LENGTH_KASUMI_F9,
4617                         "KASUMI Generated auth tag not as expected");
4618         }
4619         return 0;
4620 }
4621
4622 static int
4623 test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata,
4624         uint8_t op_mode, uint8_t verify)
4625 {
4626         struct crypto_testsuite_params *ts_params = &testsuite_params;
4627         struct crypto_unittest_params *ut_params = &unittest_params;
4628
4629         int retval;
4630
4631         const uint8_t *plaintext = NULL;
4632         const uint8_t *ciphertext = NULL;
4633         const uint8_t *digest = NULL;
4634         unsigned int plaintext_pad_len;
4635         unsigned int plaintext_len;
4636         unsigned int ciphertext_pad_len;
4637         unsigned int ciphertext_len;
4638         uint8_t buffer[10000];
4639         uint8_t digest_buffer[10000];
4640
4641         struct rte_cryptodev_info dev_info;
4642
4643         /* Verify the capabilities */
4644         struct rte_cryptodev_sym_capability_idx cap_idx;
4645         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4646         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
4647         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4648                         &cap_idx) == NULL)
4649                 return -ENOTSUP;
4650         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4651         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
4652         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4653                         &cap_idx) == NULL)
4654                 return -ENOTSUP;
4655
4656         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4657
4658         uint64_t feat_flags = dev_info.feature_flags;
4659
4660         if (op_mode == IN_PLACE) {
4661                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
4662                         printf("Device doesn't support in-place scatter-gather "
4663                                         "in both input and output mbufs.\n");
4664                         return -ENOTSUP;
4665                 }
4666         } else {
4667                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
4668                         printf("Device doesn't support out-of-place scatter-gather "
4669                                         "in both input and output mbufs.\n");
4670                         return -ENOTSUP;
4671                 }
4672                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
4673                         printf("Device doesn't support digest encrypted.\n");
4674                         return -ENOTSUP;
4675                 }
4676         }
4677
4678         /* Create KASUMI session */
4679         retval = create_wireless_algo_auth_cipher_session(
4680                         ts_params->valid_devs[0],
4681                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
4682                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
4683                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
4684                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
4685                         RTE_CRYPTO_AUTH_KASUMI_F9,
4686                         RTE_CRYPTO_CIPHER_KASUMI_F8,
4687                         tdata->key.data, tdata->key.len,
4688                         0, tdata->digest.len,
4689                         tdata->cipher_iv.len);
4690
4691         if (retval < 0)
4692                 return retval;
4693
4694         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4695         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4696         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4697         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4698
4699         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
4700                         plaintext_pad_len, 15, 0);
4701         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4702                         "Failed to allocate input buffer in mempool");
4703
4704         if (op_mode == OUT_OF_PLACE) {
4705                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
4706                                 plaintext_pad_len, 15, 0);
4707                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
4708                                 "Failed to allocate output buffer in mempool");
4709         }
4710
4711         if (verify) {
4712                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
4713                         tdata->ciphertext.data);
4714                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
4715                                         ciphertext_len, buffer);
4716                 debug_hexdump(stdout, "ciphertext:", ciphertext,
4717                         ciphertext_len);
4718         } else {
4719                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
4720                         tdata->plaintext.data);
4721                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
4722                                         plaintext_len, buffer);
4723                 debug_hexdump(stdout, "plaintext:", plaintext,
4724                         plaintext_len);
4725         }
4726         memset(buffer, 0, sizeof(buffer));
4727
4728         /* Create KASUMI operation */
4729         retval = create_wireless_algo_auth_cipher_operation(
4730                 tdata->digest.data, tdata->digest.len,
4731                 tdata->cipher_iv.data, tdata->cipher_iv.len,
4732                 NULL, 0,
4733                 (tdata->digest.offset_bytes == 0 ?
4734                 (verify ? ciphertext_pad_len : plaintext_pad_len)
4735                         : tdata->digest.offset_bytes),
4736                 tdata->validCipherLenInBits.len,
4737                 tdata->validCipherOffsetInBits.len,
4738                 tdata->validAuthLenInBits.len,
4739                 0,
4740                 op_mode, 1, verify);
4741
4742         if (retval < 0)
4743                 return retval;
4744
4745         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4746                         ut_params->op);
4747
4748         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4749
4750         ut_params->obuf = (op_mode == IN_PLACE ?
4751                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
4752
4753         if (verify) {
4754                 if (ut_params->obuf)
4755                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
4756                                         plaintext_len, buffer);
4757                 else
4758                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
4759                                         plaintext_len, buffer);
4760
4761                 debug_hexdump(stdout, "plaintext:", plaintext,
4762                         (tdata->plaintext.len >> 3) - tdata->digest.len);
4763                 debug_hexdump(stdout, "plaintext expected:",
4764                         tdata->plaintext.data,
4765                         (tdata->plaintext.len >> 3) - tdata->digest.len);
4766         } else {
4767                 if (ut_params->obuf)
4768                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
4769                                         ciphertext_len, buffer);
4770                 else
4771                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
4772                                         ciphertext_len, buffer);
4773
4774                 debug_hexdump(stdout, "ciphertext:", ciphertext,
4775                         ciphertext_len);
4776                 debug_hexdump(stdout, "ciphertext expected:",
4777                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
4778
4779                 if (ut_params->obuf)
4780                         digest = rte_pktmbuf_read(ut_params->obuf,
4781                                 (tdata->digest.offset_bytes == 0 ?
4782                                 plaintext_pad_len : tdata->digest.offset_bytes),
4783                                 tdata->digest.len, digest_buffer);
4784                 else
4785                         digest = rte_pktmbuf_read(ut_params->ibuf,
4786                                 (tdata->digest.offset_bytes == 0 ?
4787                                 plaintext_pad_len : tdata->digest.offset_bytes),
4788                                 tdata->digest.len, digest_buffer);
4789
4790                 debug_hexdump(stdout, "digest:", digest,
4791                         tdata->digest.len);
4792                 debug_hexdump(stdout, "digest expected:",
4793                         tdata->digest.data, tdata->digest.len);
4794         }
4795
4796         /* Validate obuf */
4797         if (verify) {
4798                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4799                         plaintext,
4800                         tdata->plaintext.data,
4801                         tdata->plaintext.len >> 3,
4802                         "KASUMI Plaintext data not as expected");
4803         } else {
4804                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4805                         ciphertext,
4806                         tdata->ciphertext.data,
4807                         tdata->validDataLenInBits.len,
4808                         "KASUMI Ciphertext data not as expected");
4809
4810                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4811                         digest,
4812                         tdata->digest.data,
4813                         DIGEST_BYTE_LENGTH_KASUMI_F9,
4814                         "KASUMI Generated auth tag not as expected");
4815         }
4816         return 0;
4817 }
4818
4819 static int
4820 test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
4821 {
4822         struct crypto_testsuite_params *ts_params = &testsuite_params;
4823         struct crypto_unittest_params *ut_params = &unittest_params;
4824
4825         int retval;
4826
4827         uint8_t *plaintext, *ciphertext;
4828         unsigned plaintext_pad_len;
4829         unsigned plaintext_len;
4830
4831         /* Verify the capabilities */
4832         struct rte_cryptodev_sym_capability_idx cap_idx;
4833         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4834         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
4835         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4836                         &cap_idx) == NULL)
4837                 return -ENOTSUP;
4838         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4839         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
4840         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4841                         &cap_idx) == NULL)
4842                 return -ENOTSUP;
4843
4844         /* Create KASUMI session */
4845         retval = create_wireless_algo_cipher_auth_session(
4846                         ts_params->valid_devs[0],
4847                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4848                         RTE_CRYPTO_AUTH_OP_GENERATE,
4849                         RTE_CRYPTO_AUTH_KASUMI_F9,
4850                         RTE_CRYPTO_CIPHER_KASUMI_F8,
4851                         tdata->key.data, tdata->key.len,
4852                         0, tdata->digest.len,
4853                         tdata->cipher_iv.len);
4854         if (retval < 0)
4855                 return retval;
4856
4857         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4858
4859         /* clear mbuf payload */
4860         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4861                         rte_pktmbuf_tailroom(ut_params->ibuf));
4862
4863         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4864         /* Append data which is padded to a multiple of */
4865         /* the algorithms block size */
4866         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4867         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4868                                 plaintext_pad_len);
4869         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4870
4871         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4872
4873         /* Create KASUMI operation */
4874         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
4875                                 tdata->digest.len, NULL, 0,
4876                                 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
4877                                 tdata->cipher_iv.data, tdata->cipher_iv.len,
4878                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
4879                                 tdata->validCipherOffsetInBits.len,
4880                                 tdata->validAuthLenInBits.len,
4881                                 0
4882                                 );
4883         if (retval < 0)
4884                 return retval;
4885
4886         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4887                         ut_params->op);
4888         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4889
4890         if (ut_params->op->sym->m_dst)
4891                 ut_params->obuf = ut_params->op->sym->m_dst;
4892         else
4893                 ut_params->obuf = ut_params->op->sym->m_src;
4894
4895         ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
4896                                 tdata->validCipherOffsetInBits.len >> 3);
4897
4898         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4899                         + plaintext_pad_len;
4900
4901         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
4902                                 (tdata->validCipherOffsetInBits.len >> 3);
4903         /* Validate obuf */
4904         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4905                 ciphertext,
4906                 reference_ciphertext,
4907                 tdata->validCipherLenInBits.len,
4908                 "KASUMI Ciphertext data not as expected");
4909
4910         /* Validate obuf */
4911         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4912                 ut_params->digest,
4913                 tdata->digest.data,
4914                 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4915                 "KASUMI Generated auth tag not as expected");
4916         return 0;
4917 }
4918
4919 static int
4920 test_zuc_encryption(const struct wireless_test_data *tdata)
4921 {
4922         struct crypto_testsuite_params *ts_params = &testsuite_params;
4923         struct crypto_unittest_params *ut_params = &unittest_params;
4924
4925         int retval;
4926         uint8_t *plaintext, *ciphertext;
4927         unsigned plaintext_pad_len;
4928         unsigned plaintext_len;
4929
4930         struct rte_cryptodev_sym_capability_idx cap_idx;
4931
4932         /* Check if device supports ZUC EEA3 */
4933         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4934         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
4935
4936         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4937                         &cap_idx) == NULL)
4938                 return -ENOTSUP;
4939
4940         /* Create ZUC session */
4941         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4942                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4943                                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
4944                                         tdata->key.data, tdata->key.len,
4945                                         tdata->cipher_iv.len);
4946         if (retval < 0)
4947                 return retval;
4948
4949         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4950
4951         /* Clear mbuf payload */
4952         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4953                rte_pktmbuf_tailroom(ut_params->ibuf));
4954
4955         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4956         /* Append data which is padded to a multiple */
4957         /* of the algorithms block size */
4958         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
4959         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4960                                 plaintext_pad_len);
4961         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4962
4963         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4964
4965         /* Create ZUC operation */
4966         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4967                                         tdata->cipher_iv.len,
4968                                         tdata->plaintext.len,
4969                                         0);
4970         if (retval < 0)
4971                 return retval;
4972
4973         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4974                                                 ut_params->op);
4975         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4976
4977         ut_params->obuf = ut_params->op->sym->m_dst;
4978         if (ut_params->obuf)
4979                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4980         else
4981                 ciphertext = plaintext;
4982
4983         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4984
4985         /* Validate obuf */
4986         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4987                 ciphertext,
4988                 tdata->ciphertext.data,
4989                 tdata->validCipherLenInBits.len,
4990                 "ZUC Ciphertext data not as expected");
4991         return 0;
4992 }
4993
4994 static int
4995 test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
4996 {
4997         struct crypto_testsuite_params *ts_params = &testsuite_params;
4998         struct crypto_unittest_params *ut_params = &unittest_params;
4999
5000         int retval;
5001
5002         unsigned int plaintext_pad_len;
5003         unsigned int plaintext_len;
5004         const uint8_t *ciphertext;
5005         uint8_t ciphertext_buffer[2048];
5006         struct rte_cryptodev_info dev_info;
5007
5008         struct rte_cryptodev_sym_capability_idx cap_idx;
5009
5010         /* Check if device supports ZUC EEA3 */
5011         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5012         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
5013
5014         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5015                         &cap_idx) == NULL)
5016                 return -ENOTSUP;
5017
5018         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5019
5020         uint64_t feat_flags = dev_info.feature_flags;
5021
5022         if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5023                 printf("Device doesn't support in-place scatter-gather. "
5024                                 "Test Skipped.\n");
5025                 return -ENOTSUP;
5026         }
5027
5028         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5029
5030         /* Append data which is padded to a multiple */
5031         /* of the algorithms block size */
5032         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
5033
5034         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5035                         plaintext_pad_len, 10, 0);
5036
5037         pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5038                         tdata->plaintext.data);
5039
5040         /* Create ZUC session */
5041         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
5042                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5043                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
5044                         tdata->key.data, tdata->key.len,
5045                         tdata->cipher_iv.len);
5046         if (retval < 0)
5047                 return retval;
5048
5049         /* Clear mbuf payload */
5050
5051         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
5052
5053         /* Create ZUC operation */
5054         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
5055                         tdata->cipher_iv.len, tdata->plaintext.len,
5056                         0);
5057         if (retval < 0)
5058                 return retval;
5059
5060         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5061                                                 ut_params->op);
5062         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5063
5064         ut_params->obuf = ut_params->op->sym->m_dst;
5065         if (ut_params->obuf)
5066                 ciphertext = rte_pktmbuf_read(ut_params->obuf,
5067                         0, plaintext_len, ciphertext_buffer);
5068         else
5069                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
5070                         0, plaintext_len, ciphertext_buffer);
5071
5072         /* Validate obuf */
5073         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
5074
5075         /* Validate obuf */
5076         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5077                 ciphertext,
5078                 tdata->ciphertext.data,
5079                 tdata->validCipherLenInBits.len,
5080                 "ZUC Ciphertext data not as expected");
5081
5082         return 0;
5083 }
5084
5085 static int
5086 test_zuc_authentication(const struct wireless_test_data *tdata)
5087 {
5088         struct crypto_testsuite_params *ts_params = &testsuite_params;
5089         struct crypto_unittest_params *ut_params = &unittest_params;
5090
5091         int retval;
5092         unsigned plaintext_pad_len;
5093         unsigned plaintext_len;
5094         uint8_t *plaintext;
5095
5096         struct rte_cryptodev_sym_capability_idx cap_idx;
5097         struct rte_cryptodev_info dev_info;
5098
5099         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5100         uint64_t feat_flags = dev_info.feature_flags;
5101
5102         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
5103                         (tdata->validAuthLenInBits.len % 8 != 0)) {
5104                 printf("Device doesn't support NON-Byte Aligned Data.\n");
5105                 return -ENOTSUP;
5106         }
5107
5108         /* Check if device supports ZUC EIA3 */
5109         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5110         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
5111
5112         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5113                         &cap_idx) == NULL)
5114                 return -ENOTSUP;
5115
5116         /* Create ZUC session */
5117         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
5118                         tdata->key.data, tdata->key.len,
5119                         tdata->auth_iv.len, tdata->digest.len,
5120                         RTE_CRYPTO_AUTH_OP_GENERATE,
5121                         RTE_CRYPTO_AUTH_ZUC_EIA3);
5122         if (retval < 0)
5123                 return retval;
5124
5125         /* alloc mbuf and set payload */
5126         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5127
5128         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5129         rte_pktmbuf_tailroom(ut_params->ibuf));
5130
5131         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5132         /* Append data which is padded to a multiple of */
5133         /* the algorithms block size */
5134         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
5135         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5136                                 plaintext_pad_len);
5137         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5138
5139         /* Create ZUC operation */
5140         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
5141                         tdata->auth_iv.data, tdata->auth_iv.len,
5142                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
5143                         tdata->validAuthLenInBits.len,
5144                         0);
5145         if (retval < 0)
5146                 return retval;
5147
5148         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5149                                 ut_params->op);
5150         ut_params->obuf = ut_params->op->sym->m_src;
5151         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5152         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5153                         + plaintext_pad_len;
5154
5155         /* Validate obuf */
5156         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5157         ut_params->digest,
5158         tdata->digest.data,
5159         tdata->digest.len,
5160         "ZUC Generated auth tag not as expected");
5161
5162         return 0;
5163 }
5164
5165 static int
5166 test_zuc_auth_cipher(const struct wireless_test_data *tdata,
5167         uint8_t op_mode, uint8_t verify)
5168 {
5169         struct crypto_testsuite_params *ts_params = &testsuite_params;
5170         struct crypto_unittest_params *ut_params = &unittest_params;
5171
5172         int retval;
5173
5174         uint8_t *plaintext = NULL, *ciphertext = NULL;
5175         unsigned int plaintext_pad_len;
5176         unsigned int plaintext_len;
5177         unsigned int ciphertext_pad_len;
5178         unsigned int ciphertext_len;
5179
5180         struct rte_cryptodev_info dev_info;
5181         struct rte_cryptodev_sym_capability_idx cap_idx;
5182
5183         /* Check if device supports ZUC EIA3 */
5184         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5185         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
5186
5187         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5188                         &cap_idx) == NULL)
5189                 return -ENOTSUP;
5190
5191         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5192
5193         uint64_t feat_flags = dev_info.feature_flags;
5194
5195         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5196                 printf("Device doesn't support digest encrypted.\n");
5197                 return -ENOTSUP;
5198         }
5199         if (op_mode == IN_PLACE) {
5200                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5201                         printf("Device doesn't support in-place scatter-gather "
5202                                         "in both input and output mbufs.\n");
5203                         return -ENOTSUP;
5204                 }
5205         } else {
5206                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5207                         printf("Device doesn't support out-of-place scatter-gather "
5208                                         "in both input and output mbufs.\n");
5209                         return -ENOTSUP;
5210                 }
5211         }
5212
5213         /* Create ZUC session */
5214         retval = create_wireless_algo_auth_cipher_session(
5215                         ts_params->valid_devs[0],
5216                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5217                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5218                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5219                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5220                         RTE_CRYPTO_AUTH_ZUC_EIA3,
5221                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
5222                         tdata->key.data, tdata->key.len,
5223                         tdata->auth_iv.len, tdata->digest.len,
5224                         tdata->cipher_iv.len);
5225
5226         if (retval < 0)
5227                 return retval;
5228
5229         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5230         if (op_mode == OUT_OF_PLACE)
5231                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5232
5233         /* clear mbuf payload */
5234         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5235                 rte_pktmbuf_tailroom(ut_params->ibuf));
5236         if (op_mode == OUT_OF_PLACE)
5237                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5238                         rte_pktmbuf_tailroom(ut_params->obuf));
5239
5240         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5241         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5242         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5243         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5244
5245         if (verify) {
5246                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5247                                         ciphertext_pad_len);
5248                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
5249                 if (op_mode == OUT_OF_PLACE)
5250                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
5251                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5252                         ciphertext_len);
5253         } else {
5254                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5255                                         plaintext_pad_len);
5256                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5257                 if (op_mode == OUT_OF_PLACE)
5258                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
5259                 debug_hexdump(stdout, "plaintext:", plaintext,
5260                         plaintext_len);
5261         }
5262
5263         /* Create ZUC operation */
5264         retval = create_wireless_algo_auth_cipher_operation(
5265                 tdata->digest.data, tdata->digest.len,
5266                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5267                 tdata->auth_iv.data, tdata->auth_iv.len,
5268                 (tdata->digest.offset_bytes == 0 ?
5269                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5270                         : tdata->digest.offset_bytes),
5271                 tdata->validCipherLenInBits.len,
5272                 tdata->validCipherOffsetInBits.len,
5273                 tdata->validAuthLenInBits.len,
5274                 0,
5275                 op_mode, 0, verify);
5276
5277         if (retval < 0)
5278                 return retval;
5279
5280         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5281                         ut_params->op);
5282
5283         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5284
5285         ut_params->obuf = (op_mode == IN_PLACE ?
5286                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5287
5288
5289         if (verify) {
5290                 if (ut_params->obuf)
5291                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5292                                                         uint8_t *);
5293                 else
5294                         plaintext = ciphertext;
5295
5296                 debug_hexdump(stdout, "plaintext:", plaintext,
5297                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5298                 debug_hexdump(stdout, "plaintext expected:",
5299                         tdata->plaintext.data,
5300                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5301         } else {
5302                 if (ut_params->obuf)
5303                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5304                                                         uint8_t *);
5305                 else
5306                         ciphertext = plaintext;
5307
5308                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5309                         ciphertext_len);
5310                 debug_hexdump(stdout, "ciphertext expected:",
5311                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5312
5313                 ut_params->digest = rte_pktmbuf_mtod(
5314                         ut_params->obuf, uint8_t *) +
5315                         (tdata->digest.offset_bytes == 0 ?
5316                         plaintext_pad_len : tdata->digest.offset_bytes);
5317
5318                 debug_hexdump(stdout, "digest:", ut_params->digest,
5319                         tdata->digest.len);
5320                 debug_hexdump(stdout, "digest expected:",
5321                         tdata->digest.data, tdata->digest.len);
5322         }
5323
5324         /* Validate obuf */
5325         if (verify) {
5326                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5327                         plaintext,
5328                         tdata->plaintext.data,
5329                         tdata->plaintext.len >> 3,
5330                         "ZUC Plaintext data not as expected");
5331         } else {
5332                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5333                         ciphertext,
5334                         tdata->ciphertext.data,
5335                         tdata->ciphertext.len >> 3,
5336                         "ZUC Ciphertext data not as expected");
5337
5338                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5339                         ut_params->digest,
5340                         tdata->digest.data,
5341                         DIGEST_BYTE_LENGTH_KASUMI_F9,
5342                         "ZUC Generated auth tag not as expected");
5343         }
5344         return 0;
5345 }
5346
5347 static int
5348 test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata,
5349         uint8_t op_mode, uint8_t verify)
5350 {
5351         struct crypto_testsuite_params *ts_params = &testsuite_params;
5352         struct crypto_unittest_params *ut_params = &unittest_params;
5353
5354         int retval;
5355
5356         const uint8_t *plaintext = NULL;
5357         const uint8_t *ciphertext = NULL;
5358         const uint8_t *digest = NULL;
5359         unsigned int plaintext_pad_len;
5360         unsigned int plaintext_len;
5361         unsigned int ciphertext_pad_len;
5362         unsigned int ciphertext_len;
5363         uint8_t buffer[10000];
5364         uint8_t digest_buffer[10000];
5365
5366         struct rte_cryptodev_info dev_info;
5367         struct rte_cryptodev_sym_capability_idx cap_idx;
5368
5369         /* Check if device supports ZUC EIA3 */
5370         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5371         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
5372
5373         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5374                         &cap_idx) == NULL)
5375                 return -ENOTSUP;
5376
5377         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5378
5379         uint64_t feat_flags = dev_info.feature_flags;
5380
5381         if (op_mode == IN_PLACE) {
5382                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5383                         printf("Device doesn't support in-place scatter-gather "
5384                                         "in both input and output mbufs.\n");
5385                         return -ENOTSUP;
5386                 }
5387         } else {
5388                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5389                         printf("Device doesn't support out-of-place scatter-gather "
5390                                         "in both input and output mbufs.\n");
5391                         return -ENOTSUP;
5392                 }
5393                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5394                         printf("Device doesn't support digest encrypted.\n");
5395                         return -ENOTSUP;
5396                 }
5397         }
5398
5399         /* Create ZUC session */
5400         retval = create_wireless_algo_auth_cipher_session(
5401                         ts_params->valid_devs[0],
5402                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5403                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5404                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5405                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5406                         RTE_CRYPTO_AUTH_ZUC_EIA3,
5407                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
5408                         tdata->key.data, tdata->key.len,
5409                         tdata->auth_iv.len, tdata->digest.len,
5410                         tdata->cipher_iv.len);
5411
5412         if (retval < 0)
5413                 return retval;
5414
5415         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5416         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5417         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5418         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5419
5420         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5421                         plaintext_pad_len, 15, 0);
5422         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5423                         "Failed to allocate input buffer in mempool");
5424
5425         if (op_mode == OUT_OF_PLACE) {
5426                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5427                                 plaintext_pad_len, 15, 0);
5428                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5429                                 "Failed to allocate output buffer in mempool");
5430         }
5431
5432         if (verify) {
5433                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
5434                         tdata->ciphertext.data);
5435                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5436                                         ciphertext_len, buffer);
5437                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5438                         ciphertext_len);
5439         } else {
5440                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5441                         tdata->plaintext.data);
5442                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5443                                         plaintext_len, buffer);
5444                 debug_hexdump(stdout, "plaintext:", plaintext,
5445                         plaintext_len);
5446         }
5447         memset(buffer, 0, sizeof(buffer));
5448
5449         /* Create ZUC operation */
5450         retval = create_wireless_algo_auth_cipher_operation(
5451                 tdata->digest.data, tdata->digest.len,
5452                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5453                 NULL, 0,
5454                 (tdata->digest.offset_bytes == 0 ?
5455                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5456                         : tdata->digest.offset_bytes),
5457                 tdata->validCipherLenInBits.len,
5458                 tdata->validCipherOffsetInBits.len,
5459                 tdata->validAuthLenInBits.len,
5460                 0,
5461                 op_mode, 1, verify);
5462
5463         if (retval < 0)
5464                 return retval;
5465
5466         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5467                         ut_params->op);
5468
5469         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5470
5471         ut_params->obuf = (op_mode == IN_PLACE ?
5472                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5473
5474         if (verify) {
5475                 if (ut_params->obuf)
5476                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
5477                                         plaintext_len, buffer);
5478                 else
5479                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5480                                         plaintext_len, buffer);
5481
5482                 debug_hexdump(stdout, "plaintext:", plaintext,
5483                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5484                 debug_hexdump(stdout, "plaintext expected:",
5485                         tdata->plaintext.data,
5486                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5487         } else {
5488                 if (ut_params->obuf)
5489                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
5490                                         ciphertext_len, buffer);
5491                 else
5492                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5493                                         ciphertext_len, buffer);
5494
5495                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5496                         ciphertext_len);
5497                 debug_hexdump(stdout, "ciphertext expected:",
5498                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5499
5500                 if (ut_params->obuf)
5501                         digest = rte_pktmbuf_read(ut_params->obuf,
5502                                 (tdata->digest.offset_bytes == 0 ?
5503                                 plaintext_pad_len : tdata->digest.offset_bytes),
5504                                 tdata->digest.len, digest_buffer);
5505                 else
5506                         digest = rte_pktmbuf_read(ut_params->ibuf,
5507                                 (tdata->digest.offset_bytes == 0 ?
5508                                 plaintext_pad_len : tdata->digest.offset_bytes),
5509                                 tdata->digest.len, digest_buffer);
5510
5511                 debug_hexdump(stdout, "digest:", digest,
5512                         tdata->digest.len);
5513                 debug_hexdump(stdout, "digest expected:",
5514                         tdata->digest.data, tdata->digest.len);
5515         }
5516
5517         /* Validate obuf */
5518         if (verify) {
5519                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5520                         plaintext,
5521                         tdata->plaintext.data,
5522                         tdata->plaintext.len >> 3,
5523                         "ZUC Plaintext data not as expected");
5524         } else {
5525                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5526                         ciphertext,
5527                         tdata->ciphertext.data,
5528                         tdata->validDataLenInBits.len,
5529                         "ZUC Ciphertext data not as expected");
5530
5531                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5532                         digest,
5533                         tdata->digest.data,
5534                         DIGEST_BYTE_LENGTH_KASUMI_F9,
5535                         "ZUC Generated auth tag not as expected");
5536         }
5537         return 0;
5538 }
5539
5540 static int
5541 test_kasumi_encryption_test_case_1(void)
5542 {
5543         return test_kasumi_encryption(&kasumi_test_case_1);
5544 }
5545
5546 static int
5547 test_kasumi_encryption_test_case_1_sgl(void)
5548 {
5549         return test_kasumi_encryption_sgl(&kasumi_test_case_1);
5550 }
5551
5552 static int
5553 test_kasumi_encryption_test_case_1_oop(void)
5554 {
5555         return test_kasumi_encryption_oop(&kasumi_test_case_1);
5556 }
5557
5558 static int
5559 test_kasumi_encryption_test_case_1_oop_sgl(void)
5560 {
5561         return test_kasumi_encryption_oop_sgl(&kasumi_test_case_1);
5562 }
5563
5564 static int
5565 test_kasumi_encryption_test_case_2(void)
5566 {
5567         return test_kasumi_encryption(&kasumi_test_case_2);
5568 }
5569
5570 static int
5571 test_kasumi_encryption_test_case_3(void)
5572 {
5573         return test_kasumi_encryption(&kasumi_test_case_3);
5574 }
5575
5576 static int
5577 test_kasumi_encryption_test_case_4(void)
5578 {
5579         return test_kasumi_encryption(&kasumi_test_case_4);
5580 }
5581
5582 static int
5583 test_kasumi_encryption_test_case_5(void)
5584 {
5585         return test_kasumi_encryption(&kasumi_test_case_5);
5586 }
5587
5588 static int
5589 test_kasumi_decryption_test_case_1(void)
5590 {
5591         return test_kasumi_decryption(&kasumi_test_case_1);
5592 }
5593
5594 static int
5595 test_kasumi_decryption_test_case_1_oop(void)
5596 {
5597         return test_kasumi_decryption_oop(&kasumi_test_case_1);
5598 }
5599
5600 static int
5601 test_kasumi_decryption_test_case_2(void)
5602 {
5603         return test_kasumi_decryption(&kasumi_test_case_2);
5604 }
5605
5606 static int
5607 test_kasumi_decryption_test_case_3(void)
5608 {
5609         return test_kasumi_decryption(&kasumi_test_case_3);
5610 }
5611
5612 static int
5613 test_kasumi_decryption_test_case_4(void)
5614 {
5615         return test_kasumi_decryption(&kasumi_test_case_4);
5616 }
5617
5618 static int
5619 test_kasumi_decryption_test_case_5(void)
5620 {
5621         return test_kasumi_decryption(&kasumi_test_case_5);
5622 }
5623 static int
5624 test_snow3g_encryption_test_case_1(void)
5625 {
5626         return test_snow3g_encryption(&snow3g_test_case_1);
5627 }
5628
5629 static int
5630 test_snow3g_encryption_test_case_1_oop(void)
5631 {
5632         return test_snow3g_encryption_oop(&snow3g_test_case_1);
5633 }
5634
5635 static int
5636 test_snow3g_encryption_test_case_1_oop_sgl(void)
5637 {
5638         return test_snow3g_encryption_oop_sgl(&snow3g_test_case_1);
5639 }
5640
5641
5642 static int
5643 test_snow3g_encryption_test_case_1_offset_oop(void)
5644 {
5645         return test_snow3g_encryption_offset_oop(&snow3g_test_case_1);
5646 }
5647
5648 static int
5649 test_snow3g_encryption_test_case_2(void)
5650 {
5651         return test_snow3g_encryption(&snow3g_test_case_2);
5652 }
5653
5654 static int
5655 test_snow3g_encryption_test_case_3(void)
5656 {
5657         return test_snow3g_encryption(&snow3g_test_case_3);
5658 }
5659
5660 static int
5661 test_snow3g_encryption_test_case_4(void)
5662 {
5663         return test_snow3g_encryption(&snow3g_test_case_4);
5664 }
5665
5666 static int
5667 test_snow3g_encryption_test_case_5(void)
5668 {
5669         return test_snow3g_encryption(&snow3g_test_case_5);
5670 }
5671
5672 static int
5673 test_snow3g_decryption_test_case_1(void)
5674 {
5675         return test_snow3g_decryption(&snow3g_test_case_1);
5676 }
5677
5678 static int
5679 test_snow3g_decryption_test_case_1_oop(void)
5680 {
5681         return test_snow3g_decryption_oop(&snow3g_test_case_1);
5682 }
5683
5684 static int
5685 test_snow3g_decryption_test_case_2(void)
5686 {
5687         return test_snow3g_decryption(&snow3g_test_case_2);
5688 }
5689
5690 static int
5691 test_snow3g_decryption_test_case_3(void)
5692 {
5693         return test_snow3g_decryption(&snow3g_test_case_3);
5694 }
5695
5696 static int
5697 test_snow3g_decryption_test_case_4(void)
5698 {
5699         return test_snow3g_decryption(&snow3g_test_case_4);
5700 }
5701
5702 static int
5703 test_snow3g_decryption_test_case_5(void)
5704 {
5705         return test_snow3g_decryption(&snow3g_test_case_5);
5706 }
5707
5708 /*
5709  * Function prepares snow3g_hash_test_data from snow3g_test_data.
5710  * Pattern digest from snow3g_test_data must be allocated as
5711  * 4 last bytes in plaintext.
5712  */
5713 static void
5714 snow3g_hash_test_vector_setup(const struct snow3g_test_data *pattern,
5715                 struct snow3g_hash_test_data *output)
5716 {
5717         if ((pattern != NULL) && (output != NULL)) {
5718                 output->key.len = pattern->key.len;
5719
5720                 memcpy(output->key.data,
5721                 pattern->key.data, pattern->key.len);
5722
5723                 output->auth_iv.len = pattern->auth_iv.len;
5724
5725                 memcpy(output->auth_iv.data,
5726                 pattern->auth_iv.data, pattern->auth_iv.len);
5727
5728                 output->plaintext.len = pattern->plaintext.len;
5729
5730                 memcpy(output->plaintext.data,
5731                 pattern->plaintext.data, pattern->plaintext.len >> 3);
5732
5733                 output->digest.len = pattern->digest.len;
5734
5735                 memcpy(output->digest.data,
5736                 &pattern->plaintext.data[pattern->digest.offset_bytes],
5737                 pattern->digest.len);
5738
5739                 output->validAuthLenInBits.len =
5740                 pattern->validAuthLenInBits.len;
5741         }
5742 }
5743
5744 /*
5745  * Test case verify computed cipher and digest from snow3g_test_case_7 data.
5746  */
5747 static int
5748 test_snow3g_decryption_with_digest_test_case_1(void)
5749 {
5750         struct snow3g_hash_test_data snow3g_hash_data;
5751
5752         /*
5753          * Function prepare data for hash veryfication test case.
5754          * Digest is allocated in 4 last bytes in plaintext, pattern.
5755          */
5756         snow3g_hash_test_vector_setup(&snow3g_test_case_7, &snow3g_hash_data);
5757
5758         return test_snow3g_decryption(&snow3g_test_case_7) &
5759                         test_snow3g_authentication_verify(&snow3g_hash_data);
5760 }
5761
5762 static int
5763 test_snow3g_cipher_auth_test_case_1(void)
5764 {
5765         return test_snow3g_cipher_auth(&snow3g_test_case_3);
5766 }
5767
5768 static int
5769 test_snow3g_auth_cipher_test_case_1(void)
5770 {
5771         return test_snow3g_auth_cipher(
5772                 &snow3g_auth_cipher_test_case_1, IN_PLACE, 0);
5773 }
5774
5775 static int
5776 test_snow3g_auth_cipher_test_case_2(void)
5777 {
5778         return test_snow3g_auth_cipher(
5779                 &snow3g_auth_cipher_test_case_2, IN_PLACE, 0);
5780 }
5781
5782 static int
5783 test_snow3g_auth_cipher_test_case_2_oop(void)
5784 {
5785         return test_snow3g_auth_cipher(
5786                 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
5787 }
5788
5789 static int
5790 test_snow3g_auth_cipher_part_digest_enc(void)
5791 {
5792         return test_snow3g_auth_cipher(
5793                 &snow3g_auth_cipher_partial_digest_encryption,
5794                         IN_PLACE, 0);
5795 }
5796
5797 static int
5798 test_snow3g_auth_cipher_part_digest_enc_oop(void)
5799 {
5800         return test_snow3g_auth_cipher(
5801                 &snow3g_auth_cipher_partial_digest_encryption,
5802                         OUT_OF_PLACE, 0);
5803 }
5804
5805 static int
5806 test_snow3g_auth_cipher_test_case_3_sgl(void)
5807 {
5808         return test_snow3g_auth_cipher_sgl(
5809                 &snow3g_auth_cipher_test_case_3, IN_PLACE, 0);
5810 }
5811
5812 static int
5813 test_snow3g_auth_cipher_test_case_3_oop_sgl(void)
5814 {
5815         return test_snow3g_auth_cipher_sgl(
5816                 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 0);
5817 }
5818
5819 static int
5820 test_snow3g_auth_cipher_part_digest_enc_sgl(void)
5821 {
5822         return test_snow3g_auth_cipher_sgl(
5823                 &snow3g_auth_cipher_partial_digest_encryption,
5824                         IN_PLACE, 0);
5825 }
5826
5827 static int
5828 test_snow3g_auth_cipher_part_digest_enc_oop_sgl(void)
5829 {
5830         return test_snow3g_auth_cipher_sgl(
5831                 &snow3g_auth_cipher_partial_digest_encryption,
5832                         OUT_OF_PLACE, 0);
5833 }
5834
5835 static int
5836 test_snow3g_auth_cipher_verify_test_case_1(void)
5837 {
5838         return test_snow3g_auth_cipher(
5839                 &snow3g_auth_cipher_test_case_1, IN_PLACE, 1);
5840 }
5841
5842 static int
5843 test_snow3g_auth_cipher_verify_test_case_2(void)
5844 {
5845         return test_snow3g_auth_cipher(
5846                 &snow3g_auth_cipher_test_case_2, IN_PLACE, 1);
5847 }
5848
5849 static int
5850 test_snow3g_auth_cipher_verify_test_case_2_oop(void)
5851 {
5852         return test_snow3g_auth_cipher(
5853                 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
5854 }
5855
5856 static int
5857 test_snow3g_auth_cipher_verify_part_digest_enc(void)
5858 {
5859         return test_snow3g_auth_cipher(
5860                 &snow3g_auth_cipher_partial_digest_encryption,
5861                         IN_PLACE, 1);
5862 }
5863
5864 static int
5865 test_snow3g_auth_cipher_verify_part_digest_enc_oop(void)
5866 {
5867         return test_snow3g_auth_cipher(
5868                 &snow3g_auth_cipher_partial_digest_encryption,
5869                         OUT_OF_PLACE, 1);
5870 }
5871
5872 static int
5873 test_snow3g_auth_cipher_verify_test_case_3_sgl(void)
5874 {
5875         return test_snow3g_auth_cipher_sgl(
5876                 &snow3g_auth_cipher_test_case_3, IN_PLACE, 1);
5877 }
5878
5879 static int
5880 test_snow3g_auth_cipher_verify_test_case_3_oop_sgl(void)
5881 {
5882         return test_snow3g_auth_cipher_sgl(
5883                 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 1);
5884 }
5885
5886 static int
5887 test_snow3g_auth_cipher_verify_part_digest_enc_sgl(void)
5888 {
5889         return test_snow3g_auth_cipher_sgl(
5890                 &snow3g_auth_cipher_partial_digest_encryption,
5891                         IN_PLACE, 1);
5892 }
5893
5894 static int
5895 test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl(void)
5896 {
5897         return test_snow3g_auth_cipher_sgl(
5898                 &snow3g_auth_cipher_partial_digest_encryption,
5899                         OUT_OF_PLACE, 1);
5900 }
5901
5902 static int
5903 test_snow3g_auth_cipher_with_digest_test_case_1(void)
5904 {
5905         return test_snow3g_auth_cipher(
5906                 &snow3g_test_case_7, IN_PLACE, 0);
5907 }
5908
5909 static int
5910 test_kasumi_auth_cipher_test_case_1(void)
5911 {
5912         return test_kasumi_auth_cipher(
5913                 &kasumi_test_case_3, IN_PLACE, 0);
5914 }
5915
5916 static int
5917 test_kasumi_auth_cipher_test_case_2(void)
5918 {
5919         return test_kasumi_auth_cipher(
5920                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
5921 }
5922
5923 static int
5924 test_kasumi_auth_cipher_test_case_2_oop(void)
5925 {
5926         return test_kasumi_auth_cipher(
5927                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
5928 }
5929
5930 static int
5931 test_kasumi_auth_cipher_test_case_2_sgl(void)
5932 {
5933         return test_kasumi_auth_cipher_sgl(
5934                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
5935 }
5936
5937 static int
5938 test_kasumi_auth_cipher_test_case_2_oop_sgl(void)
5939 {
5940         return test_kasumi_auth_cipher_sgl(
5941                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
5942 }
5943
5944 static int
5945 test_kasumi_auth_cipher_verify_test_case_1(void)
5946 {
5947         return test_kasumi_auth_cipher(
5948                 &kasumi_test_case_3, IN_PLACE, 1);
5949 }
5950
5951 static int
5952 test_kasumi_auth_cipher_verify_test_case_2(void)
5953 {
5954         return test_kasumi_auth_cipher(
5955                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
5956 }
5957
5958 static int
5959 test_kasumi_auth_cipher_verify_test_case_2_oop(void)
5960 {
5961         return test_kasumi_auth_cipher(
5962                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
5963 }
5964
5965 static int
5966 test_kasumi_auth_cipher_verify_test_case_2_sgl(void)
5967 {
5968         return test_kasumi_auth_cipher_sgl(
5969                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
5970 }
5971
5972 static int
5973 test_kasumi_auth_cipher_verify_test_case_2_oop_sgl(void)
5974 {
5975         return test_kasumi_auth_cipher_sgl(
5976                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
5977 }
5978
5979 static int
5980 test_kasumi_cipher_auth_test_case_1(void)
5981 {
5982         return test_kasumi_cipher_auth(&kasumi_test_case_6);
5983 }
5984
5985 static int
5986 test_zuc_encryption_test_case_1(void)
5987 {
5988         return test_zuc_encryption(&zuc_test_case_cipher_193b);
5989 }
5990
5991 static int
5992 test_zuc_encryption_test_case_2(void)
5993 {
5994         return test_zuc_encryption(&zuc_test_case_cipher_800b);
5995 }
5996
5997 static int
5998 test_zuc_encryption_test_case_3(void)
5999 {
6000         return test_zuc_encryption(&zuc_test_case_cipher_1570b);
6001 }
6002
6003 static int
6004 test_zuc_encryption_test_case_4(void)
6005 {
6006         return test_zuc_encryption(&zuc_test_case_cipher_2798b);
6007 }
6008
6009 static int
6010 test_zuc_encryption_test_case_5(void)
6011 {
6012         return test_zuc_encryption(&zuc_test_case_cipher_4019b);
6013 }
6014
6015 static int
6016 test_zuc_encryption_test_case_6_sgl(void)
6017 {
6018         return test_zuc_encryption_sgl(&zuc_test_case_cipher_193b);
6019 }
6020
6021 static int
6022 test_zuc_hash_generate_test_case_1(void)
6023 {
6024         return test_zuc_authentication(&zuc_test_case_auth_1b);
6025 }
6026
6027 static int
6028 test_zuc_hash_generate_test_case_2(void)
6029 {
6030         return test_zuc_authentication(&zuc_test_case_auth_90b);
6031 }
6032
6033 static int
6034 test_zuc_hash_generate_test_case_3(void)
6035 {
6036         return test_zuc_authentication(&zuc_test_case_auth_577b);
6037 }
6038
6039 static int
6040 test_zuc_hash_generate_test_case_4(void)
6041 {
6042         return test_zuc_authentication(&zuc_test_case_auth_2079b);
6043 }
6044
6045 static int
6046 test_zuc_hash_generate_test_case_5(void)
6047 {
6048         return test_zuc_authentication(&zuc_test_auth_5670b);
6049 }
6050
6051 static int
6052 test_zuc_hash_generate_test_case_6(void)
6053 {
6054         return test_zuc_authentication(&zuc_test_case_auth_128b);
6055 }
6056
6057 static int
6058 test_zuc_hash_generate_test_case_7(void)
6059 {
6060         return test_zuc_authentication(&zuc_test_case_auth_2080b);
6061 }
6062
6063 static int
6064 test_zuc_hash_generate_test_case_8(void)
6065 {
6066         return test_zuc_authentication(&zuc_test_case_auth_584b);
6067 }
6068
6069 static int
6070 test_zuc_cipher_auth_test_case_1(void)
6071 {
6072         return test_zuc_cipher_auth(&zuc_test_case_cipher_200b_auth_200b);
6073 }
6074
6075 static int
6076 test_zuc_cipher_auth_test_case_2(void)
6077 {
6078         return test_zuc_cipher_auth(&zuc_test_case_cipher_800b_auth_120b);
6079 }
6080
6081 static int
6082 test_zuc_auth_cipher_test_case_1(void)
6083 {
6084         return test_zuc_auth_cipher(
6085                 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
6086 }
6087
6088 static int
6089 test_zuc_auth_cipher_test_case_1_oop(void)
6090 {
6091         return test_zuc_auth_cipher(
6092                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
6093 }
6094
6095 static int
6096 test_zuc_auth_cipher_test_case_1_sgl(void)
6097 {
6098         return test_zuc_auth_cipher_sgl(
6099                 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
6100 }
6101
6102 static int
6103 test_zuc_auth_cipher_test_case_1_oop_sgl(void)
6104 {
6105         return test_zuc_auth_cipher_sgl(
6106                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
6107 }
6108
6109 static int
6110 test_zuc_auth_cipher_verify_test_case_1(void)
6111 {
6112         return test_zuc_auth_cipher(
6113                 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
6114 }
6115
6116 static int
6117 test_zuc_auth_cipher_verify_test_case_1_oop(void)
6118 {
6119         return test_zuc_auth_cipher(
6120                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
6121 }
6122
6123 static int
6124 test_zuc_auth_cipher_verify_test_case_1_sgl(void)
6125 {
6126         return test_zuc_auth_cipher_sgl(
6127                 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
6128 }
6129
6130 static int
6131 test_zuc_auth_cipher_verify_test_case_1_oop_sgl(void)
6132 {
6133         return test_zuc_auth_cipher_sgl(
6134                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
6135 }
6136
6137 static int
6138 test_mixed_check_if_unsupported(const struct mixed_cipher_auth_test_data *tdata)
6139 {
6140         uint8_t dev_id = testsuite_params.valid_devs[0];
6141
6142         struct rte_cryptodev_sym_capability_idx cap_idx;
6143
6144         /* Check if device supports particular cipher algorithm */
6145         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
6146         cap_idx.algo.cipher = tdata->cipher_algo;
6147         if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
6148                 return -ENOTSUP;
6149
6150         /* Check if device supports particular hash algorithm */
6151         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6152         cap_idx.algo.auth = tdata->auth_algo;
6153         if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
6154                 return -ENOTSUP;
6155
6156         return 0;
6157 }
6158
6159 static int
6160 test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata,
6161         uint8_t op_mode, uint8_t verify)
6162 {
6163         struct crypto_testsuite_params *ts_params = &testsuite_params;
6164         struct crypto_unittest_params *ut_params = &unittest_params;
6165
6166         int retval;
6167
6168         uint8_t *plaintext = NULL, *ciphertext = NULL;
6169         unsigned int plaintext_pad_len;
6170         unsigned int plaintext_len;
6171         unsigned int ciphertext_pad_len;
6172         unsigned int ciphertext_len;
6173
6174         struct rte_cryptodev_info dev_info;
6175         struct rte_crypto_op *op;
6176
6177         /* Check if device supports particular algorithms separately */
6178         if (test_mixed_check_if_unsupported(tdata))
6179                 return -ENOTSUP;
6180
6181         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6182
6183         uint64_t feat_flags = dev_info.feature_flags;
6184
6185         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6186                 printf("Device doesn't support digest encrypted.\n");
6187                 return -ENOTSUP;
6188         }
6189
6190         /* Create the session */
6191         if (verify)
6192                 retval = create_wireless_algo_cipher_auth_session(
6193                                 ts_params->valid_devs[0],
6194                                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
6195                                 RTE_CRYPTO_AUTH_OP_VERIFY,
6196                                 tdata->auth_algo,
6197                                 tdata->cipher_algo,
6198                                 tdata->auth_key.data, tdata->auth_key.len,
6199                                 tdata->auth_iv.len, tdata->digest_enc.len,
6200                                 tdata->cipher_iv.len);
6201         else
6202                 retval = create_wireless_algo_auth_cipher_session(
6203                                 ts_params->valid_devs[0],
6204                                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
6205                                 RTE_CRYPTO_AUTH_OP_GENERATE,
6206                                 tdata->auth_algo,
6207                                 tdata->cipher_algo,
6208                                 tdata->auth_key.data, tdata->auth_key.len,
6209                                 tdata->auth_iv.len, tdata->digest_enc.len,
6210                                 tdata->cipher_iv.len);
6211         if (retval < 0)
6212                 return retval;
6213
6214         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6215         if (op_mode == OUT_OF_PLACE)
6216                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6217
6218         /* clear mbuf payload */
6219         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6220                 rte_pktmbuf_tailroom(ut_params->ibuf));
6221         if (op_mode == OUT_OF_PLACE)
6222                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
6223                                 rte_pktmbuf_tailroom(ut_params->obuf));
6224
6225         ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
6226         plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
6227         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6228         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6229
6230         if (verify) {
6231                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6232                                 ciphertext_pad_len);
6233                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
6234                 if (op_mode == OUT_OF_PLACE)
6235                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
6236                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6237                                 ciphertext_len);
6238         } else {
6239                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6240                                 plaintext_pad_len);
6241                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6242                 if (op_mode == OUT_OF_PLACE)
6243                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
6244                 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
6245         }
6246
6247         /* Create the operation */
6248         retval = create_wireless_algo_auth_cipher_operation(
6249                         tdata->digest_enc.data, tdata->digest_enc.len,
6250                         tdata->cipher_iv.data, tdata->cipher_iv.len,
6251                         tdata->auth_iv.data, tdata->auth_iv.len,
6252                         (tdata->digest_enc.offset == 0 ?
6253                                 plaintext_pad_len
6254                                 : tdata->digest_enc.offset),
6255                         tdata->validCipherLen.len_bits,
6256                         tdata->cipher.offset_bits,
6257                         tdata->validAuthLen.len_bits,
6258                         tdata->auth.offset_bits,
6259                         op_mode, 0, verify);
6260
6261         if (retval < 0)
6262                 return retval;
6263
6264         op = process_crypto_request(ts_params->valid_devs[0],
6265                         ut_params->op);
6266
6267         /* Check if the op failed because the device doesn't */
6268         /* support this particular combination of algorithms */
6269         if (op == NULL && ut_params->op->status ==
6270                         RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
6271                 printf("Device doesn't support this mixed combination. "
6272                                 "Test Skipped.\n");
6273                 return -ENOTSUP;
6274         }
6275         ut_params->op = op;
6276
6277         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6278
6279         ut_params->obuf = (op_mode == IN_PLACE ?
6280                         ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6281
6282         if (verify) {
6283                 if (ut_params->obuf)
6284                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
6285                                                         uint8_t *);
6286                 else
6287                         plaintext = ciphertext +
6288                                         (tdata->cipher.offset_bits >> 3);
6289
6290                 debug_hexdump(stdout, "plaintext:", plaintext,
6291                                 tdata->plaintext.len_bits >> 3);
6292                 debug_hexdump(stdout, "plaintext expected:",
6293                                 tdata->plaintext.data,
6294                                 tdata->plaintext.len_bits >> 3);
6295         } else {
6296                 if (ut_params->obuf)
6297                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
6298                                         uint8_t *);
6299                 else
6300                         ciphertext = plaintext;
6301
6302                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6303                                 ciphertext_len);
6304                 debug_hexdump(stdout, "ciphertext expected:",
6305                                 tdata->ciphertext.data,
6306                                 tdata->ciphertext.len_bits >> 3);
6307
6308                 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
6309                                 + (tdata->digest_enc.offset == 0 ?
6310                 plaintext_pad_len : tdata->digest_enc.offset);
6311
6312                 debug_hexdump(stdout, "digest:", ut_params->digest,
6313                                 tdata->digest_enc.len);
6314                 debug_hexdump(stdout, "digest expected:",
6315                                 tdata->digest_enc.data,
6316                                 tdata->digest_enc.len);
6317         }
6318
6319         /* Validate obuf */
6320         if (verify) {
6321                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6322                                 plaintext,
6323                                 tdata->plaintext.data,
6324                                 tdata->plaintext.len_bits >> 3,
6325                                 "Plaintext data not as expected");
6326         } else {
6327                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6328                                 ciphertext,
6329                                 tdata->ciphertext.data,
6330                                 tdata->validDataLen.len_bits,
6331                                 "Ciphertext data not as expected");
6332
6333                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6334                                 ut_params->digest,
6335                                 tdata->digest_enc.data,
6336                                 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
6337                                 "Generated auth tag not as expected");
6338         }
6339
6340         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6341                         "crypto op processing failed");
6342
6343         return 0;
6344 }
6345
6346 static int
6347 test_mixed_auth_cipher_sgl(const struct mixed_cipher_auth_test_data *tdata,
6348         uint8_t op_mode, uint8_t verify)
6349 {
6350         struct crypto_testsuite_params *ts_params = &testsuite_params;
6351         struct crypto_unittest_params *ut_params = &unittest_params;
6352
6353         int retval;
6354
6355         const uint8_t *plaintext = NULL;
6356         const uint8_t *ciphertext = NULL;
6357         const uint8_t *digest = NULL;
6358         unsigned int plaintext_pad_len;
6359         unsigned int plaintext_len;
6360         unsigned int ciphertext_pad_len;
6361         unsigned int ciphertext_len;
6362         uint8_t buffer[10000];
6363         uint8_t digest_buffer[10000];
6364
6365         struct rte_cryptodev_info dev_info;
6366         struct rte_crypto_op *op;
6367
6368         /* Check if device supports particular algorithms */
6369         if (test_mixed_check_if_unsupported(tdata))
6370                 return -ENOTSUP;
6371
6372         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6373
6374         uint64_t feat_flags = dev_info.feature_flags;
6375
6376         if (op_mode == IN_PLACE) {
6377                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6378                         printf("Device doesn't support in-place scatter-gather "
6379                                         "in both input and output mbufs.\n");
6380                         return -ENOTSUP;
6381                 }
6382         } else {
6383                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
6384                         printf("Device doesn't support out-of-place scatter-gather "
6385                                         "in both input and output mbufs.\n");
6386                         return -ENOTSUP;
6387                 }
6388                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6389                         printf("Device doesn't support digest encrypted.\n");
6390                         return -ENOTSUP;
6391                 }
6392         }
6393
6394         /* Create the session */
6395         if (verify)
6396                 retval = create_wireless_algo_cipher_auth_session(
6397                                 ts_params->valid_devs[0],
6398                                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
6399                                 RTE_CRYPTO_AUTH_OP_VERIFY,
6400                                 tdata->auth_algo,
6401                                 tdata->cipher_algo,
6402                                 tdata->auth_key.data, tdata->auth_key.len,
6403                                 tdata->auth_iv.len, tdata->digest_enc.len,
6404                                 tdata->cipher_iv.len);
6405         else
6406                 retval = create_wireless_algo_auth_cipher_session(
6407                                 ts_params->valid_devs[0],
6408                                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
6409                                 RTE_CRYPTO_AUTH_OP_GENERATE,
6410                                 tdata->auth_algo,
6411                                 tdata->cipher_algo,
6412                                 tdata->auth_key.data, tdata->auth_key.len,
6413                                 tdata->auth_iv.len, tdata->digest_enc.len,
6414                                 tdata->cipher_iv.len);
6415         if (retval < 0)
6416                 return retval;
6417
6418         ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
6419         plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
6420         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6421         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6422
6423         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
6424                         ciphertext_pad_len, 15, 0);
6425         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
6426                         "Failed to allocate input buffer in mempool");
6427
6428         if (op_mode == OUT_OF_PLACE) {
6429                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
6430                                 plaintext_pad_len, 15, 0);
6431                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
6432                                 "Failed to allocate output buffer in mempool");
6433         }
6434
6435         if (verify) {
6436                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
6437                         tdata->ciphertext.data);
6438                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6439                                         ciphertext_len, buffer);
6440                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6441                         ciphertext_len);
6442         } else {
6443                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
6444                         tdata->plaintext.data);
6445                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6446                                         plaintext_len, buffer);
6447                 debug_hexdump(stdout, "plaintext:", plaintext,
6448                         plaintext_len);
6449         }
6450         memset(buffer, 0, sizeof(buffer));
6451
6452         /* Create the operation */
6453         retval = create_wireless_algo_auth_cipher_operation(
6454                         tdata->digest_enc.data, tdata->digest_enc.len,
6455                         tdata->cipher_iv.data, tdata->cipher_iv.len,
6456                         tdata->auth_iv.data, tdata->auth_iv.len,
6457                         (tdata->digest_enc.offset == 0 ?
6458                                 plaintext_pad_len
6459                                 : tdata->digest_enc.offset),
6460                         tdata->validCipherLen.len_bits,
6461                         tdata->cipher.offset_bits,
6462                         tdata->validAuthLen.len_bits,
6463                         tdata->auth.offset_bits,
6464                         op_mode, 1, verify);
6465
6466         if (retval < 0)
6467                 return retval;
6468
6469         op = process_crypto_request(ts_params->valid_devs[0],
6470                         ut_params->op);
6471
6472         /* Check if the op failed because the device doesn't */
6473         /* support this particular combination of algorithms */
6474         if (op == NULL && ut_params->op->status ==
6475                         RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
6476                 printf("Device doesn't support this mixed combination. "
6477                                 "Test Skipped.\n");
6478                 return -ENOTSUP;
6479         }
6480
6481         ut_params->op = op;
6482
6483         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6484
6485         ut_params->obuf = (op_mode == IN_PLACE ?
6486                         ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6487
6488         if (verify) {
6489                 if (ut_params->obuf)
6490                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
6491                                         plaintext_len, buffer);
6492                 else
6493                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6494                                         plaintext_len, buffer);
6495
6496                 debug_hexdump(stdout, "plaintext:", plaintext,
6497                                 (tdata->plaintext.len_bits >> 3) -
6498                                 tdata->digest_enc.len);
6499                 debug_hexdump(stdout, "plaintext expected:",
6500                                 tdata->plaintext.data,
6501                                 (tdata->plaintext.len_bits >> 3) -
6502                                 tdata->digest_enc.len);
6503         } else {
6504                 if (ut_params->obuf)
6505                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
6506                                         ciphertext_len, buffer);
6507                 else
6508                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6509                                         ciphertext_len, buffer);
6510
6511                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6512                         ciphertext_len);
6513                 debug_hexdump(stdout, "ciphertext expected:",
6514                         tdata->ciphertext.data,
6515                         tdata->ciphertext.len_bits >> 3);
6516
6517                 if (ut_params->obuf)
6518                         digest = rte_pktmbuf_read(ut_params->obuf,
6519                                         (tdata->digest_enc.offset == 0 ?
6520                                                 plaintext_pad_len :
6521                                                 tdata->digest_enc.offset),
6522                                         tdata->digest_enc.len, digest_buffer);
6523                 else
6524                         digest = rte_pktmbuf_read(ut_params->ibuf,
6525                                         (tdata->digest_enc.offset == 0 ?
6526                                                 plaintext_pad_len :
6527                                                 tdata->digest_enc.offset),
6528                                         tdata->digest_enc.len, digest_buffer);
6529
6530                 debug_hexdump(stdout, "digest:", digest,
6531                                 tdata->digest_enc.len);
6532                 debug_hexdump(stdout, "digest expected:",
6533                                 tdata->digest_enc.data, tdata->digest_enc.len);
6534         }
6535
6536         /* Validate obuf */
6537         if (verify) {
6538                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6539                                 plaintext,
6540                                 tdata->plaintext.data,
6541                                 tdata->plaintext.len_bits >> 3,
6542                                 "Plaintext data not as expected");
6543         } else {
6544                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6545                                 ciphertext,
6546                                 tdata->ciphertext.data,
6547                                 tdata->validDataLen.len_bits,
6548                                 "Ciphertext data not as expected");
6549                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6550                                 digest,
6551                                 tdata->digest_enc.data,
6552                                 tdata->digest_enc.len,
6553                                 "Generated auth tag not as expected");
6554         }
6555
6556         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6557                         "crypto op processing failed");
6558
6559         return 0;
6560 }
6561
6562 /** AUTH AES CMAC + CIPHER AES CTR */
6563
6564 static int
6565 test_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
6566 {
6567         return test_mixed_auth_cipher(
6568                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
6569 }
6570
6571 static int
6572 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
6573 {
6574         return test_mixed_auth_cipher(
6575                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
6576 }
6577
6578 static int
6579 test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
6580 {
6581         return test_mixed_auth_cipher_sgl(
6582                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
6583 }
6584
6585 static int
6586 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
6587 {
6588         return test_mixed_auth_cipher_sgl(
6589                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
6590 }
6591
6592 static int
6593 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
6594 {
6595         return test_mixed_auth_cipher(
6596                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
6597 }
6598
6599 static int
6600 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
6601 {
6602         return test_mixed_auth_cipher(
6603                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
6604 }
6605
6606 static int
6607 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
6608 {
6609         return test_mixed_auth_cipher_sgl(
6610                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
6611 }
6612
6613 static int
6614 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
6615 {
6616         return test_mixed_auth_cipher_sgl(
6617                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
6618 }
6619
6620 /** MIXED AUTH + CIPHER */
6621
6622 static int
6623 test_auth_zuc_cipher_snow_test_case_1(void)
6624 {
6625         return test_mixed_auth_cipher(
6626                 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
6627 }
6628
6629 static int
6630 test_verify_auth_zuc_cipher_snow_test_case_1(void)
6631 {
6632         return test_mixed_auth_cipher(
6633                 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
6634 }
6635
6636 static int
6637 test_auth_aes_cmac_cipher_snow_test_case_1(void)
6638 {
6639         return test_mixed_auth_cipher(
6640                 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
6641 }
6642
6643 static int
6644 test_verify_auth_aes_cmac_cipher_snow_test_case_1(void)
6645 {
6646         return test_mixed_auth_cipher(
6647                 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
6648 }
6649
6650 static int
6651 test_auth_zuc_cipher_aes_ctr_test_case_1(void)
6652 {
6653         return test_mixed_auth_cipher(
6654                 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
6655 }
6656
6657 static int
6658 test_verify_auth_zuc_cipher_aes_ctr_test_case_1(void)
6659 {
6660         return test_mixed_auth_cipher(
6661                 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
6662 }
6663
6664 static int
6665 test_auth_snow_cipher_aes_ctr_test_case_1(void)
6666 {
6667         return test_mixed_auth_cipher(
6668                 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
6669 }
6670
6671 static int
6672 test_verify_auth_snow_cipher_aes_ctr_test_case_1(void)
6673 {
6674         return test_mixed_auth_cipher(
6675                 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
6676 }
6677
6678 static int
6679 test_auth_snow_cipher_zuc_test_case_1(void)
6680 {
6681         return test_mixed_auth_cipher(
6682                 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
6683 }
6684
6685 static int
6686 test_verify_auth_snow_cipher_zuc_test_case_1(void)
6687 {
6688         return test_mixed_auth_cipher(
6689                 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
6690 }
6691
6692 static int
6693 test_auth_aes_cmac_cipher_zuc_test_case_1(void)
6694 {
6695         return test_mixed_auth_cipher(
6696                 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
6697 }
6698
6699 static int
6700 test_verify_auth_aes_cmac_cipher_zuc_test_case_1(void)
6701 {
6702         return test_mixed_auth_cipher(
6703                 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
6704 }
6705
6706 static int
6707 test_auth_null_cipher_snow_test_case_1(void)
6708 {
6709         return test_mixed_auth_cipher(
6710                 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
6711 }
6712
6713 static int
6714 test_verify_auth_null_cipher_snow_test_case_1(void)
6715 {
6716         return test_mixed_auth_cipher(
6717                 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
6718 }
6719
6720 static int
6721 test_auth_null_cipher_zuc_test_case_1(void)
6722 {
6723         return test_mixed_auth_cipher(
6724                 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
6725 }
6726
6727 static int
6728 test_verify_auth_null_cipher_zuc_test_case_1(void)
6729 {
6730         return test_mixed_auth_cipher(
6731                 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
6732 }
6733
6734 static int
6735 test_auth_snow_cipher_null_test_case_1(void)
6736 {
6737         return test_mixed_auth_cipher(
6738                 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 0);
6739 }
6740
6741 static int
6742 test_verify_auth_snow_cipher_null_test_case_1(void)
6743 {
6744         return test_mixed_auth_cipher(
6745                 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 1);
6746 }
6747
6748 static int
6749 test_auth_zuc_cipher_null_test_case_1(void)
6750 {
6751         return test_mixed_auth_cipher(
6752                 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 0);
6753 }
6754
6755 static int
6756 test_verify_auth_zuc_cipher_null_test_case_1(void)
6757 {
6758         return test_mixed_auth_cipher(
6759                 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 1);
6760 }
6761
6762 static int
6763 test_auth_null_cipher_aes_ctr_test_case_1(void)
6764 {
6765         return test_mixed_auth_cipher(
6766                 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
6767 }
6768
6769 static int
6770 test_verify_auth_null_cipher_aes_ctr_test_case_1(void)
6771 {
6772         return test_mixed_auth_cipher(
6773                 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
6774 }
6775
6776 static int
6777 test_auth_aes_cmac_cipher_null_test_case_1(void)
6778 {
6779         return test_mixed_auth_cipher(
6780                 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 0);
6781 }
6782
6783 static int
6784 test_verify_auth_aes_cmac_cipher_null_test_case_1(void)
6785 {
6786         return test_mixed_auth_cipher(
6787                 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 1);
6788 }
6789
6790 /* ***** AEAD algorithm Tests ***** */
6791
6792 static int
6793 create_aead_session(uint8_t dev_id, enum rte_crypto_aead_algorithm algo,
6794                 enum rte_crypto_aead_operation op,
6795                 const uint8_t *key, const uint8_t key_len,
6796                 const uint16_t aad_len, const uint8_t auth_len,
6797                 uint8_t iv_len)
6798 {
6799         uint8_t aead_key[key_len];
6800
6801         struct crypto_testsuite_params *ts_params = &testsuite_params;
6802         struct crypto_unittest_params *ut_params = &unittest_params;
6803
6804         memcpy(aead_key, key, key_len);
6805
6806         /* Setup AEAD Parameters */
6807         ut_params->aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD;
6808         ut_params->aead_xform.next = NULL;
6809         ut_params->aead_xform.aead.algo = algo;
6810         ut_params->aead_xform.aead.op = op;
6811         ut_params->aead_xform.aead.key.data = aead_key;
6812         ut_params->aead_xform.aead.key.length = key_len;
6813         ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
6814         ut_params->aead_xform.aead.iv.length = iv_len;
6815         ut_params->aead_xform.aead.digest_length = auth_len;
6816         ut_params->aead_xform.aead.aad_length = aad_len;
6817
6818         debug_hexdump(stdout, "key:", key, key_len);
6819
6820         /* Create Crypto session*/
6821         ut_params->sess = rte_cryptodev_sym_session_create(
6822                         ts_params->session_mpool);
6823
6824         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
6825                         &ut_params->aead_xform,
6826                         ts_params->session_priv_mpool);
6827
6828         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6829
6830         return 0;
6831 }
6832
6833 static int
6834 create_aead_xform(struct rte_crypto_op *op,
6835                 enum rte_crypto_aead_algorithm algo,
6836                 enum rte_crypto_aead_operation aead_op,
6837                 uint8_t *key, const uint8_t key_len,
6838                 const uint8_t aad_len, const uint8_t auth_len,
6839                 uint8_t iv_len)
6840 {
6841         TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 1),
6842                         "failed to allocate space for crypto transform");
6843
6844         struct rte_crypto_sym_op *sym_op = op->sym;
6845
6846         /* Setup AEAD Parameters */
6847         sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_AEAD;
6848         sym_op->xform->next = NULL;
6849         sym_op->xform->aead.algo = algo;
6850         sym_op->xform->aead.op = aead_op;
6851         sym_op->xform->aead.key.data = key;
6852         sym_op->xform->aead.key.length = key_len;
6853         sym_op->xform->aead.iv.offset = IV_OFFSET;
6854         sym_op->xform->aead.iv.length = iv_len;
6855         sym_op->xform->aead.digest_length = auth_len;
6856         sym_op->xform->aead.aad_length = aad_len;
6857
6858         debug_hexdump(stdout, "key:", key, key_len);
6859
6860         return 0;
6861 }
6862
6863 static int
6864 create_aead_operation(enum rte_crypto_aead_operation op,
6865                 const struct aead_test_data *tdata)
6866 {
6867         struct crypto_testsuite_params *ts_params = &testsuite_params;
6868         struct crypto_unittest_params *ut_params = &unittest_params;
6869
6870         uint8_t *plaintext, *ciphertext;
6871         unsigned int aad_pad_len, plaintext_pad_len;
6872
6873         /* Generate Crypto op data structure */
6874         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
6875                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
6876         TEST_ASSERT_NOT_NULL(ut_params->op,
6877                         "Failed to allocate symmetric crypto operation struct");
6878
6879         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
6880
6881         /* Append aad data */
6882         if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
6883                 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len + 18, 16);
6884                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6885                                 aad_pad_len);
6886                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
6887                                 "no room to append aad");
6888
6889                 sym_op->aead.aad.phys_addr =
6890                                 rte_pktmbuf_iova(ut_params->ibuf);
6891                 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
6892                 memcpy(sym_op->aead.aad.data + 18, tdata->aad.data, tdata->aad.len);
6893                 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
6894                         tdata->aad.len);
6895
6896                 /* Append IV at the end of the crypto operation*/
6897                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
6898                                 uint8_t *, IV_OFFSET);
6899
6900                 /* Copy IV 1 byte after the IV pointer, according to the API */
6901                 rte_memcpy(iv_ptr + 1, tdata->iv.data, tdata->iv.len);
6902                 debug_hexdump(stdout, "iv:", iv_ptr,
6903                         tdata->iv.len);
6904         } else {
6905                 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
6906                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6907                                 aad_pad_len);
6908                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
6909                                 "no room to append aad");
6910
6911                 sym_op->aead.aad.phys_addr =
6912                                 rte_pktmbuf_iova(ut_params->ibuf);
6913                 memcpy(sym_op->aead.aad.data, tdata->aad.data, tdata->aad.len);
6914                 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
6915                         tdata->aad.len);
6916
6917                 /* Append IV at the end of the crypto operation*/
6918                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
6919                                 uint8_t *, IV_OFFSET);
6920
6921                 if (tdata->iv.len == 0) {
6922                         rte_memcpy(iv_ptr, tdata->iv.data, AES_GCM_J0_LENGTH);
6923                         debug_hexdump(stdout, "iv:", iv_ptr,
6924                                 AES_GCM_J0_LENGTH);
6925                 } else {
6926                         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
6927                         debug_hexdump(stdout, "iv:", iv_ptr,
6928                                 tdata->iv.len);
6929                 }
6930         }
6931
6932         /* Append plaintext/ciphertext */
6933         if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
6934                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
6935                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6936                                 plaintext_pad_len);
6937                 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
6938
6939                 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
6940                 debug_hexdump(stdout, "plaintext:", plaintext,
6941                                 tdata->plaintext.len);
6942
6943                 if (ut_params->obuf) {
6944                         ciphertext = (uint8_t *)rte_pktmbuf_append(
6945                                         ut_params->obuf,
6946                                         plaintext_pad_len + aad_pad_len);
6947                         TEST_ASSERT_NOT_NULL(ciphertext,
6948                                         "no room to append ciphertext");
6949
6950                         memset(ciphertext + aad_pad_len, 0,
6951                                         tdata->ciphertext.len);
6952                 }
6953         } else {
6954                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16);
6955                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6956                                 plaintext_pad_len);
6957                 TEST_ASSERT_NOT_NULL(ciphertext,
6958                                 "no room to append ciphertext");
6959
6960                 memcpy(ciphertext, tdata->ciphertext.data,
6961                                 tdata->ciphertext.len);
6962                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6963                                 tdata->ciphertext.len);
6964
6965                 if (ut_params->obuf) {
6966                         plaintext = (uint8_t *)rte_pktmbuf_append(
6967                                         ut_params->obuf,
6968                                         plaintext_pad_len + aad_pad_len);
6969                         TEST_ASSERT_NOT_NULL(plaintext,
6970                                         "no room to append plaintext");
6971
6972                         memset(plaintext + aad_pad_len, 0,
6973                                         tdata->plaintext.len);
6974                 }
6975         }
6976
6977         /* Append digest data */
6978         if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
6979                 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
6980                                 ut_params->obuf ? ut_params->obuf :
6981                                                 ut_params->ibuf,
6982                                                 tdata->auth_tag.len);
6983                 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
6984                                 "no room to append digest");
6985                 memset(sym_op->aead.digest.data, 0, tdata->auth_tag.len);
6986                 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
6987                                 ut_params->obuf ? ut_params->obuf :
6988                                                 ut_params->ibuf,
6989                                                 plaintext_pad_len +
6990                                                 aad_pad_len);
6991         } else {
6992                 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
6993                                 ut_params->ibuf, tdata->auth_tag.len);
6994                 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
6995                                 "no room to append digest");
6996                 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
6997                                 ut_params->ibuf,
6998                                 plaintext_pad_len + aad_pad_len);
6999
7000                 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
7001                         tdata->auth_tag.len);
7002                 debug_hexdump(stdout, "digest:",
7003                         sym_op->aead.digest.data,
7004                         tdata->auth_tag.len);
7005         }
7006
7007         sym_op->aead.data.length = tdata->plaintext.len;
7008         sym_op->aead.data.offset = aad_pad_len;
7009
7010         return 0;
7011 }
7012
7013 static int
7014 test_authenticated_encryption(const struct aead_test_data *tdata)
7015 {
7016         struct crypto_testsuite_params *ts_params = &testsuite_params;
7017         struct crypto_unittest_params *ut_params = &unittest_params;
7018
7019         int retval;
7020         uint8_t *ciphertext, *auth_tag;
7021         uint16_t plaintext_pad_len;
7022         uint32_t i;
7023
7024         /* Verify the capabilities */
7025         struct rte_cryptodev_sym_capability_idx cap_idx;
7026         const struct rte_cryptodev_symmetric_capability *capability;
7027         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
7028         cap_idx.algo.aead = tdata->algo;
7029         capability = rte_cryptodev_sym_capability_get(
7030                         ts_params->valid_devs[0], &cap_idx);
7031         if (capability == NULL)
7032                 return -ENOTSUP;
7033         if (rte_cryptodev_sym_capability_check_aead(
7034                         capability, tdata->key.len, tdata->auth_tag.len,
7035                         tdata->aad.len, tdata->iv.len))
7036                 return -ENOTSUP;
7037
7038         /* Create AEAD session */
7039         retval = create_aead_session(ts_params->valid_devs[0],
7040                         tdata->algo,
7041                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
7042                         tdata->key.data, tdata->key.len,
7043                         tdata->aad.len, tdata->auth_tag.len,
7044                         tdata->iv.len);
7045         if (retval < 0)
7046                 return retval;
7047
7048         if (tdata->aad.len > MBUF_SIZE) {
7049                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
7050                 /* Populate full size of add data */
7051                 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
7052                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
7053         } else
7054                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7055
7056         /* clear mbuf payload */
7057         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7058                         rte_pktmbuf_tailroom(ut_params->ibuf));
7059
7060         /* Create AEAD operation */
7061         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
7062         if (retval < 0)
7063                 return retval;
7064
7065         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
7066
7067         ut_params->op->sym->m_src = ut_params->ibuf;
7068
7069         /* Process crypto operation */
7070         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
7071                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
7072         else
7073                 TEST_ASSERT_NOT_NULL(
7074                         process_crypto_request(ts_params->valid_devs[0],
7075                         ut_params->op), "failed to process sym crypto op");
7076
7077         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7078                         "crypto op processing failed");
7079
7080         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
7081
7082         if (ut_params->op->sym->m_dst) {
7083                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
7084                                 uint8_t *);
7085                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
7086                                 uint8_t *, plaintext_pad_len);
7087         } else {
7088                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
7089                                 uint8_t *,
7090                                 ut_params->op->sym->cipher.data.offset);
7091                 auth_tag = ciphertext + plaintext_pad_len;
7092         }
7093
7094         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
7095         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
7096
7097         /* Validate obuf */
7098         TEST_ASSERT_BUFFERS_ARE_EQUAL(
7099                         ciphertext,
7100                         tdata->ciphertext.data,
7101                         tdata->ciphertext.len,
7102                         "Ciphertext data not as expected");
7103
7104         TEST_ASSERT_BUFFERS_ARE_EQUAL(
7105                         auth_tag,
7106                         tdata->auth_tag.data,
7107                         tdata->auth_tag.len,
7108                         "Generated auth tag not as expected");
7109
7110         return 0;
7111
7112 }
7113
7114 #ifdef RTE_LIBRTE_SECURITY
7115 /* Basic algorithm run function for async inplace mode.
7116  * Creates a session from input parameters and runs one operation
7117  * on input_vec. Checks the output of the crypto operation against
7118  * output_vec.
7119  */
7120 static int
7121 test_pdcp_proto(int i, int oop,
7122         enum rte_crypto_cipher_operation opc,
7123         enum rte_crypto_auth_operation opa,
7124         uint8_t *input_vec,
7125         unsigned int input_vec_len,
7126         uint8_t *output_vec,
7127         unsigned int output_vec_len)
7128 {
7129         struct crypto_testsuite_params *ts_params = &testsuite_params;
7130         struct crypto_unittest_params *ut_params = &unittest_params;
7131         uint8_t *plaintext;
7132         int ret = TEST_SUCCESS;
7133         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
7134                                 rte_cryptodev_get_sec_ctx(
7135                                 ts_params->valid_devs[0]);
7136
7137         /* Verify the capabilities */
7138         struct rte_security_capability_idx sec_cap_idx;
7139
7140         sec_cap_idx.action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
7141         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
7142         sec_cap_idx.pdcp.domain = pdcp_test_params[i].domain;
7143         if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
7144                 return -ENOTSUP;
7145
7146         /* Generate test mbuf data */
7147         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7148
7149         /* clear mbuf payload */
7150         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7151                         rte_pktmbuf_tailroom(ut_params->ibuf));
7152
7153         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7154                                                   input_vec_len);
7155         memcpy(plaintext, input_vec, input_vec_len);
7156
7157         /* Out of place support */
7158         if (oop) {
7159                 /*
7160                  * For out-op-place we need to alloc another mbuf
7161                  */
7162                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7163                 rte_pktmbuf_append(ut_params->obuf, output_vec_len);
7164         }
7165
7166         /* Set crypto type as IPSEC */
7167         ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
7168
7169         /* Setup Cipher Parameters */
7170         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
7171         ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg;
7172         ut_params->cipher_xform.cipher.op = opc;
7173         ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i];
7174         ut_params->cipher_xform.cipher.key.length =
7175                                         pdcp_test_params[i].cipher_key_len;
7176         ut_params->cipher_xform.cipher.iv.length = 0;
7177
7178         /* Setup HMAC Parameters if ICV header is required */
7179         if (pdcp_test_params[i].auth_alg != 0) {
7180                 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
7181                 ut_params->auth_xform.next = NULL;
7182                 ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg;
7183                 ut_params->auth_xform.auth.op = opa;
7184                 ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i];
7185                 ut_params->auth_xform.auth.key.length =
7186                                         pdcp_test_params[i].auth_key_len;
7187
7188                 ut_params->cipher_xform.next = &ut_params->auth_xform;
7189         } else {
7190                 ut_params->cipher_xform.next = NULL;
7191         }
7192
7193         struct rte_security_session_conf sess_conf = {
7194                 .action_type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
7195                 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
7196                 {.pdcp = {
7197                         .bearer = pdcp_test_bearer[i],
7198                         .domain = pdcp_test_params[i].domain,
7199                         .pkt_dir = pdcp_test_packet_direction[i],
7200                         .sn_size = pdcp_test_data_sn_size[i],
7201                         .hfn = pdcp_test_hfn[i],
7202                         .hfn_threshold = pdcp_test_hfn_threshold[i],
7203                 } },
7204                 .crypto_xform = &ut_params->cipher_xform
7205         };
7206
7207         /* Create security session */
7208         ut_params->sec_session = rte_security_session_create(ctx,
7209                                 &sess_conf, ts_params->session_priv_mpool);
7210
7211         if (!ut_params->sec_session) {
7212                 printf("TestCase %s()-%d line %d failed %s: ",
7213                         __func__, i, __LINE__, "Failed to allocate session");
7214                 ret = TEST_FAILED;
7215                 goto on_err;
7216         }
7217
7218         /* Generate crypto op data structure */
7219         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7220                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7221         if (!ut_params->op) {
7222                 printf("TestCase %s()-%d line %d failed %s: ",
7223                         __func__, i, __LINE__,
7224                         "Failed to allocate symmetric crypto operation struct");
7225                 ret = TEST_FAILED;
7226                 goto on_err;
7227         }
7228
7229         rte_security_attach_session(ut_params->op, ut_params->sec_session);
7230
7231         /* set crypto operation source mbuf */
7232         ut_params->op->sym->m_src = ut_params->ibuf;
7233         if (oop)
7234                 ut_params->op->sym->m_dst = ut_params->obuf;
7235
7236         /* Process crypto operation */
7237         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op)
7238                 == NULL) {
7239                 printf("TestCase %s()-%d line %d failed %s: ",
7240                         __func__, i, __LINE__,
7241                         "failed to process sym crypto op");
7242                 ret = TEST_FAILED;
7243                 goto on_err;
7244         }
7245
7246         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
7247                 printf("TestCase %s()-%d line %d failed %s: ",
7248                         __func__, i, __LINE__, "crypto op processing failed");
7249                 ret = TEST_FAILED;
7250                 goto on_err;
7251         }
7252
7253         /* Validate obuf */
7254         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
7255                         uint8_t *);
7256         if (oop) {
7257                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
7258                                 uint8_t *);
7259         }
7260
7261         if (memcmp(ciphertext, output_vec, output_vec_len)) {
7262                 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
7263                 rte_hexdump(stdout, "encrypted", ciphertext, output_vec_len);
7264                 rte_hexdump(stdout, "reference", output_vec, output_vec_len);
7265                 ret = TEST_FAILED;
7266                 goto on_err;
7267         }
7268
7269 on_err:
7270         rte_crypto_op_free(ut_params->op);
7271         ut_params->op = NULL;
7272
7273         if (ut_params->sec_session)
7274                 rte_security_session_destroy(ctx, ut_params->sec_session);
7275         ut_params->sec_session = NULL;
7276
7277         rte_pktmbuf_free(ut_params->ibuf);
7278         ut_params->ibuf = NULL;
7279         if (oop) {
7280                 rte_pktmbuf_free(ut_params->obuf);
7281                 ut_params->obuf = NULL;
7282         }
7283
7284         return ret;
7285 }
7286
7287 static int
7288 test_pdcp_proto_SGL(int i, int oop,
7289         enum rte_crypto_cipher_operation opc,
7290         enum rte_crypto_auth_operation opa,
7291         uint8_t *input_vec,
7292         unsigned int input_vec_len,
7293         uint8_t *output_vec,
7294         unsigned int output_vec_len,
7295         uint32_t fragsz,
7296         uint32_t fragsz_oop)
7297 {
7298         struct crypto_testsuite_params *ts_params = &testsuite_params;
7299         struct crypto_unittest_params *ut_params = &unittest_params;
7300         uint8_t *plaintext;
7301         struct rte_mbuf *buf, *buf_oop = NULL;
7302         int ret = TEST_SUCCESS;
7303         int to_trn = 0;
7304         int to_trn_tbl[16];
7305         int segs = 1;
7306         unsigned int trn_data = 0;
7307         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
7308                                 rte_cryptodev_get_sec_ctx(
7309                                 ts_params->valid_devs[0]);
7310
7311         /* Verify the capabilities */
7312         struct rte_security_capability_idx sec_cap_idx;
7313
7314         sec_cap_idx.action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
7315         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
7316         sec_cap_idx.pdcp.domain = pdcp_test_params[i].domain;
7317         if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
7318                 return -ENOTSUP;
7319
7320         if (fragsz > input_vec_len)
7321                 fragsz = input_vec_len;
7322
7323         uint16_t plaintext_len = fragsz;
7324         uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
7325
7326         if (fragsz_oop > output_vec_len)
7327                 frag_size_oop = output_vec_len;
7328
7329         int ecx = 0;
7330         if (input_vec_len % fragsz != 0) {
7331                 if (input_vec_len / fragsz + 1 > 16)
7332                         return 1;
7333         } else if (input_vec_len / fragsz > 16)
7334                 return 1;
7335
7336         /* Out of place support */
7337         if (oop) {
7338                 /*
7339                  * For out-op-place we need to alloc another mbuf
7340                  */
7341                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7342                 rte_pktmbuf_append(ut_params->obuf, frag_size_oop);
7343                 buf_oop = ut_params->obuf;
7344         }
7345
7346         /* Generate test mbuf data */
7347         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7348
7349         /* clear mbuf payload */
7350         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7351                         rte_pktmbuf_tailroom(ut_params->ibuf));
7352
7353         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7354                                                   plaintext_len);
7355         memcpy(plaintext, input_vec, plaintext_len);
7356         trn_data += plaintext_len;
7357
7358         buf = ut_params->ibuf;
7359
7360         /*
7361          * Loop until no more fragments
7362          */
7363
7364         while (trn_data < input_vec_len) {
7365                 ++segs;
7366                 to_trn = (input_vec_len - trn_data < fragsz) ?
7367                                 (input_vec_len - trn_data) : fragsz;
7368
7369                 to_trn_tbl[ecx++] = to_trn;
7370
7371                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7372                 buf = buf->next;
7373
7374                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
7375                                 rte_pktmbuf_tailroom(buf));
7376
7377                 /* OOP */
7378                 if (oop && !fragsz_oop) {
7379                         buf_oop->next =
7380                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
7381                         buf_oop = buf_oop->next;
7382                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
7383                                         0, rte_pktmbuf_tailroom(buf_oop));
7384                         rte_pktmbuf_append(buf_oop, to_trn);
7385                 }
7386
7387                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
7388                                 to_trn);
7389
7390                 memcpy(plaintext, input_vec + trn_data, to_trn);
7391                 trn_data += to_trn;
7392         }
7393
7394         ut_params->ibuf->nb_segs = segs;
7395
7396         segs = 1;
7397         if (fragsz_oop && oop) {
7398                 to_trn = 0;
7399                 ecx = 0;
7400
7401                 trn_data = frag_size_oop;
7402                 while (trn_data < output_vec_len) {
7403                         ++segs;
7404                         to_trn =
7405                                 (output_vec_len - trn_data <
7406                                                 frag_size_oop) ?
7407                                 (output_vec_len - trn_data) :
7408                                                 frag_size_oop;
7409
7410                         to_trn_tbl[ecx++] = to_trn;
7411
7412                         buf_oop->next =
7413                                 rte_pktmbuf_alloc(ts_params->mbuf_pool);
7414                         buf_oop = buf_oop->next;
7415                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
7416                                         0, rte_pktmbuf_tailroom(buf_oop));
7417                         rte_pktmbuf_append(buf_oop, to_trn);
7418
7419                         trn_data += to_trn;
7420                 }
7421                 ut_params->obuf->nb_segs = segs;
7422         }
7423
7424         ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
7425
7426         /* Setup Cipher Parameters */
7427         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
7428         ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg;
7429         ut_params->cipher_xform.cipher.op = opc;
7430         ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i];
7431         ut_params->cipher_xform.cipher.key.length =
7432                                         pdcp_test_params[i].cipher_key_len;
7433         ut_params->cipher_xform.cipher.iv.length = 0;
7434
7435         /* Setup HMAC Parameters if ICV header is required */
7436         if (pdcp_test_params[i].auth_alg != 0) {
7437                 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
7438                 ut_params->auth_xform.next = NULL;
7439                 ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg;
7440                 ut_params->auth_xform.auth.op = opa;
7441                 ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i];
7442                 ut_params->auth_xform.auth.key.length =
7443                                         pdcp_test_params[i].auth_key_len;
7444
7445                 ut_params->cipher_xform.next = &ut_params->auth_xform;
7446         } else {
7447                 ut_params->cipher_xform.next = NULL;
7448         }
7449
7450         struct rte_security_session_conf sess_conf = {
7451                 .action_type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
7452                 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
7453                 {.pdcp = {
7454                         .bearer = pdcp_test_bearer[i],
7455                         .domain = pdcp_test_params[i].domain,
7456                         .pkt_dir = pdcp_test_packet_direction[i],
7457                         .sn_size = pdcp_test_data_sn_size[i],
7458                         .hfn = pdcp_test_hfn[i],
7459                         .hfn_threshold = pdcp_test_hfn_threshold[i],
7460                 } },
7461                 .crypto_xform = &ut_params->cipher_xform
7462         };
7463
7464         /* Create security session */
7465         ut_params->sec_session = rte_security_session_create(ctx,
7466                                 &sess_conf, ts_params->session_priv_mpool);
7467
7468         if (!ut_params->sec_session) {
7469                 printf("TestCase %s()-%d line %d failed %s: ",
7470                         __func__, i, __LINE__, "Failed to allocate session");
7471                 ret = TEST_FAILED;
7472                 goto on_err;
7473         }
7474
7475         /* Generate crypto op data structure */
7476         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7477                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7478         if (!ut_params->op) {
7479                 printf("TestCase %s()-%d line %d failed %s: ",
7480                         __func__, i, __LINE__,
7481                         "Failed to allocate symmetric crypto operation struct");
7482                 ret = TEST_FAILED;
7483                 goto on_err;
7484         }
7485
7486         rte_security_attach_session(ut_params->op, ut_params->sec_session);
7487
7488         /* set crypto operation source mbuf */
7489         ut_params->op->sym->m_src = ut_params->ibuf;
7490         if (oop)
7491                 ut_params->op->sym->m_dst = ut_params->obuf;
7492
7493         /* Process crypto operation */
7494         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op)
7495                 == NULL) {
7496                 printf("TestCase %s()-%d line %d failed %s: ",
7497                         __func__, i, __LINE__,
7498                         "failed to process sym crypto op");
7499                 ret = TEST_FAILED;
7500                 goto on_err;
7501         }
7502
7503         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
7504                 printf("TestCase %s()-%d line %d failed %s: ",
7505                         __func__, i, __LINE__, "crypto op processing failed");
7506                 ret = TEST_FAILED;
7507                 goto on_err;
7508         }
7509
7510         /* Validate obuf */
7511         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
7512                         uint8_t *);
7513         if (oop) {
7514                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
7515                                 uint8_t *);
7516         }
7517         if (fragsz_oop)
7518                 fragsz = frag_size_oop;
7519         if (memcmp(ciphertext, output_vec, fragsz)) {
7520                 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
7521                 rte_hexdump(stdout, "encrypted", ciphertext, fragsz);
7522                 rte_hexdump(stdout, "reference", output_vec, fragsz);
7523                 ret = TEST_FAILED;
7524                 goto on_err;
7525         }
7526
7527         buf = ut_params->op->sym->m_src->next;
7528         if (oop)
7529                 buf = ut_params->op->sym->m_dst->next;
7530
7531         unsigned int off = fragsz;
7532
7533         ecx = 0;
7534         while (buf) {
7535                 ciphertext = rte_pktmbuf_mtod(buf,
7536                                 uint8_t *);
7537                 if (memcmp(ciphertext, output_vec + off, to_trn_tbl[ecx])) {
7538                         printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
7539                         rte_hexdump(stdout, "encrypted", ciphertext, to_trn_tbl[ecx]);
7540                         rte_hexdump(stdout, "reference", output_vec + off,
7541                                         to_trn_tbl[ecx]);
7542                         ret = TEST_FAILED;
7543                         goto on_err;
7544                 }
7545                 off += to_trn_tbl[ecx++];
7546                 buf = buf->next;
7547         }
7548 on_err:
7549         rte_crypto_op_free(ut_params->op);
7550         ut_params->op = NULL;
7551
7552         if (ut_params->sec_session)
7553                 rte_security_session_destroy(ctx, ut_params->sec_session);
7554         ut_params->sec_session = NULL;
7555
7556         rte_pktmbuf_free(ut_params->ibuf);
7557         ut_params->ibuf = NULL;
7558         if (oop) {
7559                 rte_pktmbuf_free(ut_params->obuf);
7560                 ut_params->obuf = NULL;
7561         }
7562
7563         return ret;
7564 }
7565
7566 int
7567 test_pdcp_proto_cplane_encap(int i)
7568 {
7569         return test_pdcp_proto(i, 0,
7570                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7571                 RTE_CRYPTO_AUTH_OP_GENERATE,
7572                 pdcp_test_data_in[i],
7573                 pdcp_test_data_in_len[i],
7574                 pdcp_test_data_out[i],
7575                 pdcp_test_data_in_len[i]+4);
7576 }
7577
7578 int
7579 test_pdcp_proto_uplane_encap(int i)
7580 {
7581         return test_pdcp_proto(i, 0,
7582                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7583                 RTE_CRYPTO_AUTH_OP_GENERATE,
7584                 pdcp_test_data_in[i],
7585                 pdcp_test_data_in_len[i],
7586                 pdcp_test_data_out[i],
7587                 pdcp_test_data_in_len[i]);
7588
7589 }
7590
7591 int
7592 test_pdcp_proto_uplane_encap_with_int(int i)
7593 {
7594         return test_pdcp_proto(i, 0,
7595                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7596                 RTE_CRYPTO_AUTH_OP_GENERATE,
7597                 pdcp_test_data_in[i],
7598                 pdcp_test_data_in_len[i],
7599                 pdcp_test_data_out[i],
7600                 pdcp_test_data_in_len[i] + 4);
7601 }
7602
7603 int
7604 test_pdcp_proto_cplane_decap(int i)
7605 {
7606         return test_pdcp_proto(i, 0,
7607                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
7608                 RTE_CRYPTO_AUTH_OP_VERIFY,
7609                 pdcp_test_data_out[i],
7610                 pdcp_test_data_in_len[i] + 4,
7611                 pdcp_test_data_in[i],
7612                 pdcp_test_data_in_len[i]);
7613 }
7614
7615 int
7616 test_pdcp_proto_uplane_decap(int i)
7617 {
7618         return test_pdcp_proto(i, 0,
7619                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
7620                 RTE_CRYPTO_AUTH_OP_VERIFY,
7621                 pdcp_test_data_out[i],
7622                 pdcp_test_data_in_len[i],
7623                 pdcp_test_data_in[i],
7624                 pdcp_test_data_in_len[i]);
7625 }
7626
7627 int
7628 test_pdcp_proto_uplane_decap_with_int(int i)
7629 {
7630         return test_pdcp_proto(i, 0,
7631                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
7632                 RTE_CRYPTO_AUTH_OP_VERIFY,
7633                 pdcp_test_data_out[i],
7634                 pdcp_test_data_in_len[i] + 4,
7635                 pdcp_test_data_in[i],
7636                 pdcp_test_data_in_len[i]);
7637 }
7638
7639 static int
7640 test_PDCP_PROTO_SGL_in_place_32B(void)
7641 {
7642         /* i can be used for running any PDCP case
7643          * In this case it is uplane 12-bit AES-SNOW DL encap
7644          */
7645         int i = PDCP_UPLANE_12BIT_OFFSET + AES_ENC + SNOW_AUTH + DOWNLINK;
7646         return test_pdcp_proto_SGL(i, IN_PLACE,
7647                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7648                         RTE_CRYPTO_AUTH_OP_GENERATE,
7649                         pdcp_test_data_in[i],
7650                         pdcp_test_data_in_len[i],
7651                         pdcp_test_data_out[i],
7652                         pdcp_test_data_in_len[i]+4,
7653                         32, 0);
7654 }
7655 static int
7656 test_PDCP_PROTO_SGL_oop_32B_128B(void)
7657 {
7658         /* i can be used for running any PDCP case
7659          * In this case it is uplane 18-bit NULL-NULL DL encap
7660          */
7661         int i = PDCP_UPLANE_18BIT_OFFSET + NULL_ENC + NULL_AUTH + DOWNLINK;
7662         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
7663                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7664                         RTE_CRYPTO_AUTH_OP_GENERATE,
7665                         pdcp_test_data_in[i],
7666                         pdcp_test_data_in_len[i],
7667                         pdcp_test_data_out[i],
7668                         pdcp_test_data_in_len[i]+4,
7669                         32, 128);
7670 }
7671 static int
7672 test_PDCP_PROTO_SGL_oop_32B_40B(void)
7673 {
7674         /* i can be used for running any PDCP case
7675          * In this case it is uplane 18-bit AES DL encap
7676          */
7677         int i = PDCP_UPLANE_OFFSET + AES_ENC + EIGHTEEN_BIT_SEQ_NUM_OFFSET
7678                         + DOWNLINK;
7679         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
7680                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7681                         RTE_CRYPTO_AUTH_OP_GENERATE,
7682                         pdcp_test_data_in[i],
7683                         pdcp_test_data_in_len[i],
7684                         pdcp_test_data_out[i],
7685                         pdcp_test_data_in_len[i],
7686                         32, 40);
7687 }
7688 static int
7689 test_PDCP_PROTO_SGL_oop_128B_32B(void)
7690 {
7691         /* i can be used for running any PDCP case
7692          * In this case it is cplane 12-bit AES-ZUC DL encap
7693          */
7694         int i = PDCP_CPLANE_LONG_SN_OFFSET + AES_ENC + ZUC_AUTH + DOWNLINK;
7695         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
7696                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7697                         RTE_CRYPTO_AUTH_OP_GENERATE,
7698                         pdcp_test_data_in[i],
7699                         pdcp_test_data_in_len[i],
7700                         pdcp_test_data_out[i],
7701                         pdcp_test_data_in_len[i]+4,
7702                         128, 32);
7703 }
7704
7705 static int
7706 test_PDCP_PROTO_all(void)
7707 {
7708         struct crypto_testsuite_params *ts_params = &testsuite_params;
7709         struct rte_cryptodev_info dev_info;
7710         int status;
7711
7712         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
7713         uint64_t feat_flags = dev_info.feature_flags;
7714
7715         if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY))
7716                 return -ENOTSUP;
7717
7718         status = test_PDCP_PROTO_cplane_encap_all();
7719         status += test_PDCP_PROTO_cplane_decap_all();
7720         status += test_PDCP_PROTO_uplane_encap_all();
7721         status += test_PDCP_PROTO_uplane_decap_all();
7722         status += test_PDCP_PROTO_SGL_in_place_32B();
7723         status += test_PDCP_PROTO_SGL_oop_32B_128B();
7724         status += test_PDCP_PROTO_SGL_oop_32B_40B();
7725         status += test_PDCP_PROTO_SGL_oop_128B_32B();
7726
7727         if (status)
7728                 return TEST_FAILED;
7729         else
7730                 return TEST_SUCCESS;
7731 }
7732 #endif
7733
7734 static int
7735 test_AES_GCM_authenticated_encryption_test_case_1(void)
7736 {
7737         return test_authenticated_encryption(&gcm_test_case_1);
7738 }
7739
7740 static int
7741 test_AES_GCM_authenticated_encryption_test_case_2(void)
7742 {
7743         return test_authenticated_encryption(&gcm_test_case_2);
7744 }
7745
7746 static int
7747 test_AES_GCM_authenticated_encryption_test_case_3(void)
7748 {
7749         return test_authenticated_encryption(&gcm_test_case_3);
7750 }
7751
7752 static int
7753 test_AES_GCM_authenticated_encryption_test_case_4(void)
7754 {
7755         return test_authenticated_encryption(&gcm_test_case_4);
7756 }
7757
7758 static int
7759 test_AES_GCM_authenticated_encryption_test_case_5(void)
7760 {
7761         return test_authenticated_encryption(&gcm_test_case_5);
7762 }
7763
7764 static int
7765 test_AES_GCM_authenticated_encryption_test_case_6(void)
7766 {
7767         return test_authenticated_encryption(&gcm_test_case_6);
7768 }
7769
7770 static int
7771 test_AES_GCM_authenticated_encryption_test_case_7(void)
7772 {
7773         return test_authenticated_encryption(&gcm_test_case_7);
7774 }
7775
7776 static int
7777 test_AES_GCM_authenticated_encryption_test_case_8(void)
7778 {
7779         return test_authenticated_encryption(&gcm_test_case_8);
7780 }
7781
7782 static int
7783 test_AES_GCM_J0_authenticated_encryption_test_case_1(void)
7784 {
7785         return test_authenticated_encryption(&gcm_J0_test_case_1);
7786 }
7787
7788 static int
7789 test_AES_GCM_auth_encryption_test_case_192_1(void)
7790 {
7791         return test_authenticated_encryption(&gcm_test_case_192_1);
7792 }
7793
7794 static int
7795 test_AES_GCM_auth_encryption_test_case_192_2(void)
7796 {
7797         return test_authenticated_encryption(&gcm_test_case_192_2);
7798 }
7799
7800 static int
7801 test_AES_GCM_auth_encryption_test_case_192_3(void)
7802 {
7803         return test_authenticated_encryption(&gcm_test_case_192_3);
7804 }
7805
7806 static int
7807 test_AES_GCM_auth_encryption_test_case_192_4(void)
7808 {
7809         return test_authenticated_encryption(&gcm_test_case_192_4);
7810 }
7811
7812 static int
7813 test_AES_GCM_auth_encryption_test_case_192_5(void)
7814 {
7815         return test_authenticated_encryption(&gcm_test_case_192_5);
7816 }
7817
7818 static int
7819 test_AES_GCM_auth_encryption_test_case_192_6(void)
7820 {
7821         return test_authenticated_encryption(&gcm_test_case_192_6);
7822 }
7823
7824 static int
7825 test_AES_GCM_auth_encryption_test_case_192_7(void)
7826 {
7827         return test_authenticated_encryption(&gcm_test_case_192_7);
7828 }
7829
7830 static int
7831 test_AES_GCM_auth_encryption_test_case_256_1(void)
7832 {
7833         return test_authenticated_encryption(&gcm_test_case_256_1);
7834 }
7835
7836 static int
7837 test_AES_GCM_auth_encryption_test_case_256_2(void)
7838 {
7839         return test_authenticated_encryption(&gcm_test_case_256_2);
7840 }
7841
7842 static int
7843 test_AES_GCM_auth_encryption_test_case_256_3(void)
7844 {
7845         return test_authenticated_encryption(&gcm_test_case_256_3);
7846 }
7847
7848 static int
7849 test_AES_GCM_auth_encryption_test_case_256_4(void)
7850 {
7851         return test_authenticated_encryption(&gcm_test_case_256_4);
7852 }
7853
7854 static int
7855 test_AES_GCM_auth_encryption_test_case_256_5(void)
7856 {
7857         return test_authenticated_encryption(&gcm_test_case_256_5);
7858 }
7859
7860 static int
7861 test_AES_GCM_auth_encryption_test_case_256_6(void)
7862 {
7863         return test_authenticated_encryption(&gcm_test_case_256_6);
7864 }
7865
7866 static int
7867 test_AES_GCM_auth_encryption_test_case_256_7(void)
7868 {
7869         return test_authenticated_encryption(&gcm_test_case_256_7);
7870 }
7871
7872 static int
7873 test_AES_GCM_auth_encryption_test_case_aad_1(void)
7874 {
7875         return test_authenticated_encryption(&gcm_test_case_aad_1);
7876 }
7877
7878 static int
7879 test_AES_GCM_auth_encryption_test_case_aad_2(void)
7880 {
7881         return test_authenticated_encryption(&gcm_test_case_aad_2);
7882 }
7883
7884 static int
7885 test_AES_GCM_auth_encryption_fail_iv_corrupt(void)
7886 {
7887         struct aead_test_data tdata;
7888         int res;
7889
7890         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
7891         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
7892         tdata.iv.data[0] += 1;
7893         res = test_authenticated_encryption(&tdata);
7894         if (res == -ENOTSUP)
7895                 return res;
7896         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
7897         return TEST_SUCCESS;
7898 }
7899
7900 static int
7901 test_AES_GCM_auth_encryption_fail_in_data_corrupt(void)
7902 {
7903         struct aead_test_data tdata;
7904         int res;
7905
7906         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
7907         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
7908         tdata.plaintext.data[0] += 1;
7909         res = test_authenticated_encryption(&tdata);
7910         if (res == -ENOTSUP)
7911                 return res;
7912         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
7913         return TEST_SUCCESS;
7914 }
7915
7916 static int
7917 test_AES_GCM_auth_encryption_fail_out_data_corrupt(void)
7918 {
7919         struct aead_test_data tdata;
7920         int res;
7921
7922         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
7923         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
7924         tdata.ciphertext.data[0] += 1;
7925         res = test_authenticated_encryption(&tdata);
7926         if (res == -ENOTSUP)
7927                 return res;
7928         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
7929         return TEST_SUCCESS;
7930 }
7931
7932 static int
7933 test_AES_GCM_auth_encryption_fail_aad_len_corrupt(void)
7934 {
7935         struct aead_test_data tdata;
7936         int res;
7937
7938         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
7939         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
7940         tdata.aad.len += 1;
7941         res = test_authenticated_encryption(&tdata);
7942         if (res == -ENOTSUP)
7943                 return res;
7944         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
7945         return TEST_SUCCESS;
7946 }
7947
7948 static int
7949 test_AES_GCM_auth_encryption_fail_aad_corrupt(void)
7950 {
7951         struct aead_test_data tdata;
7952         uint8_t aad[gcm_test_case_7.aad.len];
7953         int res;
7954
7955         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
7956         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
7957         memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
7958         aad[0] += 1;
7959         tdata.aad.data = aad;
7960         res = test_authenticated_encryption(&tdata);
7961         if (res == -ENOTSUP)
7962                 return res;
7963         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
7964         return TEST_SUCCESS;
7965 }
7966
7967 static int
7968 test_AES_GCM_auth_encryption_fail_tag_corrupt(void)
7969 {
7970         struct aead_test_data tdata;
7971         int res;
7972
7973         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
7974         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
7975         tdata.auth_tag.data[0] += 1;
7976         res = test_authenticated_encryption(&tdata);
7977         if (res == -ENOTSUP)
7978                 return res;
7979         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
7980         return TEST_SUCCESS;
7981 }
7982
7983 static int
7984 test_authenticated_decryption(const struct aead_test_data *tdata)
7985 {
7986         struct crypto_testsuite_params *ts_params = &testsuite_params;
7987         struct crypto_unittest_params *ut_params = &unittest_params;
7988
7989         int retval;
7990         uint8_t *plaintext;
7991         uint32_t i;
7992
7993         /* Verify the capabilities */
7994         struct rte_cryptodev_sym_capability_idx cap_idx;
7995         const struct rte_cryptodev_symmetric_capability *capability;
7996         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
7997         cap_idx.algo.aead = tdata->algo;
7998         capability = rte_cryptodev_sym_capability_get(
7999                         ts_params->valid_devs[0], &cap_idx);
8000         if (capability == NULL)
8001                 return -ENOTSUP;
8002         if (rte_cryptodev_sym_capability_check_aead(
8003                         capability, tdata->key.len, tdata->auth_tag.len,
8004                         tdata->aad.len, tdata->iv.len))
8005                 return -ENOTSUP;
8006
8007         /* Create AEAD session */
8008         retval = create_aead_session(ts_params->valid_devs[0],
8009                         tdata->algo,
8010                         RTE_CRYPTO_AEAD_OP_DECRYPT,
8011                         tdata->key.data, tdata->key.len,
8012                         tdata->aad.len, tdata->auth_tag.len,
8013                         tdata->iv.len);
8014         if (retval < 0)
8015                 return retval;
8016
8017         /* alloc mbuf and set payload */
8018         if (tdata->aad.len > MBUF_SIZE) {
8019                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
8020                 /* Populate full size of add data */
8021                 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
8022                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
8023         } else
8024                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8025
8026         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8027                         rte_pktmbuf_tailroom(ut_params->ibuf));
8028
8029         /* Create AEAD operation */
8030         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
8031         if (retval < 0)
8032                 return retval;
8033
8034         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
8035
8036         ut_params->op->sym->m_src = ut_params->ibuf;
8037
8038         /* Process crypto operation */
8039         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
8040                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
8041         else
8042                 TEST_ASSERT_NOT_NULL(
8043                         process_crypto_request(ts_params->valid_devs[0],
8044                         ut_params->op), "failed to process sym crypto op");
8045
8046         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8047                         "crypto op processing failed");
8048
8049         if (ut_params->op->sym->m_dst)
8050                 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8051                                 uint8_t *);
8052         else
8053                 plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
8054                                 uint8_t *,
8055                                 ut_params->op->sym->cipher.data.offset);
8056
8057         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
8058
8059         /* Validate obuf */
8060         TEST_ASSERT_BUFFERS_ARE_EQUAL(
8061                         plaintext,
8062                         tdata->plaintext.data,
8063                         tdata->plaintext.len,
8064                         "Plaintext data not as expected");
8065
8066         TEST_ASSERT_EQUAL(ut_params->op->status,
8067                         RTE_CRYPTO_OP_STATUS_SUCCESS,
8068                         "Authentication failed");
8069
8070         return 0;
8071 }
8072
8073 static int
8074 test_AES_GCM_authenticated_decryption_test_case_1(void)
8075 {
8076         return test_authenticated_decryption(&gcm_test_case_1);
8077 }
8078
8079 static int
8080 test_AES_GCM_authenticated_decryption_test_case_2(void)
8081 {
8082         return test_authenticated_decryption(&gcm_test_case_2);
8083 }
8084
8085 static int
8086 test_AES_GCM_authenticated_decryption_test_case_3(void)
8087 {
8088         return test_authenticated_decryption(&gcm_test_case_3);
8089 }
8090
8091 static int
8092 test_AES_GCM_authenticated_decryption_test_case_4(void)
8093 {
8094         return test_authenticated_decryption(&gcm_test_case_4);
8095 }
8096
8097 static int
8098 test_AES_GCM_authenticated_decryption_test_case_5(void)
8099 {
8100         return test_authenticated_decryption(&gcm_test_case_5);
8101 }
8102
8103 static int
8104 test_AES_GCM_authenticated_decryption_test_case_6(void)
8105 {
8106         return test_authenticated_decryption(&gcm_test_case_6);
8107 }
8108
8109 static int
8110 test_AES_GCM_authenticated_decryption_test_case_7(void)
8111 {
8112         return test_authenticated_decryption(&gcm_test_case_7);
8113 }
8114
8115 static int
8116 test_AES_GCM_authenticated_decryption_test_case_8(void)
8117 {
8118         return test_authenticated_decryption(&gcm_test_case_8);
8119 }
8120
8121 static int
8122 test_AES_GCM_J0_authenticated_decryption_test_case_1(void)
8123 {
8124         return test_authenticated_decryption(&gcm_J0_test_case_1);
8125 }
8126
8127 static int
8128 test_AES_GCM_auth_decryption_test_case_192_1(void)
8129 {
8130         return test_authenticated_decryption(&gcm_test_case_192_1);
8131 }
8132
8133 static int
8134 test_AES_GCM_auth_decryption_test_case_192_2(void)
8135 {
8136         return test_authenticated_decryption(&gcm_test_case_192_2);
8137 }
8138
8139 static int
8140 test_AES_GCM_auth_decryption_test_case_192_3(void)
8141 {
8142         return test_authenticated_decryption(&gcm_test_case_192_3);
8143 }
8144
8145 static int
8146 test_AES_GCM_auth_decryption_test_case_192_4(void)
8147 {
8148         return test_authenticated_decryption(&gcm_test_case_192_4);
8149 }
8150
8151 static int
8152 test_AES_GCM_auth_decryption_test_case_192_5(void)
8153 {
8154         return test_authenticated_decryption(&gcm_test_case_192_5);
8155 }
8156
8157 static int
8158 test_AES_GCM_auth_decryption_test_case_192_6(void)
8159 {
8160         return test_authenticated_decryption(&gcm_test_case_192_6);
8161 }
8162
8163 static int
8164 test_AES_GCM_auth_decryption_test_case_192_7(void)
8165 {
8166         return test_authenticated_decryption(&gcm_test_case_192_7);
8167 }
8168
8169 static int
8170 test_AES_GCM_auth_decryption_test_case_256_1(void)
8171 {
8172         return test_authenticated_decryption(&gcm_test_case_256_1);
8173 }
8174
8175 static int
8176 test_AES_GCM_auth_decryption_test_case_256_2(void)
8177 {
8178         return test_authenticated_decryption(&gcm_test_case_256_2);
8179 }
8180
8181 static int
8182 test_AES_GCM_auth_decryption_test_case_256_3(void)
8183 {
8184         return test_authenticated_decryption(&gcm_test_case_256_3);
8185 }
8186
8187 static int
8188 test_AES_GCM_auth_decryption_test_case_256_4(void)
8189 {
8190         return test_authenticated_decryption(&gcm_test_case_256_4);
8191 }
8192
8193 static int
8194 test_AES_GCM_auth_decryption_test_case_256_5(void)
8195 {
8196         return test_authenticated_decryption(&gcm_test_case_256_5);
8197 }
8198
8199 static int
8200 test_AES_GCM_auth_decryption_test_case_256_6(void)
8201 {
8202         return test_authenticated_decryption(&gcm_test_case_256_6);
8203 }
8204
8205 static int
8206 test_AES_GCM_auth_decryption_test_case_256_7(void)
8207 {
8208         return test_authenticated_decryption(&gcm_test_case_256_7);
8209 }
8210
8211 static int
8212 test_AES_GCM_auth_decryption_test_case_aad_1(void)
8213 {
8214         return test_authenticated_decryption(&gcm_test_case_aad_1);
8215 }
8216
8217 static int
8218 test_AES_GCM_auth_decryption_test_case_aad_2(void)
8219 {
8220         return test_authenticated_decryption(&gcm_test_case_aad_2);
8221 }
8222
8223 static int
8224 test_AES_GCM_auth_decryption_fail_iv_corrupt(void)
8225 {
8226         struct aead_test_data tdata;
8227         int res;
8228
8229         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
8230         tdata.iv.data[0] += 1;
8231         res = test_authenticated_decryption(&tdata);
8232         if (res == -ENOTSUP)
8233                 return res;
8234         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
8235         return TEST_SUCCESS;
8236 }
8237
8238 static int
8239 test_AES_GCM_auth_decryption_fail_in_data_corrupt(void)
8240 {
8241         struct aead_test_data tdata;
8242         int res;
8243
8244         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
8245         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
8246         tdata.plaintext.data[0] += 1;
8247         res = test_authenticated_decryption(&tdata);
8248         if (res == -ENOTSUP)
8249                 return res;
8250         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
8251         return TEST_SUCCESS;
8252 }
8253
8254 static int
8255 test_AES_GCM_auth_decryption_fail_out_data_corrupt(void)
8256 {
8257         struct aead_test_data tdata;
8258         int res;
8259
8260         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
8261         tdata.ciphertext.data[0] += 1;
8262         res = test_authenticated_decryption(&tdata);
8263         if (res == -ENOTSUP)
8264                 return res;
8265         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
8266         return TEST_SUCCESS;
8267 }
8268
8269 static int
8270 test_AES_GCM_auth_decryption_fail_aad_len_corrupt(void)
8271 {
8272         struct aead_test_data tdata;
8273         int res;
8274
8275         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
8276         tdata.aad.len += 1;
8277         res = test_authenticated_decryption(&tdata);
8278         if (res == -ENOTSUP)
8279                 return res;
8280         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
8281         return TEST_SUCCESS;
8282 }
8283
8284 static int
8285 test_AES_GCM_auth_decryption_fail_aad_corrupt(void)
8286 {
8287         struct aead_test_data tdata;
8288         uint8_t aad[gcm_test_case_7.aad.len];
8289         int res;
8290
8291         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
8292         memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
8293         aad[0] += 1;
8294         tdata.aad.data = aad;
8295         res = test_authenticated_decryption(&tdata);
8296         if (res == -ENOTSUP)
8297                 return res;
8298         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
8299         return TEST_SUCCESS;
8300 }
8301
8302 static int
8303 test_AES_GCM_auth_decryption_fail_tag_corrupt(void)
8304 {
8305         struct aead_test_data tdata;
8306         int res;
8307
8308         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
8309         tdata.auth_tag.data[0] += 1;
8310         res = test_authenticated_decryption(&tdata);
8311         if (res == -ENOTSUP)
8312                 return res;
8313         TEST_ASSERT_EQUAL(res, TEST_FAILED, "authentication not failed");
8314         return TEST_SUCCESS;
8315 }
8316
8317 static int
8318 test_authenticated_encryption_oop(const struct aead_test_data *tdata)
8319 {
8320         struct crypto_testsuite_params *ts_params = &testsuite_params;
8321         struct crypto_unittest_params *ut_params = &unittest_params;
8322
8323         int retval;
8324         uint8_t *ciphertext, *auth_tag;
8325         uint16_t plaintext_pad_len;
8326
8327         /* Verify the capabilities */
8328         struct rte_cryptodev_sym_capability_idx cap_idx;
8329         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
8330         cap_idx.algo.aead = tdata->algo;
8331         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
8332                         &cap_idx) == NULL)
8333                 return -ENOTSUP;
8334
8335         /* not supported with CPU crypto */
8336         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
8337                 return -ENOTSUP;
8338
8339         /* Create AEAD session */
8340         retval = create_aead_session(ts_params->valid_devs[0],
8341                         tdata->algo,
8342                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
8343                         tdata->key.data, tdata->key.len,
8344                         tdata->aad.len, tdata->auth_tag.len,
8345                         tdata->iv.len);
8346         if (retval < 0)
8347                 return retval;
8348
8349         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8350         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8351
8352         /* clear mbuf payload */
8353         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8354                         rte_pktmbuf_tailroom(ut_params->ibuf));
8355         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
8356                         rte_pktmbuf_tailroom(ut_params->obuf));
8357
8358         /* Create AEAD operation */
8359         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
8360         if (retval < 0)
8361                 return retval;
8362
8363         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
8364
8365         ut_params->op->sym->m_src = ut_params->ibuf;
8366         ut_params->op->sym->m_dst = ut_params->obuf;
8367
8368         /* Process crypto operation */
8369         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
8370                         ut_params->op), "failed to process sym crypto op");
8371
8372         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8373                         "crypto op processing failed");
8374
8375         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
8376
8377         ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
8378                         ut_params->op->sym->cipher.data.offset);
8379         auth_tag = ciphertext + plaintext_pad_len;
8380
8381         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
8382         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
8383
8384         /* Validate obuf */
8385         TEST_ASSERT_BUFFERS_ARE_EQUAL(
8386                         ciphertext,
8387                         tdata->ciphertext.data,
8388                         tdata->ciphertext.len,
8389                         "Ciphertext data not as expected");
8390
8391         TEST_ASSERT_BUFFERS_ARE_EQUAL(
8392                         auth_tag,
8393                         tdata->auth_tag.data,
8394                         tdata->auth_tag.len,
8395                         "Generated auth tag not as expected");
8396
8397         return 0;
8398
8399 }
8400
8401 static int
8402 test_AES_GCM_authenticated_encryption_oop_test_case_1(void)
8403 {
8404         return test_authenticated_encryption_oop(&gcm_test_case_5);
8405 }
8406
8407 static int
8408 test_authenticated_decryption_oop(const struct aead_test_data *tdata)
8409 {
8410         struct crypto_testsuite_params *ts_params = &testsuite_params;
8411         struct crypto_unittest_params *ut_params = &unittest_params;
8412
8413         int retval;
8414         uint8_t *plaintext;
8415
8416         /* Verify the capabilities */
8417         struct rte_cryptodev_sym_capability_idx cap_idx;
8418         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
8419         cap_idx.algo.aead = tdata->algo;
8420         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
8421                         &cap_idx) == NULL)
8422                 return -ENOTSUP;
8423
8424         /* not supported with CPU crypto */
8425         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
8426                 return -ENOTSUP;
8427
8428         /* Create AEAD session */
8429         retval = create_aead_session(ts_params->valid_devs[0],
8430                         tdata->algo,
8431                         RTE_CRYPTO_AEAD_OP_DECRYPT,
8432                         tdata->key.data, tdata->key.len,
8433                         tdata->aad.len, tdata->auth_tag.len,
8434                         tdata->iv.len);
8435         if (retval < 0)
8436                 return retval;
8437
8438         /* alloc mbuf and set payload */
8439         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8440         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8441
8442         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8443                         rte_pktmbuf_tailroom(ut_params->ibuf));
8444         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
8445                         rte_pktmbuf_tailroom(ut_params->obuf));
8446
8447         /* Create AEAD operation */
8448         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
8449         if (retval < 0)
8450                 return retval;
8451
8452         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
8453
8454         ut_params->op->sym->m_src = ut_params->ibuf;
8455         ut_params->op->sym->m_dst = ut_params->obuf;
8456
8457         /* Process crypto operation */
8458         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
8459                         ut_params->op), "failed to process sym crypto op");
8460
8461         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8462                         "crypto op processing failed");
8463
8464         plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
8465                         ut_params->op->sym->cipher.data.offset);
8466
8467         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
8468
8469         /* Validate obuf */
8470         TEST_ASSERT_BUFFERS_ARE_EQUAL(
8471                         plaintext,
8472                         tdata->plaintext.data,
8473                         tdata->plaintext.len,
8474                         "Plaintext data not as expected");
8475
8476         TEST_ASSERT_EQUAL(ut_params->op->status,
8477                         RTE_CRYPTO_OP_STATUS_SUCCESS,
8478                         "Authentication failed");
8479         return 0;
8480 }
8481
8482 static int
8483 test_AES_GCM_authenticated_decryption_oop_test_case_1(void)
8484 {
8485         return test_authenticated_decryption_oop(&gcm_test_case_5);
8486 }
8487
8488 static int
8489 test_authenticated_encryption_sessionless(
8490                 const struct aead_test_data *tdata)
8491 {
8492         struct crypto_testsuite_params *ts_params = &testsuite_params;
8493         struct crypto_unittest_params *ut_params = &unittest_params;
8494
8495         int retval;
8496         uint8_t *ciphertext, *auth_tag;
8497         uint16_t plaintext_pad_len;
8498         uint8_t key[tdata->key.len + 1];
8499         struct rte_cryptodev_info dev_info;
8500
8501         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8502         uint64_t feat_flags = dev_info.feature_flags;
8503
8504         if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
8505                 printf("Device doesn't support Sessionless ops.\n");
8506                 return -ENOTSUP;
8507         }
8508
8509         /* not supported with CPU crypto */
8510         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
8511                 return -ENOTSUP;
8512
8513         /* Verify the capabilities */
8514         struct rte_cryptodev_sym_capability_idx cap_idx;
8515         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
8516         cap_idx.algo.aead = tdata->algo;
8517         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
8518                         &cap_idx) == NULL)
8519                 return -ENOTSUP;
8520
8521         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8522
8523         /* clear mbuf payload */
8524         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8525                         rte_pktmbuf_tailroom(ut_params->ibuf));
8526
8527         /* Create AEAD operation */
8528         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
8529         if (retval < 0)
8530                 return retval;
8531
8532         /* Create GCM xform */
8533         memcpy(key, tdata->key.data, tdata->key.len);
8534         retval = create_aead_xform(ut_params->op,
8535                         tdata->algo,
8536                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
8537                         key, tdata->key.len,
8538                         tdata->aad.len, tdata->auth_tag.len,
8539                         tdata->iv.len);
8540         if (retval < 0)
8541                 return retval;
8542
8543         ut_params->op->sym->m_src = ut_params->ibuf;
8544
8545         TEST_ASSERT_EQUAL(ut_params->op->sess_type,
8546                         RTE_CRYPTO_OP_SESSIONLESS,
8547                         "crypto op session type not sessionless");
8548
8549         /* Process crypto operation */
8550         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
8551                         ut_params->op), "failed to process sym crypto op");
8552
8553         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
8554
8555         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8556                         "crypto op status not success");
8557
8558         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
8559
8560         ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
8561                         ut_params->op->sym->cipher.data.offset);
8562         auth_tag = ciphertext + plaintext_pad_len;
8563
8564         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
8565         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
8566
8567         /* Validate obuf */
8568         TEST_ASSERT_BUFFERS_ARE_EQUAL(
8569                         ciphertext,
8570                         tdata->ciphertext.data,
8571                         tdata->ciphertext.len,
8572                         "Ciphertext data not as expected");
8573
8574         TEST_ASSERT_BUFFERS_ARE_EQUAL(
8575                         auth_tag,
8576                         tdata->auth_tag.data,
8577                         tdata->auth_tag.len,
8578                         "Generated auth tag not as expected");
8579
8580         return 0;
8581
8582 }
8583
8584 static int
8585 test_AES_GCM_authenticated_encryption_sessionless_test_case_1(void)
8586 {
8587         return test_authenticated_encryption_sessionless(
8588                         &gcm_test_case_5);
8589 }
8590
8591 static int
8592 test_authenticated_decryption_sessionless(
8593                 const struct aead_test_data *tdata)
8594 {
8595         struct crypto_testsuite_params *ts_params = &testsuite_params;
8596         struct crypto_unittest_params *ut_params = &unittest_params;
8597
8598         int retval;
8599         uint8_t *plaintext;
8600         uint8_t key[tdata->key.len + 1];
8601         struct rte_cryptodev_info dev_info;
8602
8603         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8604         uint64_t feat_flags = dev_info.feature_flags;
8605
8606         if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
8607                 printf("Device doesn't support Sessionless ops.\n");
8608                 return -ENOTSUP;
8609         }
8610
8611         /* not supported with CPU crypto */
8612         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
8613                 return -ENOTSUP;
8614
8615         /* Verify the capabilities */
8616         struct rte_cryptodev_sym_capability_idx cap_idx;
8617         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
8618         cap_idx.algo.aead = tdata->algo;
8619         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
8620                         &cap_idx) == NULL)
8621                 return -ENOTSUP;
8622
8623         /* alloc mbuf and set payload */
8624         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8625
8626         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8627                         rte_pktmbuf_tailroom(ut_params->ibuf));
8628
8629         /* Create AEAD operation */
8630         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
8631         if (retval < 0)
8632                 return retval;
8633
8634         /* Create AEAD xform */
8635         memcpy(key, tdata->key.data, tdata->key.len);
8636         retval = create_aead_xform(ut_params->op,
8637                         tdata->algo,
8638                         RTE_CRYPTO_AEAD_OP_DECRYPT,
8639                         key, tdata->key.len,
8640                         tdata->aad.len, tdata->auth_tag.len,
8641                         tdata->iv.len);
8642         if (retval < 0)
8643                 return retval;
8644
8645         ut_params->op->sym->m_src = ut_params->ibuf;
8646
8647         TEST_ASSERT_EQUAL(ut_params->op->sess_type,
8648                         RTE_CRYPTO_OP_SESSIONLESS,
8649                         "crypto op session type not sessionless");
8650
8651         /* Process crypto operation */
8652         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
8653                         ut_params->op), "failed to process sym crypto op");
8654
8655         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
8656
8657         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8658                         "crypto op status not success");
8659
8660         plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
8661                         ut_params->op->sym->cipher.data.offset);
8662
8663         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
8664
8665         /* Validate obuf */
8666         TEST_ASSERT_BUFFERS_ARE_EQUAL(
8667                         plaintext,
8668                         tdata->plaintext.data,
8669                         tdata->plaintext.len,
8670                         "Plaintext data not as expected");
8671
8672         TEST_ASSERT_EQUAL(ut_params->op->status,
8673                         RTE_CRYPTO_OP_STATUS_SUCCESS,
8674                         "Authentication failed");
8675         return 0;
8676 }
8677
8678 static int
8679 test_AES_GCM_authenticated_decryption_sessionless_test_case_1(void)
8680 {
8681         return test_authenticated_decryption_sessionless(
8682                         &gcm_test_case_5);
8683 }
8684
8685 static int
8686 test_AES_CCM_authenticated_encryption_test_case_128_1(void)
8687 {
8688         return test_authenticated_encryption(&ccm_test_case_128_1);
8689 }
8690
8691 static int
8692 test_AES_CCM_authenticated_encryption_test_case_128_2(void)
8693 {
8694         return test_authenticated_encryption(&ccm_test_case_128_2);
8695 }
8696
8697 static int
8698 test_AES_CCM_authenticated_encryption_test_case_128_3(void)
8699 {
8700         return test_authenticated_encryption(&ccm_test_case_128_3);
8701 }
8702
8703 static int
8704 test_AES_CCM_authenticated_decryption_test_case_128_1(void)
8705 {
8706         return test_authenticated_decryption(&ccm_test_case_128_1);
8707 }
8708
8709 static int
8710 test_AES_CCM_authenticated_decryption_test_case_128_2(void)
8711 {
8712         return test_authenticated_decryption(&ccm_test_case_128_2);
8713 }
8714
8715 static int
8716 test_AES_CCM_authenticated_decryption_test_case_128_3(void)
8717 {
8718         return test_authenticated_decryption(&ccm_test_case_128_3);
8719 }
8720
8721 static int
8722 test_AES_CCM_authenticated_encryption_test_case_192_1(void)
8723 {
8724         return test_authenticated_encryption(&ccm_test_case_192_1);
8725 }
8726
8727 static int
8728 test_AES_CCM_authenticated_encryption_test_case_192_2(void)
8729 {
8730         return test_authenticated_encryption(&ccm_test_case_192_2);
8731 }
8732
8733 static int
8734 test_AES_CCM_authenticated_encryption_test_case_192_3(void)
8735 {
8736         return test_authenticated_encryption(&ccm_test_case_192_3);
8737 }
8738
8739 static int
8740 test_AES_CCM_authenticated_decryption_test_case_192_1(void)
8741 {
8742         return test_authenticated_decryption(&ccm_test_case_192_1);
8743 }
8744
8745 static int
8746 test_AES_CCM_authenticated_decryption_test_case_192_2(void)
8747 {
8748         return test_authenticated_decryption(&ccm_test_case_192_2);
8749 }
8750
8751 static int
8752 test_AES_CCM_authenticated_decryption_test_case_192_3(void)
8753 {
8754         return test_authenticated_decryption(&ccm_test_case_192_3);
8755 }
8756
8757 static int
8758 test_AES_CCM_authenticated_encryption_test_case_256_1(void)
8759 {
8760         return test_authenticated_encryption(&ccm_test_case_256_1);
8761 }
8762
8763 static int
8764 test_AES_CCM_authenticated_encryption_test_case_256_2(void)
8765 {
8766         return test_authenticated_encryption(&ccm_test_case_256_2);
8767 }
8768
8769 static int
8770 test_AES_CCM_authenticated_encryption_test_case_256_3(void)
8771 {
8772         return test_authenticated_encryption(&ccm_test_case_256_3);
8773 }
8774
8775 static int
8776 test_AES_CCM_authenticated_decryption_test_case_256_1(void)
8777 {
8778         return test_authenticated_decryption(&ccm_test_case_256_1);
8779 }
8780
8781 static int
8782 test_AES_CCM_authenticated_decryption_test_case_256_2(void)
8783 {
8784         return test_authenticated_decryption(&ccm_test_case_256_2);
8785 }
8786
8787 static int
8788 test_AES_CCM_authenticated_decryption_test_case_256_3(void)
8789 {
8790         return test_authenticated_decryption(&ccm_test_case_256_3);
8791 }
8792
8793 static int
8794 test_stats(void)
8795 {
8796         struct crypto_testsuite_params *ts_params = &testsuite_params;
8797         struct rte_cryptodev_stats stats;
8798         struct rte_cryptodev *dev;
8799         cryptodev_stats_get_t temp_pfn;
8800
8801         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
8802                 return -ENOTSUP;
8803
8804         /* Verify the capabilities */
8805         struct rte_cryptodev_sym_capability_idx cap_idx;
8806         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8807         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
8808         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
8809                         &cap_idx) == NULL)
8810                 return -ENOTSUP;
8811         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8812         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
8813         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
8814                         &cap_idx) == NULL)
8815                 return -ENOTSUP;
8816
8817         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
8818         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
8819                         &stats) == -ENODEV),
8820                 "rte_cryptodev_stats_get invalid dev failed");
8821         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
8822                 "rte_cryptodev_stats_get invalid Param failed");
8823         dev = &rte_cryptodevs[ts_params->valid_devs[0]];
8824         temp_pfn = dev->dev_ops->stats_get;
8825         dev->dev_ops->stats_get = (cryptodev_stats_get_t)0;
8826         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
8827                         == -ENOTSUP),
8828                 "rte_cryptodev_stats_get invalid Param failed");
8829         dev->dev_ops->stats_get = temp_pfn;
8830
8831         /* Test expected values */
8832         ut_setup();
8833         test_AES_CBC_HMAC_SHA1_encrypt_digest();
8834         ut_teardown();
8835         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
8836                         &stats),
8837                 "rte_cryptodev_stats_get failed");
8838         TEST_ASSERT((stats.enqueued_count == 1),
8839                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
8840         TEST_ASSERT((stats.dequeued_count == 1),
8841                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
8842         TEST_ASSERT((stats.enqueue_err_count == 0),
8843                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
8844         TEST_ASSERT((stats.dequeue_err_count == 0),
8845                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
8846
8847         /* invalid device but should ignore and not reset device stats*/
8848         rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
8849         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
8850                         &stats),
8851                 "rte_cryptodev_stats_get failed");
8852         TEST_ASSERT((stats.enqueued_count == 1),
8853                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
8854
8855         /* check that a valid reset clears stats */
8856         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
8857         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
8858                         &stats),
8859                                           "rte_cryptodev_stats_get failed");
8860         TEST_ASSERT((stats.enqueued_count == 0),
8861                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
8862         TEST_ASSERT((stats.dequeued_count == 0),
8863                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
8864
8865         return TEST_SUCCESS;
8866 }
8867
8868 static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
8869                                    struct crypto_unittest_params *ut_params,
8870                                    enum rte_crypto_auth_operation op,
8871                                    const struct HMAC_MD5_vector *test_case)
8872 {
8873         uint8_t key[64];
8874
8875         memcpy(key, test_case->key.data, test_case->key.len);
8876
8877         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8878         ut_params->auth_xform.next = NULL;
8879         ut_params->auth_xform.auth.op = op;
8880
8881         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC;
8882
8883         ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN;
8884         ut_params->auth_xform.auth.key.length = test_case->key.len;
8885         ut_params->auth_xform.auth.key.data = key;
8886
8887         ut_params->sess = rte_cryptodev_sym_session_create(
8888                         ts_params->session_mpool);
8889
8890         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
8891                         ut_params->sess, &ut_params->auth_xform,
8892                         ts_params->session_priv_mpool);
8893
8894         if (ut_params->sess == NULL)
8895                 return TEST_FAILED;
8896
8897         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8898
8899         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8900                         rte_pktmbuf_tailroom(ut_params->ibuf));
8901
8902         return 0;
8903 }
8904
8905 static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
8906                               const struct HMAC_MD5_vector *test_case,
8907                               uint8_t **plaintext)
8908 {
8909         uint16_t plaintext_pad_len;
8910
8911         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
8912
8913         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
8914                                 16);
8915
8916         *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8917                         plaintext_pad_len);
8918         memcpy(*plaintext, test_case->plaintext.data,
8919                         test_case->plaintext.len);
8920
8921         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
8922                         ut_params->ibuf, MD5_DIGEST_LEN);
8923         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
8924                         "no room to append digest");
8925         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
8926                         ut_params->ibuf, plaintext_pad_len);
8927
8928         if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
8929                 rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data,
8930                            test_case->auth_tag.len);
8931         }
8932
8933         sym_op->auth.data.offset = 0;
8934         sym_op->auth.data.length = test_case->plaintext.len;
8935
8936         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
8937         ut_params->op->sym->m_src = ut_params->ibuf;
8938
8939         return 0;
8940 }
8941
8942 static int
8943 test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
8944 {
8945         uint16_t plaintext_pad_len;
8946         uint8_t *plaintext, *auth_tag;
8947
8948         struct crypto_testsuite_params *ts_params = &testsuite_params;
8949         struct crypto_unittest_params *ut_params = &unittest_params;
8950
8951         /* Verify the capabilities */
8952         struct rte_cryptodev_sym_capability_idx cap_idx;
8953         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8954         cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
8955         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
8956                         &cap_idx) == NULL)
8957                 return -ENOTSUP;
8958
8959         if (MD5_HMAC_create_session(ts_params, ut_params,
8960                         RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
8961                 return TEST_FAILED;
8962
8963         /* Generate Crypto op data structure */
8964         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8965                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8966         TEST_ASSERT_NOT_NULL(ut_params->op,
8967                         "Failed to allocate symmetric crypto operation struct");
8968
8969         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
8970                                 16);
8971
8972         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
8973                 return TEST_FAILED;
8974
8975         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
8976                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
8977                         ut_params->op);
8978         else
8979                 TEST_ASSERT_NOT_NULL(
8980                         process_crypto_request(ts_params->valid_devs[0],
8981                                 ut_params->op),
8982                                 "failed to process sym crypto op");
8983
8984         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8985                         "crypto op processing failed");
8986
8987         if (ut_params->op->sym->m_dst) {
8988                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
8989                                 uint8_t *, plaintext_pad_len);
8990         } else {
8991                 auth_tag = plaintext + plaintext_pad_len;
8992         }
8993
8994         TEST_ASSERT_BUFFERS_ARE_EQUAL(
8995                         auth_tag,
8996                         test_case->auth_tag.data,
8997                         test_case->auth_tag.len,
8998                         "HMAC_MD5 generated tag not as expected");
8999
9000         return TEST_SUCCESS;
9001 }
9002
9003 static int
9004 test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
9005 {
9006         uint8_t *plaintext;
9007
9008         struct crypto_testsuite_params *ts_params = &testsuite_params;
9009         struct crypto_unittest_params *ut_params = &unittest_params;
9010
9011         /* Verify the capabilities */
9012         struct rte_cryptodev_sym_capability_idx cap_idx;
9013         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
9014         cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
9015         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9016                         &cap_idx) == NULL)
9017                 return -ENOTSUP;
9018
9019         if (MD5_HMAC_create_session(ts_params, ut_params,
9020                         RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
9021                 return TEST_FAILED;
9022         }
9023
9024         /* Generate Crypto op data structure */
9025         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9026                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9027         TEST_ASSERT_NOT_NULL(ut_params->op,
9028                         "Failed to allocate symmetric crypto operation struct");
9029
9030         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
9031                 return TEST_FAILED;
9032
9033         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
9034                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
9035                         ut_params->op);
9036         else
9037                 TEST_ASSERT_NOT_NULL(
9038                         process_crypto_request(ts_params->valid_devs[0],
9039                                 ut_params->op),
9040                                 "failed to process sym crypto op");
9041
9042         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9043                         "HMAC_MD5 crypto op processing failed");
9044
9045         return TEST_SUCCESS;
9046 }
9047
9048 static int
9049 test_MD5_HMAC_generate_case_1(void)
9050 {
9051         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1);
9052 }
9053
9054 static int
9055 test_MD5_HMAC_verify_case_1(void)
9056 {
9057         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1);
9058 }
9059
9060 static int
9061 test_MD5_HMAC_generate_case_2(void)
9062 {
9063         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2);
9064 }
9065
9066 static int
9067 test_MD5_HMAC_verify_case_2(void)
9068 {
9069         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2);
9070 }
9071
9072 static int
9073 test_multi_session(void)
9074 {
9075         struct crypto_testsuite_params *ts_params = &testsuite_params;
9076         struct crypto_unittest_params *ut_params = &unittest_params;
9077
9078         struct rte_cryptodev_info dev_info;
9079         struct rte_cryptodev_sym_session **sessions;
9080
9081         uint16_t i;
9082
9083         /* Verify the capabilities */
9084         struct rte_cryptodev_sym_capability_idx cap_idx;
9085         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
9086         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
9087         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9088                         &cap_idx) == NULL)
9089                 return -ENOTSUP;
9090         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
9091         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
9092         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9093                         &cap_idx) == NULL)
9094                 return -ENOTSUP;
9095
9096         test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
9097                         aes_cbc_key, hmac_sha512_key);
9098
9099
9100         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
9101
9102         sessions = rte_malloc(NULL,
9103                         (sizeof(struct rte_cryptodev_sym_session *) *
9104                         MAX_NB_SESSIONS) + 1, 0);
9105
9106         /* Create multiple crypto sessions*/
9107         for (i = 0; i < MAX_NB_SESSIONS; i++) {
9108
9109                 sessions[i] = rte_cryptodev_sym_session_create(
9110                                 ts_params->session_mpool);
9111
9112                 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
9113                                 sessions[i], &ut_params->auth_xform,
9114                                 ts_params->session_priv_mpool);
9115                 TEST_ASSERT_NOT_NULL(sessions[i],
9116                                 "Session creation failed at session number %u",
9117                                 i);
9118
9119                 /* Attempt to send a request on each session */
9120                 TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform(
9121                         sessions[i],
9122                         ut_params,
9123                         ts_params,
9124                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
9125                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
9126                         aes_cbc_iv),
9127                         "Failed to perform decrypt on request number %u.", i);
9128                 /* free crypto operation structure */
9129                 if (ut_params->op)
9130                         rte_crypto_op_free(ut_params->op);
9131
9132                 /*
9133                  * free mbuf - both obuf and ibuf are usually the same,
9134                  * so check if they point at the same address is necessary,
9135                  * to avoid freeing the mbuf twice.
9136                  */
9137                 if (ut_params->obuf) {
9138                         rte_pktmbuf_free(ut_params->obuf);
9139                         if (ut_params->ibuf == ut_params->obuf)
9140                                 ut_params->ibuf = 0;
9141                         ut_params->obuf = 0;
9142                 }
9143                 if (ut_params->ibuf) {
9144                         rte_pktmbuf_free(ut_params->ibuf);
9145                         ut_params->ibuf = 0;
9146                 }
9147         }
9148
9149         /* Next session create should fail */
9150         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
9151                         sessions[i], &ut_params->auth_xform,
9152                         ts_params->session_priv_mpool);
9153         TEST_ASSERT_NULL(sessions[i],
9154                         "Session creation succeeded unexpectedly!");
9155
9156         for (i = 0; i < MAX_NB_SESSIONS; i++) {
9157                 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
9158                                 sessions[i]);
9159                 rte_cryptodev_sym_session_free(sessions[i]);
9160         }
9161
9162         rte_free(sessions);
9163
9164         return TEST_SUCCESS;
9165 }
9166
9167 struct multi_session_params {
9168         struct crypto_unittest_params ut_params;
9169         uint8_t *cipher_key;
9170         uint8_t *hmac_key;
9171         const uint8_t *cipher;
9172         const uint8_t *digest;
9173         uint8_t *iv;
9174 };
9175
9176 #define MB_SESSION_NUMBER 3
9177
9178 static int
9179 test_multi_session_random_usage(void)
9180 {
9181         struct crypto_testsuite_params *ts_params = &testsuite_params;
9182         struct rte_cryptodev_info dev_info;
9183         struct rte_cryptodev_sym_session **sessions;
9184         uint32_t i, j;
9185         struct multi_session_params ut_paramz[] = {
9186
9187                 {
9188                         .cipher_key = ms_aes_cbc_key0,
9189                         .hmac_key = ms_hmac_key0,
9190                         .cipher = ms_aes_cbc_cipher0,
9191                         .digest = ms_hmac_digest0,
9192                         .iv = ms_aes_cbc_iv0
9193                 },
9194                 {
9195                         .cipher_key = ms_aes_cbc_key1,
9196                         .hmac_key = ms_hmac_key1,
9197                         .cipher = ms_aes_cbc_cipher1,
9198                         .digest = ms_hmac_digest1,
9199                         .iv = ms_aes_cbc_iv1
9200                 },
9201                 {
9202                         .cipher_key = ms_aes_cbc_key2,
9203                         .hmac_key = ms_hmac_key2,
9204                         .cipher = ms_aes_cbc_cipher2,
9205                         .digest = ms_hmac_digest2,
9206                         .iv = ms_aes_cbc_iv2
9207                 },
9208
9209         };
9210
9211         /* Verify the capabilities */
9212         struct rte_cryptodev_sym_capability_idx cap_idx;
9213         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
9214         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
9215         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9216                         &cap_idx) == NULL)
9217                 return -ENOTSUP;
9218         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
9219         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
9220         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9221                         &cap_idx) == NULL)
9222                 return -ENOTSUP;
9223
9224         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
9225
9226         sessions = rte_malloc(NULL,
9227                         (sizeof(struct rte_cryptodev_sym_session *)
9228                                         * MAX_NB_SESSIONS) + 1, 0);
9229
9230         for (i = 0; i < MB_SESSION_NUMBER; i++) {
9231                 sessions[i] = rte_cryptodev_sym_session_create(
9232                                 ts_params->session_mpool);
9233
9234                 rte_memcpy(&ut_paramz[i].ut_params, &unittest_params,
9235                                 sizeof(struct crypto_unittest_params));
9236
9237                 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
9238                                 &ut_paramz[i].ut_params,
9239                                 ut_paramz[i].cipher_key, ut_paramz[i].hmac_key);
9240
9241                 /* Create multiple crypto sessions*/
9242                 rte_cryptodev_sym_session_init(
9243                                 ts_params->valid_devs[0],
9244                                 sessions[i],
9245                                 &ut_paramz[i].ut_params.auth_xform,
9246                                 ts_params->session_priv_mpool);
9247
9248                 TEST_ASSERT_NOT_NULL(sessions[i],
9249                                 "Session creation failed at session number %u",
9250                                 i);
9251
9252         }
9253
9254         srand(time(NULL));
9255         for (i = 0; i < 40000; i++) {
9256
9257                 j = rand() % MB_SESSION_NUMBER;
9258
9259                 TEST_ASSERT_SUCCESS(
9260                         test_AES_CBC_HMAC_SHA512_decrypt_perform(
9261                                         sessions[j],
9262                                         &ut_paramz[j].ut_params,
9263                                         ts_params, ut_paramz[j].cipher,
9264                                         ut_paramz[j].digest,
9265                                         ut_paramz[j].iv),
9266                         "Failed to perform decrypt on request number %u.", i);
9267
9268                 if (ut_paramz[j].ut_params.op)
9269                         rte_crypto_op_free(ut_paramz[j].ut_params.op);
9270
9271                 /*
9272                  * free mbuf - both obuf and ibuf are usually the same,
9273                  * so check if they point at the same address is necessary,
9274                  * to avoid freeing the mbuf twice.
9275                  */
9276                 if (ut_paramz[j].ut_params.obuf) {
9277                         rte_pktmbuf_free(ut_paramz[j].ut_params.obuf);
9278                         if (ut_paramz[j].ut_params.ibuf
9279                                         == ut_paramz[j].ut_params.obuf)
9280                                 ut_paramz[j].ut_params.ibuf = 0;
9281                         ut_paramz[j].ut_params.obuf = 0;
9282                 }
9283                 if (ut_paramz[j].ut_params.ibuf) {
9284                         rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf);
9285                         ut_paramz[j].ut_params.ibuf = 0;
9286                 }
9287         }
9288
9289         for (i = 0; i < MB_SESSION_NUMBER; i++) {
9290                 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
9291                                 sessions[i]);
9292                 rte_cryptodev_sym_session_free(sessions[i]);
9293         }
9294
9295         rte_free(sessions);
9296
9297         return TEST_SUCCESS;
9298 }
9299
9300 static int
9301 test_null_cipher_only_operation(void)
9302 {
9303         struct crypto_testsuite_params *ts_params = &testsuite_params;
9304         struct crypto_unittest_params *ut_params = &unittest_params;
9305
9306         /* Verify the capabilities */
9307         struct rte_cryptodev_sym_capability_idx cap_idx;
9308         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
9309         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_NULL;
9310         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9311                         &cap_idx) == NULL)
9312                 return -ENOTSUP;
9313
9314         /* Generate test mbuf data and space for digest */
9315         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
9316                         catch_22_quote, QUOTE_512_BYTES, 0);
9317
9318         /* Setup Cipher Parameters */
9319         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
9320         ut_params->cipher_xform.next = NULL;
9321
9322         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
9323         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
9324
9325         ut_params->sess = rte_cryptodev_sym_session_create(
9326                         ts_params->session_mpool);
9327
9328         /* Create Crypto session*/
9329         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
9330                                 ut_params->sess,
9331                                 &ut_params->cipher_xform,
9332                                 ts_params->session_priv_mpool);
9333         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
9334
9335         /* Generate Crypto op data structure */
9336         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9337                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9338         TEST_ASSERT_NOT_NULL(ut_params->op,
9339                         "Failed to allocate symmetric crypto operation struct");
9340
9341         /* Set crypto operation data parameters */
9342         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9343
9344         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
9345
9346         /* set crypto operation source mbuf */
9347         sym_op->m_src = ut_params->ibuf;
9348
9349         sym_op->cipher.data.offset = 0;
9350         sym_op->cipher.data.length = QUOTE_512_BYTES;
9351
9352         /* Process crypto operation */
9353         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
9354                         ut_params->op);
9355         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
9356
9357         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9358                         "crypto operation processing failed");
9359
9360         /* Validate obuf */
9361         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9362                         rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
9363                         catch_22_quote,
9364                         QUOTE_512_BYTES,
9365                         "Ciphertext data not as expected");
9366
9367         return TEST_SUCCESS;
9368 }
9369 uint8_t orig_data[] = {0xab, 0xab, 0xab, 0xab,
9370                         0xab, 0xab, 0xab, 0xab,
9371                         0xab, 0xab, 0xab, 0xab,
9372                         0xab, 0xab, 0xab, 0xab};
9373 static int
9374 test_null_auth_only_operation(void)
9375 {
9376         struct crypto_testsuite_params *ts_params = &testsuite_params;
9377         struct crypto_unittest_params *ut_params = &unittest_params;
9378         uint8_t *digest;
9379
9380         /* Verify the capabilities */
9381         struct rte_cryptodev_sym_capability_idx cap_idx;
9382         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
9383         cap_idx.algo.auth = RTE_CRYPTO_AUTH_NULL;
9384         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9385                         &cap_idx) == NULL)
9386                 return -ENOTSUP;
9387
9388         /* Generate test mbuf data and space for digest */
9389         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
9390                         catch_22_quote, QUOTE_512_BYTES, 0);
9391
9392         /* create a pointer for digest, but don't expect anything to be written
9393          * here in a NULL auth algo so no mbuf append done.
9394          */
9395         digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
9396                         QUOTE_512_BYTES);
9397         /* prefill the memory pointed to by digest */
9398         memcpy(digest, orig_data, sizeof(orig_data));
9399
9400         /* Setup HMAC Parameters */
9401         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
9402         ut_params->auth_xform.next = NULL;
9403
9404         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
9405         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
9406
9407         ut_params->sess = rte_cryptodev_sym_session_create(
9408                         ts_params->session_mpool);
9409
9410         /* Create Crypto session*/
9411         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
9412                         ut_params->sess, &ut_params->auth_xform,
9413                         ts_params->session_priv_mpool);
9414         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
9415
9416         /* Generate Crypto op data structure */
9417         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9418                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9419         TEST_ASSERT_NOT_NULL(ut_params->op,
9420                         "Failed to allocate symmetric crypto operation struct");
9421
9422         /* Set crypto operation data parameters */
9423         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9424
9425         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
9426
9427         sym_op->m_src = ut_params->ibuf;
9428
9429         sym_op->auth.data.offset = 0;
9430         sym_op->auth.data.length = QUOTE_512_BYTES;
9431         sym_op->auth.digest.data = digest;
9432         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf,
9433                         QUOTE_512_BYTES);
9434
9435         /* Process crypto operation */
9436         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
9437                         ut_params->op);
9438         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
9439
9440         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9441                         "crypto operation processing failed");
9442         /* Make sure memory pointed to by digest hasn't been overwritten */
9443         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9444                         orig_data,
9445                         digest,
9446                         sizeof(orig_data),
9447                         "Memory at digest ptr overwritten unexpectedly");
9448
9449         return TEST_SUCCESS;
9450 }
9451
9452
9453 static int
9454 test_null_cipher_auth_operation(void)
9455 {
9456         struct crypto_testsuite_params *ts_params = &testsuite_params;
9457         struct crypto_unittest_params *ut_params = &unittest_params;
9458         uint8_t *digest;
9459
9460         /* Verify the capabilities */
9461         struct rte_cryptodev_sym_capability_idx cap_idx;
9462         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
9463         cap_idx.algo.auth = RTE_CRYPTO_AUTH_NULL;
9464         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9465                         &cap_idx) == NULL)
9466                 return -ENOTSUP;
9467         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
9468         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_NULL;
9469         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9470                         &cap_idx) == NULL)
9471                 return -ENOTSUP;
9472
9473         /* Generate test mbuf data and space for digest */
9474         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
9475                         catch_22_quote, QUOTE_512_BYTES, 0);
9476
9477         /* create a pointer for digest, but don't expect anything to be written
9478          * here in a NULL auth algo so no mbuf append done.
9479          */
9480         digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
9481                         QUOTE_512_BYTES);
9482         /* prefill the memory pointed to by digest */
9483         memcpy(digest, orig_data, sizeof(orig_data));
9484
9485         /* Setup Cipher Parameters */
9486         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
9487         ut_params->cipher_xform.next = &ut_params->auth_xform;
9488
9489         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
9490         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
9491
9492         /* Setup HMAC Parameters */
9493         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
9494         ut_params->auth_xform.next = NULL;
9495
9496         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
9497         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
9498
9499         ut_params->sess = rte_cryptodev_sym_session_create(
9500                         ts_params->session_mpool);
9501
9502         /* Create Crypto session*/
9503         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
9504                         ut_params->sess, &ut_params->cipher_xform,
9505                         ts_params->session_priv_mpool);
9506         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
9507
9508         /* Generate Crypto op data structure */
9509         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9510                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9511         TEST_ASSERT_NOT_NULL(ut_params->op,
9512                         "Failed to allocate symmetric crypto operation struct");
9513
9514         /* Set crypto operation data parameters */
9515         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9516
9517         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
9518
9519         sym_op->m_src = ut_params->ibuf;
9520
9521         sym_op->cipher.data.offset = 0;
9522         sym_op->cipher.data.length = QUOTE_512_BYTES;
9523
9524         sym_op->auth.data.offset = 0;
9525         sym_op->auth.data.length = QUOTE_512_BYTES;
9526         sym_op->auth.digest.data = digest;
9527         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf,
9528                         QUOTE_512_BYTES);
9529
9530         /* Process crypto operation */
9531         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
9532                         ut_params->op);
9533         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
9534
9535         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9536                         "crypto operation processing failed");
9537
9538         /* Validate obuf */
9539         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9540                         rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
9541                         catch_22_quote,
9542                         QUOTE_512_BYTES,
9543                         "Ciphertext data not as expected");
9544         /* Make sure memory pointed to by digest hasn't been overwritten */
9545         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9546                         orig_data,
9547                         digest,
9548                         sizeof(orig_data),
9549                         "Memory at digest ptr overwritten unexpectedly");
9550
9551         return TEST_SUCCESS;
9552 }
9553
9554 static int
9555 test_null_auth_cipher_operation(void)
9556 {
9557         struct crypto_testsuite_params *ts_params = &testsuite_params;
9558         struct crypto_unittest_params *ut_params = &unittest_params;
9559         uint8_t *digest;
9560
9561         /* Verify the capabilities */
9562         struct rte_cryptodev_sym_capability_idx cap_idx;
9563         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
9564         cap_idx.algo.auth = RTE_CRYPTO_AUTH_NULL;
9565         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9566                         &cap_idx) == NULL)
9567                 return -ENOTSUP;
9568         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
9569         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_NULL;
9570         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9571                         &cap_idx) == NULL)
9572                 return -ENOTSUP;
9573
9574         /* Generate test mbuf data */
9575         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
9576                         catch_22_quote, QUOTE_512_BYTES, 0);
9577
9578         /* create a pointer for digest, but don't expect anything to be written
9579          * here in a NULL auth algo so no mbuf append done.
9580          */
9581         digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
9582                                 QUOTE_512_BYTES);
9583         /* prefill the memory pointed to by digest */
9584         memcpy(digest, orig_data, sizeof(orig_data));
9585
9586         /* Setup Cipher Parameters */
9587         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
9588         ut_params->cipher_xform.next = NULL;
9589
9590         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
9591         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
9592
9593         /* Setup HMAC Parameters */
9594         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
9595         ut_params->auth_xform.next = &ut_params->cipher_xform;
9596
9597         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
9598         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
9599
9600         ut_params->sess = rte_cryptodev_sym_session_create(
9601                         ts_params->session_mpool);
9602
9603         /* Create Crypto session*/
9604         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
9605                         ut_params->sess, &ut_params->cipher_xform,
9606                         ts_params->session_priv_mpool);
9607         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
9608
9609         /* Generate Crypto op data structure */
9610         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9611                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9612         TEST_ASSERT_NOT_NULL(ut_params->op,
9613                         "Failed to allocate symmetric crypto operation struct");
9614
9615         /* Set crypto operation data parameters */
9616         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9617
9618         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
9619
9620         sym_op->m_src = ut_params->ibuf;
9621
9622         sym_op->cipher.data.offset = 0;
9623         sym_op->cipher.data.length = QUOTE_512_BYTES;
9624
9625         sym_op->auth.data.offset = 0;
9626         sym_op->auth.data.length = QUOTE_512_BYTES;
9627         sym_op->auth.digest.data = digest;
9628         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf,
9629                                         QUOTE_512_BYTES);
9630
9631         /* Process crypto operation */
9632         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
9633                         ut_params->op);
9634         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
9635
9636         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9637                         "crypto operation processing failed");
9638
9639         /* Validate obuf */
9640         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9641                         rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
9642                         catch_22_quote,
9643                         QUOTE_512_BYTES,
9644                         "Ciphertext data not as expected");
9645         /* Make sure memory pointed to by digest hasn't been overwritten */
9646         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9647                         orig_data,
9648                         digest,
9649                         sizeof(orig_data),
9650                         "Memory at digest ptr overwritten unexpectedly");
9651
9652         return TEST_SUCCESS;
9653 }
9654
9655
9656 static int
9657 test_null_invalid_operation(void)
9658 {
9659         struct crypto_testsuite_params *ts_params = &testsuite_params;
9660         struct crypto_unittest_params *ut_params = &unittest_params;
9661         int ret;
9662
9663         /* This test is for NULL PMD only */
9664         if (gbl_driver_id != rte_cryptodev_driver_id_get(
9665                         RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
9666                 return -ENOTSUP;
9667
9668         /* Setup Cipher Parameters */
9669         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
9670         ut_params->cipher_xform.next = NULL;
9671
9672         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
9673         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
9674
9675         ut_params->sess = rte_cryptodev_sym_session_create(
9676                         ts_params->session_mpool);
9677
9678         /* Create Crypto session*/
9679         ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
9680                         ut_params->sess, &ut_params->cipher_xform,
9681                         ts_params->session_priv_mpool);
9682         TEST_ASSERT(ret < 0,
9683                         "Session creation succeeded unexpectedly");
9684
9685
9686         /* Setup HMAC Parameters */
9687         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
9688         ut_params->auth_xform.next = NULL;
9689
9690         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
9691         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
9692
9693         ut_params->sess = rte_cryptodev_sym_session_create(
9694                         ts_params->session_mpool);
9695
9696         /* Create Crypto session*/
9697         ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
9698                         ut_params->sess, &ut_params->auth_xform,
9699                         ts_params->session_priv_mpool);
9700         TEST_ASSERT(ret < 0,
9701                         "Session creation succeeded unexpectedly");
9702
9703         return TEST_SUCCESS;
9704 }
9705
9706
9707 #define NULL_BURST_LENGTH (32)
9708
9709 static int
9710 test_null_burst_operation(void)
9711 {
9712         struct crypto_testsuite_params *ts_params = &testsuite_params;
9713         struct crypto_unittest_params *ut_params = &unittest_params;
9714
9715         unsigned i, burst_len = NULL_BURST_LENGTH;
9716
9717         struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
9718         struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
9719
9720         /* This test is for NULL PMD only */
9721         if (gbl_driver_id != rte_cryptodev_driver_id_get(
9722                         RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
9723                 return -ENOTSUP;
9724
9725         /* Setup Cipher Parameters */
9726         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
9727         ut_params->cipher_xform.next = &ut_params->auth_xform;
9728
9729         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
9730         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
9731
9732         /* Setup HMAC Parameters */
9733         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
9734         ut_params->auth_xform.next = NULL;
9735
9736         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
9737         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
9738
9739         ut_params->sess = rte_cryptodev_sym_session_create(
9740                         ts_params->session_mpool);
9741
9742         /* Create Crypto session*/
9743         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
9744                         ut_params->sess, &ut_params->cipher_xform,
9745                         ts_params->session_priv_mpool);
9746         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
9747
9748         TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
9749                         RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
9750                         burst_len, "failed to generate burst of crypto ops");
9751
9752         /* Generate an operation for each mbuf in burst */
9753         for (i = 0; i < burst_len; i++) {
9754                 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9755
9756                 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
9757
9758                 unsigned *data = (unsigned *)rte_pktmbuf_append(m,
9759                                 sizeof(unsigned));
9760                 *data = i;
9761
9762                 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
9763
9764                 burst[i]->sym->m_src = m;
9765         }
9766
9767         /* Process crypto operation */
9768         TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
9769                         0, burst, burst_len),
9770                         burst_len,
9771                         "Error enqueuing burst");
9772
9773         TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
9774                         0, burst_dequeued, burst_len),
9775                         burst_len,
9776                         "Error dequeuing burst");
9777
9778
9779         for (i = 0; i < burst_len; i++) {
9780                 TEST_ASSERT_EQUAL(
9781                         *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
9782                         *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
9783                                         uint32_t *),
9784                         "data not as expected");
9785
9786                 rte_pktmbuf_free(burst[i]->sym->m_src);
9787                 rte_crypto_op_free(burst[i]);
9788         }
9789
9790         return TEST_SUCCESS;
9791 }
9792
9793 static void
9794 generate_gmac_large_plaintext(uint8_t *data)
9795 {
9796         uint16_t i;
9797
9798         for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32)
9799                 memcpy(&data[i], &data[0], 32);
9800 }
9801
9802 static int
9803 create_gmac_operation(enum rte_crypto_auth_operation op,
9804                 const struct gmac_test_data *tdata)
9805 {
9806         struct crypto_testsuite_params *ts_params = &testsuite_params;
9807         struct crypto_unittest_params *ut_params = &unittest_params;
9808         struct rte_crypto_sym_op *sym_op;
9809
9810         uint32_t plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
9811
9812         /* Generate Crypto op data structure */
9813         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9814                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9815         TEST_ASSERT_NOT_NULL(ut_params->op,
9816                         "Failed to allocate symmetric crypto operation struct");
9817
9818         sym_op = ut_params->op->sym;
9819
9820         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
9821                         ut_params->ibuf, tdata->gmac_tag.len);
9822         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
9823                         "no room to append digest");
9824
9825         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
9826                         ut_params->ibuf, plaintext_pad_len);
9827
9828         if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
9829                 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
9830                                 tdata->gmac_tag.len);
9831                 debug_hexdump(stdout, "digest:",
9832                                 sym_op->auth.digest.data,
9833                                 tdata->gmac_tag.len);
9834         }
9835
9836         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
9837                         uint8_t *, IV_OFFSET);
9838
9839         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
9840
9841         debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
9842
9843         sym_op->cipher.data.length = 0;
9844         sym_op->cipher.data.offset = 0;
9845
9846         sym_op->auth.data.offset = 0;
9847         sym_op->auth.data.length = tdata->plaintext.len;
9848
9849         return 0;
9850 }
9851
9852 static int create_gmac_session(uint8_t dev_id,
9853                 const struct gmac_test_data *tdata,
9854                 enum rte_crypto_auth_operation auth_op)
9855 {
9856         uint8_t auth_key[tdata->key.len];
9857
9858         struct crypto_testsuite_params *ts_params = &testsuite_params;
9859         struct crypto_unittest_params *ut_params = &unittest_params;
9860
9861         memcpy(auth_key, tdata->key.data, tdata->key.len);
9862
9863         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
9864         ut_params->auth_xform.next = NULL;
9865
9866         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
9867         ut_params->auth_xform.auth.op = auth_op;
9868         ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
9869         ut_params->auth_xform.auth.key.length = tdata->key.len;
9870         ut_params->auth_xform.auth.key.data = auth_key;
9871         ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
9872         ut_params->auth_xform.auth.iv.length = tdata->iv.len;
9873
9874
9875         ut_params->sess = rte_cryptodev_sym_session_create(
9876                         ts_params->session_mpool);
9877
9878         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
9879                         &ut_params->auth_xform,
9880                         ts_params->session_priv_mpool);
9881
9882         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
9883
9884         return 0;
9885 }
9886
9887 static int
9888 test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
9889 {
9890         struct crypto_testsuite_params *ts_params = &testsuite_params;
9891         struct crypto_unittest_params *ut_params = &unittest_params;
9892
9893         int retval;
9894
9895         uint8_t *auth_tag, *plaintext;
9896         uint16_t plaintext_pad_len;
9897
9898         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
9899                               "No GMAC length in the source data");
9900
9901         /* Verify the capabilities */
9902         struct rte_cryptodev_sym_capability_idx cap_idx;
9903         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
9904         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
9905         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9906                         &cap_idx) == NULL)
9907                 return -ENOTSUP;
9908
9909         retval = create_gmac_session(ts_params->valid_devs[0],
9910                         tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
9911
9912         if (retval < 0)
9913                 return retval;
9914
9915         if (tdata->plaintext.len > MBUF_SIZE)
9916                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
9917         else
9918                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9919         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
9920                         "Failed to allocate input buffer in mempool");
9921
9922         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9923                         rte_pktmbuf_tailroom(ut_params->ibuf));
9924
9925         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
9926         /*
9927          * Runtime generate the large plain text instead of use hard code
9928          * plain text vector. It is done to avoid create huge source file
9929          * with the test vector.
9930          */
9931         if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
9932                 generate_gmac_large_plaintext(tdata->plaintext.data);
9933
9934         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9935                                 plaintext_pad_len);
9936         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
9937
9938         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
9939         debug_hexdump(stdout, "plaintext:", plaintext,
9940                         tdata->plaintext.len);
9941
9942         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
9943                         tdata);
9944
9945         if (retval < 0)
9946                 return retval;
9947
9948         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9949
9950         ut_params->op->sym->m_src = ut_params->ibuf;
9951
9952         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
9953                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
9954                         ut_params->op);
9955         else
9956                 TEST_ASSERT_NOT_NULL(
9957                         process_crypto_request(ts_params->valid_devs[0],
9958                         ut_params->op), "failed to process sym crypto op");
9959
9960         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9961                         "crypto op processing failed");
9962
9963         if (ut_params->op->sym->m_dst) {
9964                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
9965                                 uint8_t *, plaintext_pad_len);
9966         } else {
9967                 auth_tag = plaintext + plaintext_pad_len;
9968         }
9969
9970         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
9971
9972         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9973                         auth_tag,
9974                         tdata->gmac_tag.data,
9975                         tdata->gmac_tag.len,
9976                         "GMAC Generated auth tag not as expected");
9977
9978         return 0;
9979 }
9980
9981 static int
9982 test_AES_GMAC_authentication_test_case_1(void)
9983 {
9984         return test_AES_GMAC_authentication(&gmac_test_case_1);
9985 }
9986
9987 static int
9988 test_AES_GMAC_authentication_test_case_2(void)
9989 {
9990         return test_AES_GMAC_authentication(&gmac_test_case_2);
9991 }
9992
9993 static int
9994 test_AES_GMAC_authentication_test_case_3(void)
9995 {
9996         return test_AES_GMAC_authentication(&gmac_test_case_3);
9997 }
9998
9999 static int
10000 test_AES_GMAC_authentication_test_case_4(void)
10001 {
10002         return test_AES_GMAC_authentication(&gmac_test_case_4);
10003 }
10004
10005 static int
10006 test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
10007 {
10008         struct crypto_testsuite_params *ts_params = &testsuite_params;
10009         struct crypto_unittest_params *ut_params = &unittest_params;
10010         int retval;
10011         uint32_t plaintext_pad_len;
10012         uint8_t *plaintext;
10013
10014         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
10015                               "No GMAC length in the source data");
10016
10017         /* Verify the capabilities */
10018         struct rte_cryptodev_sym_capability_idx cap_idx;
10019         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10020         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
10021         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10022                         &cap_idx) == NULL)
10023                 return -ENOTSUP;
10024
10025         retval = create_gmac_session(ts_params->valid_devs[0],
10026                         tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
10027
10028         if (retval < 0)
10029                 return retval;
10030
10031         if (tdata->plaintext.len > MBUF_SIZE)
10032                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
10033         else
10034                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10035         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
10036                         "Failed to allocate input buffer in mempool");
10037
10038         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10039                         rte_pktmbuf_tailroom(ut_params->ibuf));
10040
10041         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
10042
10043         /*
10044          * Runtime generate the large plain text instead of use hard code
10045          * plain text vector. It is done to avoid create huge source file
10046          * with the test vector.
10047          */
10048         if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
10049                 generate_gmac_large_plaintext(tdata->plaintext.data);
10050
10051         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
10052                                 plaintext_pad_len);
10053         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
10054
10055         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
10056         debug_hexdump(stdout, "plaintext:", plaintext,
10057                         tdata->plaintext.len);
10058
10059         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
10060                         tdata);
10061
10062         if (retval < 0)
10063                 return retval;
10064
10065         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10066
10067         ut_params->op->sym->m_src = ut_params->ibuf;
10068
10069         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10070                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
10071                         ut_params->op);
10072         else
10073                 TEST_ASSERT_NOT_NULL(
10074                         process_crypto_request(ts_params->valid_devs[0],
10075                         ut_params->op), "failed to process sym crypto op");
10076
10077         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10078                         "crypto op processing failed");
10079
10080         return 0;
10081
10082 }
10083
10084 static int
10085 test_AES_GMAC_authentication_verify_test_case_1(void)
10086 {
10087         return test_AES_GMAC_authentication_verify(&gmac_test_case_1);
10088 }
10089
10090 static int
10091 test_AES_GMAC_authentication_verify_test_case_2(void)
10092 {
10093         return test_AES_GMAC_authentication_verify(&gmac_test_case_2);
10094 }
10095
10096 static int
10097 test_AES_GMAC_authentication_verify_test_case_3(void)
10098 {
10099         return test_AES_GMAC_authentication_verify(&gmac_test_case_3);
10100 }
10101
10102 static int
10103 test_AES_GMAC_authentication_verify_test_case_4(void)
10104 {
10105         return test_AES_GMAC_authentication_verify(&gmac_test_case_4);
10106 }
10107
10108 struct test_crypto_vector {
10109         enum rte_crypto_cipher_algorithm crypto_algo;
10110         unsigned int cipher_offset;
10111         unsigned int cipher_len;
10112
10113         struct {
10114                 uint8_t data[64];
10115                 unsigned int len;
10116         } cipher_key;
10117
10118         struct {
10119                 uint8_t data[64];
10120                 unsigned int len;
10121         } iv;
10122
10123         struct {
10124                 const uint8_t *data;
10125                 unsigned int len;
10126         } plaintext;
10127
10128         struct {
10129                 const uint8_t *data;
10130                 unsigned int len;
10131         } ciphertext;
10132
10133         enum rte_crypto_auth_algorithm auth_algo;
10134         unsigned int auth_offset;
10135
10136         struct {
10137                 uint8_t data[128];
10138                 unsigned int len;
10139         } auth_key;
10140
10141         struct {
10142                 const uint8_t *data;
10143                 unsigned int len;
10144         } aad;
10145
10146         struct {
10147                 uint8_t data[128];
10148                 unsigned int len;
10149         } digest;
10150 };
10151
10152 static const struct test_crypto_vector
10153 hmac_sha1_test_crypto_vector = {
10154         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
10155         .plaintext = {
10156                 .data = plaintext_hash,
10157                 .len = 512
10158         },
10159         .auth_key = {
10160                 .data = {
10161                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
10162                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
10163                         0xDE, 0xF4, 0xDE, 0xAD
10164                 },
10165                 .len = 20
10166         },
10167         .digest = {
10168                 .data = {
10169                         0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
10170                         0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
10171                         0x3F, 0x91, 0x64, 0x59
10172                 },
10173                 .len = 20
10174         }
10175 };
10176
10177 static const struct test_crypto_vector
10178 aes128_gmac_test_vector = {
10179         .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
10180         .plaintext = {
10181                 .data = plaintext_hash,
10182                 .len = 512
10183         },
10184         .iv = {
10185                 .data = {
10186                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
10187                         0x08, 0x09, 0x0A, 0x0B
10188                 },
10189                 .len = 12
10190         },
10191         .auth_key = {
10192                 .data = {
10193                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
10194                         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
10195                 },
10196                 .len = 16
10197         },
10198         .digest = {
10199                 .data = {
10200                         0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56,
10201                         0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A
10202                 },
10203                 .len = 16
10204         }
10205 };
10206
10207 static const struct test_crypto_vector
10208 aes128cbc_hmac_sha1_test_vector = {
10209         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
10210         .cipher_offset = 0,
10211         .cipher_len = 512,
10212         .cipher_key = {
10213                 .data = {
10214                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
10215                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
10216                 },
10217                 .len = 16
10218         },
10219         .iv = {
10220                 .data = {
10221                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
10222                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
10223                 },
10224                 .len = 16
10225         },
10226         .plaintext = {
10227                 .data = plaintext_hash,
10228                 .len = 512
10229         },
10230         .ciphertext = {
10231                 .data = ciphertext512_aes128cbc,
10232                 .len = 512
10233         },
10234         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
10235         .auth_offset = 0,
10236         .auth_key = {
10237                 .data = {
10238                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
10239                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
10240                         0xDE, 0xF4, 0xDE, 0xAD
10241                 },
10242                 .len = 20
10243         },
10244         .digest = {
10245                 .data = {
10246                         0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
10247                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
10248                         0x18, 0x8C, 0x1D, 0x32
10249                 },
10250                 .len = 20
10251         }
10252 };
10253
10254 static const struct test_crypto_vector
10255 aes128cbc_hmac_sha1_aad_test_vector = {
10256         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
10257         .cipher_offset = 12,
10258         .cipher_len = 496,
10259         .cipher_key = {
10260                 .data = {
10261                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
10262                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
10263                 },
10264                 .len = 16
10265         },
10266         .iv = {
10267                 .data = {
10268                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
10269                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
10270                 },
10271                 .len = 16
10272         },
10273         .plaintext = {
10274                 .data = plaintext_hash,
10275                 .len = 512
10276         },
10277         .ciphertext = {
10278                 .data = ciphertext512_aes128cbc_aad,
10279                 .len = 512
10280         },
10281         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
10282         .auth_offset = 0,
10283         .auth_key = {
10284                 .data = {
10285                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
10286                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
10287                         0xDE, 0xF4, 0xDE, 0xAD
10288                 },
10289                 .len = 20
10290         },
10291         .digest = {
10292                 .data = {
10293                         0x1F, 0x6A, 0xD2, 0x8B, 0x4B, 0xB3, 0xC0, 0x9E,
10294                         0x86, 0x9B, 0x3A, 0xF2, 0x00, 0x5B, 0x4F, 0x08,
10295                         0x62, 0x8D, 0x62, 0x65
10296                 },
10297                 .len = 20
10298         }
10299 };
10300
10301 static void
10302 data_corruption(uint8_t *data)
10303 {
10304         data[0] += 1;
10305 }
10306
10307 static void
10308 tag_corruption(uint8_t *data, unsigned int tag_offset)
10309 {
10310         data[tag_offset] += 1;
10311 }
10312
10313 static int
10314 create_auth_session(struct crypto_unittest_params *ut_params,
10315                 uint8_t dev_id,
10316                 const struct test_crypto_vector *reference,
10317                 enum rte_crypto_auth_operation auth_op)
10318 {
10319         struct crypto_testsuite_params *ts_params = &testsuite_params;
10320         uint8_t auth_key[reference->auth_key.len + 1];
10321
10322         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
10323
10324         /* Setup Authentication Parameters */
10325         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10326         ut_params->auth_xform.auth.op = auth_op;
10327         ut_params->auth_xform.next = NULL;
10328         ut_params->auth_xform.auth.algo = reference->auth_algo;
10329         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
10330         ut_params->auth_xform.auth.key.data = auth_key;
10331         ut_params->auth_xform.auth.digest_length = reference->digest.len;
10332
10333         /* Create Crypto session*/
10334         ut_params->sess = rte_cryptodev_sym_session_create(
10335                         ts_params->session_mpool);
10336
10337         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
10338                                 &ut_params->auth_xform,
10339                                 ts_params->session_priv_mpool);
10340
10341         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
10342
10343         return 0;
10344 }
10345
10346 static int
10347 create_auth_cipher_session(struct crypto_unittest_params *ut_params,
10348                 uint8_t dev_id,
10349                 const struct test_crypto_vector *reference,
10350                 enum rte_crypto_auth_operation auth_op,
10351                 enum rte_crypto_cipher_operation cipher_op)
10352 {
10353         struct crypto_testsuite_params *ts_params = &testsuite_params;
10354         uint8_t cipher_key[reference->cipher_key.len + 1];
10355         uint8_t auth_key[reference->auth_key.len + 1];
10356
10357         memcpy(cipher_key, reference->cipher_key.data,
10358                         reference->cipher_key.len);
10359         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
10360
10361         /* Setup Authentication Parameters */
10362         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10363         ut_params->auth_xform.auth.op = auth_op;
10364         ut_params->auth_xform.auth.algo = reference->auth_algo;
10365         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
10366         ut_params->auth_xform.auth.key.data = auth_key;
10367         ut_params->auth_xform.auth.digest_length = reference->digest.len;
10368
10369         if (reference->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) {
10370                 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
10371                 ut_params->auth_xform.auth.iv.length = reference->iv.len;
10372         } else {
10373                 ut_params->auth_xform.next = &ut_params->cipher_xform;
10374
10375                 /* Setup Cipher Parameters */
10376                 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10377                 ut_params->cipher_xform.next = NULL;
10378                 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
10379                 ut_params->cipher_xform.cipher.op = cipher_op;
10380                 ut_params->cipher_xform.cipher.key.data = cipher_key;
10381                 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
10382                 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
10383                 ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
10384         }
10385
10386         /* Create Crypto session*/
10387         ut_params->sess = rte_cryptodev_sym_session_create(
10388                         ts_params->session_mpool);
10389
10390         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
10391                                 &ut_params->auth_xform,
10392                                 ts_params->session_priv_mpool);
10393
10394         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
10395
10396         return 0;
10397 }
10398
10399 static int
10400 create_auth_operation(struct crypto_testsuite_params *ts_params,
10401                 struct crypto_unittest_params *ut_params,
10402                 const struct test_crypto_vector *reference,
10403                 unsigned int auth_generate)
10404 {
10405         /* Generate Crypto op data structure */
10406         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10407                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10408         TEST_ASSERT_NOT_NULL(ut_params->op,
10409                         "Failed to allocate pktmbuf offload");
10410
10411         /* Set crypto operation data parameters */
10412         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10413
10414         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
10415
10416         /* set crypto operation source mbuf */
10417         sym_op->m_src = ut_params->ibuf;
10418
10419         /* digest */
10420         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
10421                         ut_params->ibuf, reference->digest.len);
10422
10423         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
10424                         "no room to append auth tag");
10425
10426         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
10427                         ut_params->ibuf, reference->plaintext.len);
10428
10429         if (auth_generate)
10430                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
10431         else
10432                 memcpy(sym_op->auth.digest.data,
10433                                 reference->digest.data,
10434                                 reference->digest.len);
10435
10436         debug_hexdump(stdout, "digest:",
10437                         sym_op->auth.digest.data,
10438                         reference->digest.len);
10439
10440         sym_op->auth.data.length = reference->plaintext.len;
10441         sym_op->auth.data.offset = 0;
10442
10443         return 0;
10444 }
10445
10446 static int
10447 create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
10448                 struct crypto_unittest_params *ut_params,
10449                 const struct test_crypto_vector *reference,
10450                 unsigned int auth_generate)
10451 {
10452         /* Generate Crypto op data structure */
10453         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10454                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10455         TEST_ASSERT_NOT_NULL(ut_params->op,
10456                         "Failed to allocate pktmbuf offload");
10457
10458         /* Set crypto operation data parameters */
10459         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10460
10461         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
10462
10463         /* set crypto operation source mbuf */
10464         sym_op->m_src = ut_params->ibuf;
10465
10466         /* digest */
10467         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
10468                         ut_params->ibuf, reference->digest.len);
10469
10470         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
10471                         "no room to append auth tag");
10472
10473         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
10474                         ut_params->ibuf, reference->ciphertext.len);
10475
10476         if (auth_generate)
10477                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
10478         else
10479                 memcpy(sym_op->auth.digest.data,
10480                                 reference->digest.data,
10481                                 reference->digest.len);
10482
10483         debug_hexdump(stdout, "digest:",
10484                         sym_op->auth.digest.data,
10485                         reference->digest.len);
10486
10487         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
10488                         reference->iv.data, reference->iv.len);
10489
10490         sym_op->cipher.data.length = 0;
10491         sym_op->cipher.data.offset = 0;
10492
10493         sym_op->auth.data.length = reference->plaintext.len;
10494         sym_op->auth.data.offset = 0;
10495
10496         return 0;
10497 }
10498
10499 static int
10500 create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
10501                 struct crypto_unittest_params *ut_params,
10502                 const struct test_crypto_vector *reference,
10503                 unsigned int auth_generate)
10504 {
10505         /* Generate Crypto op data structure */
10506         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10507                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10508         TEST_ASSERT_NOT_NULL(ut_params->op,
10509                         "Failed to allocate pktmbuf offload");
10510
10511         /* Set crypto operation data parameters */
10512         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10513
10514         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
10515
10516         /* set crypto operation source mbuf */
10517         sym_op->m_src = ut_params->ibuf;
10518
10519         /* digest */
10520         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
10521                         ut_params->ibuf, reference->digest.len);
10522
10523         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
10524                         "no room to append auth tag");
10525
10526         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
10527                         ut_params->ibuf, reference->ciphertext.len);
10528
10529         if (auth_generate)
10530                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
10531         else
10532                 memcpy(sym_op->auth.digest.data,
10533                                 reference->digest.data,
10534                                 reference->digest.len);
10535
10536         debug_hexdump(stdout, "digest:",
10537                         sym_op->auth.digest.data,
10538                         reference->digest.len);
10539
10540         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
10541                         reference->iv.data, reference->iv.len);
10542
10543         sym_op->cipher.data.length = reference->cipher_len;
10544         sym_op->cipher.data.offset = reference->cipher_offset;
10545
10546         sym_op->auth.data.length = reference->plaintext.len;
10547         sym_op->auth.data.offset = reference->auth_offset;
10548
10549         return 0;
10550 }
10551
10552 static int
10553 create_auth_verify_operation(struct crypto_testsuite_params *ts_params,
10554                 struct crypto_unittest_params *ut_params,
10555                 const struct test_crypto_vector *reference)
10556 {
10557         return create_auth_operation(ts_params, ut_params, reference, 0);
10558 }
10559
10560 static int
10561 create_auth_verify_GMAC_operation(
10562                 struct crypto_testsuite_params *ts_params,
10563                 struct crypto_unittest_params *ut_params,
10564                 const struct test_crypto_vector *reference)
10565 {
10566         return create_auth_GMAC_operation(ts_params, ut_params, reference, 0);
10567 }
10568
10569 static int
10570 create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params,
10571                 struct crypto_unittest_params *ut_params,
10572                 const struct test_crypto_vector *reference)
10573 {
10574         return create_cipher_auth_operation(ts_params, ut_params, reference, 0);
10575 }
10576
10577 static int
10578 test_authentication_verify_fail_when_data_corruption(
10579                 struct crypto_testsuite_params *ts_params,
10580                 struct crypto_unittest_params *ut_params,
10581                 const struct test_crypto_vector *reference,
10582                 unsigned int data_corrupted)
10583 {
10584         int retval;
10585
10586         uint8_t *plaintext;
10587
10588         /* Verify the capabilities */
10589         struct rte_cryptodev_sym_capability_idx cap_idx;
10590         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10591         cap_idx.algo.auth = reference->auth_algo;
10592         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10593                         &cap_idx) == NULL)
10594                 return -ENOTSUP;
10595
10596         /* Create session */
10597         retval = create_auth_session(ut_params,
10598                         ts_params->valid_devs[0],
10599                         reference,
10600                         RTE_CRYPTO_AUTH_OP_VERIFY);
10601         if (retval < 0)
10602                 return retval;
10603
10604         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10605         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
10606                         "Failed to allocate input buffer in mempool");
10607
10608         /* clear mbuf payload */
10609         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10610                         rte_pktmbuf_tailroom(ut_params->ibuf));
10611
10612         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
10613                         reference->plaintext.len);
10614         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
10615         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
10616
10617         debug_hexdump(stdout, "plaintext:", plaintext,
10618                 reference->plaintext.len);
10619
10620         /* Create operation */
10621         retval = create_auth_verify_operation(ts_params, ut_params, reference);
10622
10623         if (retval < 0)
10624                 return retval;
10625
10626         if (data_corrupted)
10627                 data_corruption(plaintext);
10628         else
10629                 tag_corruption(plaintext, reference->plaintext.len);
10630
10631         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
10632                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
10633                         ut_params->op);
10634                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
10635                         RTE_CRYPTO_OP_STATUS_SUCCESS,
10636                         "authentication not failed");
10637         } else {
10638                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
10639                         ut_params->op);
10640                 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
10641         }
10642
10643         return 0;
10644 }
10645
10646 static int
10647 test_authentication_verify_GMAC_fail_when_corruption(
10648                 struct crypto_testsuite_params *ts_params,
10649                 struct crypto_unittest_params *ut_params,
10650                 const struct test_crypto_vector *reference,
10651                 unsigned int data_corrupted)
10652 {
10653         int retval;
10654         uint8_t *plaintext;
10655
10656         /* Verify the capabilities */
10657         struct rte_cryptodev_sym_capability_idx cap_idx;
10658         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10659         cap_idx.algo.auth = reference->auth_algo;
10660         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10661                         &cap_idx) == NULL)
10662                 return -ENOTSUP;
10663
10664         /* Create session */
10665         retval = create_auth_cipher_session(ut_params,
10666                         ts_params->valid_devs[0],
10667                         reference,
10668                         RTE_CRYPTO_AUTH_OP_VERIFY,
10669                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
10670         if (retval < 0)
10671                 return retval;
10672
10673         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10674         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
10675                         "Failed to allocate input buffer in mempool");
10676
10677         /* clear mbuf payload */
10678         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10679                         rte_pktmbuf_tailroom(ut_params->ibuf));
10680
10681         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
10682                         reference->plaintext.len);
10683         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
10684         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
10685
10686         debug_hexdump(stdout, "plaintext:", plaintext,
10687                 reference->plaintext.len);
10688
10689         /* Create operation */
10690         retval = create_auth_verify_GMAC_operation(ts_params,
10691                         ut_params,
10692                         reference);
10693
10694         if (retval < 0)
10695                 return retval;
10696
10697         if (data_corrupted)
10698                 data_corruption(plaintext);
10699         else
10700                 tag_corruption(plaintext, reference->aad.len);
10701
10702         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
10703                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
10704                         ut_params->op);
10705                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
10706                         RTE_CRYPTO_OP_STATUS_SUCCESS,
10707                         "authentication not failed");
10708         } else {
10709                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
10710                         ut_params->op);
10711                 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
10712         }
10713
10714         return 0;
10715 }
10716
10717 static int
10718 test_authenticated_decryption_fail_when_corruption(
10719                 struct crypto_testsuite_params *ts_params,
10720                 struct crypto_unittest_params *ut_params,
10721                 const struct test_crypto_vector *reference,
10722                 unsigned int data_corrupted)
10723 {
10724         int retval;
10725
10726         uint8_t *ciphertext;
10727
10728         /* Verify the capabilities */
10729         struct rte_cryptodev_sym_capability_idx cap_idx;
10730         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10731         cap_idx.algo.auth = reference->auth_algo;
10732         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10733                         &cap_idx) == NULL)
10734                 return -ENOTSUP;
10735         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10736         cap_idx.algo.cipher = reference->crypto_algo;
10737         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10738                         &cap_idx) == NULL)
10739                 return -ENOTSUP;
10740
10741         /* Create session */
10742         retval = create_auth_cipher_session(ut_params,
10743                         ts_params->valid_devs[0],
10744                         reference,
10745                         RTE_CRYPTO_AUTH_OP_VERIFY,
10746                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
10747         if (retval < 0)
10748                 return retval;
10749
10750         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10751         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
10752                         "Failed to allocate input buffer in mempool");
10753
10754         /* clear mbuf payload */
10755         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10756                         rte_pktmbuf_tailroom(ut_params->ibuf));
10757
10758         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
10759                         reference->ciphertext.len);
10760         TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
10761         memcpy(ciphertext, reference->ciphertext.data,
10762                         reference->ciphertext.len);
10763
10764         /* Create operation */
10765         retval = create_cipher_auth_verify_operation(ts_params,
10766                         ut_params,
10767                         reference);
10768
10769         if (retval < 0)
10770                 return retval;
10771
10772         if (data_corrupted)
10773                 data_corruption(ciphertext);
10774         else
10775                 tag_corruption(ciphertext, reference->ciphertext.len);
10776
10777         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
10778                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
10779                         ut_params->op);
10780                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
10781                         RTE_CRYPTO_OP_STATUS_SUCCESS,
10782                         "authentication not failed");
10783         } else {
10784                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
10785                         ut_params->op);
10786                 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
10787         }
10788
10789         return 0;
10790 }
10791
10792 static int
10793 test_authenticated_encryt_with_esn(
10794                 struct crypto_testsuite_params *ts_params,
10795                 struct crypto_unittest_params *ut_params,
10796                 const struct test_crypto_vector *reference)
10797 {
10798         int retval;
10799
10800         uint8_t *authciphertext, *plaintext, *auth_tag;
10801         uint16_t plaintext_pad_len;
10802         uint8_t cipher_key[reference->cipher_key.len + 1];
10803         uint8_t auth_key[reference->auth_key.len + 1];
10804
10805         /* Verify the capabilities */
10806         struct rte_cryptodev_sym_capability_idx cap_idx;
10807         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10808         cap_idx.algo.auth = reference->auth_algo;
10809         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10810                         &cap_idx) == NULL)
10811                 return -ENOTSUP;
10812         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10813         cap_idx.algo.cipher = reference->crypto_algo;
10814         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10815                         &cap_idx) == NULL)
10816                 return -ENOTSUP;
10817
10818         /* Create session */
10819         memcpy(cipher_key, reference->cipher_key.data,
10820                         reference->cipher_key.len);
10821         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
10822
10823         /* Setup Cipher Parameters */
10824         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10825         ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
10826         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
10827         ut_params->cipher_xform.cipher.key.data = cipher_key;
10828         ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
10829         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
10830         ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
10831
10832         ut_params->cipher_xform.next = &ut_params->auth_xform;
10833
10834         /* Setup Authentication Parameters */
10835         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10836         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
10837         ut_params->auth_xform.auth.algo = reference->auth_algo;
10838         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
10839         ut_params->auth_xform.auth.key.data = auth_key;
10840         ut_params->auth_xform.auth.digest_length = reference->digest.len;
10841         ut_params->auth_xform.next = NULL;
10842
10843         /* Create Crypto session*/
10844         ut_params->sess = rte_cryptodev_sym_session_create(
10845                         ts_params->session_mpool);
10846
10847         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10848                                 ut_params->sess,
10849                                 &ut_params->cipher_xform,
10850                                 ts_params->session_priv_mpool);
10851
10852         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
10853
10854         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10855         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
10856                         "Failed to allocate input buffer in mempool");
10857
10858         /* clear mbuf payload */
10859         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10860                         rte_pktmbuf_tailroom(ut_params->ibuf));
10861
10862         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
10863                         reference->plaintext.len);
10864         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
10865         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
10866
10867         /* Create operation */
10868         retval = create_cipher_auth_operation(ts_params,
10869                         ut_params,
10870                         reference, 0);
10871
10872         if (retval < 0)
10873                 return retval;
10874
10875         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10876                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
10877                         ut_params->op);
10878         else
10879                 ut_params->op = process_crypto_request(
10880                         ts_params->valid_devs[0], ut_params->op);
10881
10882         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
10883
10884         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10885                         "crypto op processing failed");
10886
10887         plaintext_pad_len = RTE_ALIGN_CEIL(reference->plaintext.len, 16);
10888
10889         authciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
10890                         ut_params->op->sym->auth.data.offset);
10891         auth_tag = authciphertext + plaintext_pad_len;
10892         debug_hexdump(stdout, "ciphertext:", authciphertext,
10893                         reference->ciphertext.len);
10894         debug_hexdump(stdout, "auth tag:", auth_tag, reference->digest.len);
10895
10896         /* Validate obuf */
10897         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10898                         authciphertext,
10899                         reference->ciphertext.data,
10900                         reference->ciphertext.len,
10901                         "Ciphertext data not as expected");
10902
10903         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10904                         auth_tag,
10905                         reference->digest.data,
10906                         reference->digest.len,
10907                         "Generated digest not as expected");
10908
10909         return TEST_SUCCESS;
10910
10911 }
10912
10913 static int
10914 test_authenticated_decrypt_with_esn(
10915                 struct crypto_testsuite_params *ts_params,
10916                 struct crypto_unittest_params *ut_params,
10917                 const struct test_crypto_vector *reference)
10918 {
10919         int retval;
10920
10921         uint8_t *ciphertext;
10922         uint8_t cipher_key[reference->cipher_key.len + 1];
10923         uint8_t auth_key[reference->auth_key.len + 1];
10924
10925         /* Verify the capabilities */
10926         struct rte_cryptodev_sym_capability_idx cap_idx;
10927         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10928         cap_idx.algo.auth = reference->auth_algo;
10929         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10930                         &cap_idx) == NULL)
10931                 return -ENOTSUP;
10932         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10933         cap_idx.algo.cipher = reference->crypto_algo;
10934         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10935                         &cap_idx) == NULL)
10936                 return -ENOTSUP;
10937
10938         /* Create session */
10939         memcpy(cipher_key, reference->cipher_key.data,
10940                         reference->cipher_key.len);
10941         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
10942
10943         /* Setup Authentication Parameters */
10944         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10945         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
10946         ut_params->auth_xform.auth.algo = reference->auth_algo;
10947         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
10948         ut_params->auth_xform.auth.key.data = auth_key;
10949         ut_params->auth_xform.auth.digest_length = reference->digest.len;
10950         ut_params->auth_xform.next = &ut_params->cipher_xform;
10951
10952         /* Setup Cipher Parameters */
10953         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10954         ut_params->cipher_xform.next = NULL;
10955         ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
10956         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
10957         ut_params->cipher_xform.cipher.key.data = cipher_key;
10958         ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
10959         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
10960         ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
10961
10962         /* Create Crypto session*/
10963         ut_params->sess = rte_cryptodev_sym_session_create(
10964                         ts_params->session_mpool);
10965
10966         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10967                                 ut_params->sess,
10968                                 &ut_params->auth_xform,
10969                                 ts_params->session_priv_mpool);
10970
10971         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
10972
10973         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10974         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
10975                         "Failed to allocate input buffer in mempool");
10976
10977         /* clear mbuf payload */
10978         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10979                         rte_pktmbuf_tailroom(ut_params->ibuf));
10980
10981         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
10982                         reference->ciphertext.len);
10983         TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
10984         memcpy(ciphertext, reference->ciphertext.data,
10985                         reference->ciphertext.len);
10986
10987         /* Create operation */
10988         retval = create_cipher_auth_verify_operation(ts_params,
10989                         ut_params,
10990                         reference);
10991
10992         if (retval < 0)
10993                 return retval;
10994
10995         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10996                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
10997                         ut_params->op);
10998         else
10999                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
11000                         ut_params->op);
11001
11002         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
11003         TEST_ASSERT_EQUAL(ut_params->op->status,
11004                         RTE_CRYPTO_OP_STATUS_SUCCESS,
11005                         "crypto op processing passed");
11006
11007         ut_params->obuf = ut_params->op->sym->m_src;
11008         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
11009
11010         return 0;
11011 }
11012
11013 static int
11014 create_aead_operation_SGL(enum rte_crypto_aead_operation op,
11015                 const struct aead_test_data *tdata,
11016                 void *digest_mem, uint64_t digest_phys)
11017 {
11018         struct crypto_testsuite_params *ts_params = &testsuite_params;
11019         struct crypto_unittest_params *ut_params = &unittest_params;
11020
11021         const unsigned int auth_tag_len = tdata->auth_tag.len;
11022         const unsigned int iv_len = tdata->iv.len;
11023         unsigned int aad_len = tdata->aad.len;
11024         unsigned int aad_len_pad = 0;
11025
11026         /* Generate Crypto op data structure */
11027         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11028                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11029         TEST_ASSERT_NOT_NULL(ut_params->op,
11030                 "Failed to allocate symmetric crypto operation struct");
11031
11032         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
11033
11034         sym_op->aead.digest.data = digest_mem;
11035
11036         TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
11037                         "no room to append digest");
11038
11039         sym_op->aead.digest.phys_addr = digest_phys;
11040
11041         if (op == RTE_CRYPTO_AEAD_OP_DECRYPT) {
11042                 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
11043                                 auth_tag_len);
11044                 debug_hexdump(stdout, "digest:",
11045                                 sym_op->aead.digest.data,
11046                                 auth_tag_len);
11047         }
11048
11049         /* Append aad data */
11050         if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
11051                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
11052                                 uint8_t *, IV_OFFSET);
11053
11054                 /* Copy IV 1 byte after the IV pointer, according to the API */
11055                 rte_memcpy(iv_ptr + 1, tdata->iv.data, iv_len);
11056
11057                 aad_len = RTE_ALIGN_CEIL(aad_len + 18, 16);
11058
11059                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
11060                                 ut_params->ibuf, aad_len);
11061                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
11062                                 "no room to prepend aad");
11063                 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
11064                                 ut_params->ibuf);
11065
11066                 memset(sym_op->aead.aad.data, 0, aad_len);
11067                 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
11068                 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
11069
11070                 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
11071                 debug_hexdump(stdout, "aad:",
11072                                 sym_op->aead.aad.data, aad_len);
11073         } else {
11074                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
11075                                 uint8_t *, IV_OFFSET);
11076
11077                 rte_memcpy(iv_ptr, tdata->iv.data, iv_len);
11078
11079                 aad_len_pad = RTE_ALIGN_CEIL(aad_len, 16);
11080
11081                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
11082                                 ut_params->ibuf, aad_len_pad);
11083                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
11084                                 "no room to prepend aad");
11085                 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
11086                                 ut_params->ibuf);
11087
11088                 memset(sym_op->aead.aad.data, 0, aad_len);
11089                 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
11090
11091                 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
11092                 debug_hexdump(stdout, "aad:",
11093                                 sym_op->aead.aad.data, aad_len);
11094         }
11095
11096         sym_op->aead.data.length = tdata->plaintext.len;
11097         sym_op->aead.data.offset = aad_len_pad;
11098
11099         return 0;
11100 }
11101
11102 #define SGL_MAX_NO      16
11103
11104 static int
11105 test_authenticated_encryption_SGL(const struct aead_test_data *tdata,
11106                 const int oop, uint32_t fragsz, uint32_t fragsz_oop)
11107 {
11108         struct crypto_testsuite_params *ts_params = &testsuite_params;
11109         struct crypto_unittest_params *ut_params = &unittest_params;
11110         struct rte_mbuf *buf, *buf_oop = NULL, *buf_last_oop = NULL;
11111         int retval;
11112         int to_trn = 0;
11113         int to_trn_tbl[SGL_MAX_NO];
11114         int segs = 1;
11115         unsigned int trn_data = 0;
11116         uint8_t *plaintext, *ciphertext, *auth_tag;
11117         struct rte_cryptodev_info dev_info;
11118
11119         /* Verify the capabilities */
11120         struct rte_cryptodev_sym_capability_idx cap_idx;
11121         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
11122         cap_idx.algo.aead = tdata->algo;
11123         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11124                         &cap_idx) == NULL)
11125                 return -ENOTSUP;
11126
11127         /* OOP not supported with CPU crypto */
11128         if (oop && gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11129                 return -ENOTSUP;
11130
11131         /* Detailed check for the particular SGL support flag */
11132         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11133         if (!oop) {
11134                 unsigned int sgl_in = fragsz < tdata->plaintext.len;
11135                 if (sgl_in && (!(dev_info.feature_flags &
11136                                 RTE_CRYPTODEV_FF_IN_PLACE_SGL)))
11137                         return -ENOTSUP;
11138         } else {
11139                 unsigned int sgl_in = fragsz < tdata->plaintext.len;
11140                 unsigned int sgl_out = (fragsz_oop ? fragsz_oop : fragsz) <
11141                                 tdata->plaintext.len;
11142                 if (sgl_in && !sgl_out) {
11143                         if (!(dev_info.feature_flags &
11144                                         RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT))
11145                                 return -ENOTSUP;
11146                 } else if (!sgl_in && sgl_out) {
11147                         if (!(dev_info.feature_flags &
11148                                         RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT))
11149                                 return -ENOTSUP;
11150                 } else if (sgl_in && sgl_out) {
11151                         if (!(dev_info.feature_flags &
11152                                         RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT))
11153                                 return -ENOTSUP;
11154                 }
11155         }
11156
11157         if (fragsz > tdata->plaintext.len)
11158                 fragsz = tdata->plaintext.len;
11159
11160         uint16_t plaintext_len = fragsz;
11161         uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
11162
11163         if (fragsz_oop > tdata->plaintext.len)
11164                 frag_size_oop = tdata->plaintext.len;
11165
11166         int ecx = 0;
11167         void *digest_mem = NULL;
11168
11169         uint32_t prepend_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
11170
11171         if (tdata->plaintext.len % fragsz != 0) {
11172                 if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO)
11173                         return 1;
11174         }       else {
11175                 if (tdata->plaintext.len / fragsz > SGL_MAX_NO)
11176                         return 1;
11177         }
11178
11179         /*
11180          * For out-op-place we need to alloc another mbuf
11181          */
11182         if (oop) {
11183                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11184                 rte_pktmbuf_append(ut_params->obuf,
11185                                 frag_size_oop + prepend_len);
11186                 buf_oop = ut_params->obuf;
11187         }
11188
11189         /* Create AEAD session */
11190         retval = create_aead_session(ts_params->valid_devs[0],
11191                         tdata->algo,
11192                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
11193                         tdata->key.data, tdata->key.len,
11194                         tdata->aad.len, tdata->auth_tag.len,
11195                         tdata->iv.len);
11196         if (retval < 0)
11197                 return retval;
11198
11199         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11200
11201         /* clear mbuf payload */
11202         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11203                         rte_pktmbuf_tailroom(ut_params->ibuf));
11204
11205         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11206                         plaintext_len);
11207
11208         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
11209
11210         trn_data += plaintext_len;
11211
11212         buf = ut_params->ibuf;
11213
11214         /*
11215          * Loop until no more fragments
11216          */
11217
11218         while (trn_data < tdata->plaintext.len) {
11219                 ++segs;
11220                 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
11221                                 (tdata->plaintext.len - trn_data) : fragsz;
11222
11223                 to_trn_tbl[ecx++] = to_trn;
11224
11225                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11226                 buf = buf->next;
11227
11228                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
11229                                 rte_pktmbuf_tailroom(buf));
11230
11231                 /* OOP */
11232                 if (oop && !fragsz_oop) {
11233                         buf_last_oop = buf_oop->next =
11234                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
11235                         buf_oop = buf_oop->next;
11236                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
11237                                         0, rte_pktmbuf_tailroom(buf_oop));
11238                         rte_pktmbuf_append(buf_oop, to_trn);
11239                 }
11240
11241                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
11242                                 to_trn);
11243
11244                 memcpy(plaintext, tdata->plaintext.data + trn_data,
11245                                 to_trn);
11246                 trn_data += to_trn;
11247                 if (trn_data  == tdata->plaintext.len) {
11248                         if (oop) {
11249                                 if (!fragsz_oop)
11250                                         digest_mem = rte_pktmbuf_append(buf_oop,
11251                                                 tdata->auth_tag.len);
11252                         } else
11253                                 digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
11254                                         tdata->auth_tag.len);
11255                 }
11256         }
11257
11258         uint64_t digest_phys = 0;
11259
11260         ut_params->ibuf->nb_segs = segs;
11261
11262         segs = 1;
11263         if (fragsz_oop && oop) {
11264                 to_trn = 0;
11265                 ecx = 0;
11266
11267                 if (frag_size_oop == tdata->plaintext.len) {
11268                         digest_mem = rte_pktmbuf_append(ut_params->obuf,
11269                                 tdata->auth_tag.len);
11270
11271                         digest_phys = rte_pktmbuf_iova_offset(
11272                                         ut_params->obuf,
11273                                         tdata->plaintext.len + prepend_len);
11274                 }
11275
11276                 trn_data = frag_size_oop;
11277                 while (trn_data < tdata->plaintext.len) {
11278                         ++segs;
11279                         to_trn =
11280                                 (tdata->plaintext.len - trn_data <
11281                                                 frag_size_oop) ?
11282                                 (tdata->plaintext.len - trn_data) :
11283                                                 frag_size_oop;
11284
11285                         to_trn_tbl[ecx++] = to_trn;
11286
11287                         buf_last_oop = buf_oop->next =
11288                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
11289                         buf_oop = buf_oop->next;
11290                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
11291                                         0, rte_pktmbuf_tailroom(buf_oop));
11292                         rte_pktmbuf_append(buf_oop, to_trn);
11293
11294                         trn_data += to_trn;
11295
11296                         if (trn_data  == tdata->plaintext.len) {
11297                                 digest_mem = rte_pktmbuf_append(buf_oop,
11298                                         tdata->auth_tag.len);
11299                         }
11300                 }
11301
11302                 ut_params->obuf->nb_segs = segs;
11303         }
11304
11305         /*
11306          * Place digest at the end of the last buffer
11307          */
11308         if (!digest_phys)
11309                 digest_phys = rte_pktmbuf_iova(buf) + to_trn;
11310         if (oop && buf_last_oop)
11311                 digest_phys = rte_pktmbuf_iova(buf_last_oop) + to_trn;
11312
11313         if (!digest_mem && !oop) {
11314                 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11315                                 + tdata->auth_tag.len);
11316                 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
11317                                 tdata->plaintext.len);
11318         }
11319
11320         /* Create AEAD operation */
11321         retval = create_aead_operation_SGL(RTE_CRYPTO_AEAD_OP_ENCRYPT,
11322                         tdata, digest_mem, digest_phys);
11323
11324         if (retval < 0)
11325                 return retval;
11326
11327         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11328
11329         ut_params->op->sym->m_src = ut_params->ibuf;
11330         if (oop)
11331                 ut_params->op->sym->m_dst = ut_params->obuf;
11332
11333         /* Process crypto operation */
11334         if (oop == IN_PLACE &&
11335                         gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11336                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
11337         else
11338                 TEST_ASSERT_NOT_NULL(
11339                         process_crypto_request(ts_params->valid_devs[0],
11340                         ut_params->op), "failed to process sym crypto op");
11341
11342         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11343                         "crypto op processing failed");
11344
11345
11346         ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
11347                         uint8_t *, prepend_len);
11348         if (oop) {
11349                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
11350                                 uint8_t *, prepend_len);
11351         }
11352
11353         if (fragsz_oop)
11354                 fragsz = fragsz_oop;
11355
11356         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11357                         ciphertext,
11358                         tdata->ciphertext.data,
11359                         fragsz,
11360                         "Ciphertext data not as expected");
11361
11362         buf = ut_params->op->sym->m_src->next;
11363         if (oop)
11364                 buf = ut_params->op->sym->m_dst->next;
11365
11366         unsigned int off = fragsz;
11367
11368         ecx = 0;
11369         while (buf) {
11370                 ciphertext = rte_pktmbuf_mtod(buf,
11371                                 uint8_t *);
11372
11373                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
11374                                 ciphertext,
11375                                 tdata->ciphertext.data + off,
11376                                 to_trn_tbl[ecx],
11377                                 "Ciphertext data not as expected");
11378
11379                 off += to_trn_tbl[ecx++];
11380                 buf = buf->next;
11381         }
11382
11383         auth_tag = digest_mem;
11384         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11385                         auth_tag,
11386                         tdata->auth_tag.data,
11387                         tdata->auth_tag.len,
11388                         "Generated auth tag not as expected");
11389
11390         return 0;
11391 }
11392
11393 static int
11394 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void)
11395 {
11396         return test_authenticated_encryption_SGL(
11397                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 400, 400);
11398 }
11399
11400 static int
11401 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B(void)
11402 {
11403         return test_authenticated_encryption_SGL(
11404                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 1500, 2000);
11405 }
11406
11407 static int
11408 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void)
11409 {
11410         return test_authenticated_encryption_SGL(
11411                         &gcm_test_case_8, OUT_OF_PLACE, 400,
11412                         gcm_test_case_8.plaintext.len);
11413 }
11414
11415 static int
11416 test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void)
11417 {
11418         /* This test is not for OPENSSL PMD */
11419         if (gbl_driver_id == rte_cryptodev_driver_id_get(
11420                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)))
11421                 return -ENOTSUP;
11422
11423         return test_authenticated_encryption_SGL(
11424                         &gcm_test_case_SGL_1, IN_PLACE, 1500, 0);
11425 }
11426
11427 static int
11428 test_authentication_verify_fail_when_data_corrupted(
11429                 struct crypto_testsuite_params *ts_params,
11430                 struct crypto_unittest_params *ut_params,
11431                 const struct test_crypto_vector *reference)
11432 {
11433         return test_authentication_verify_fail_when_data_corruption(
11434                         ts_params, ut_params, reference, 1);
11435 }
11436
11437 static int
11438 test_authentication_verify_fail_when_tag_corrupted(
11439                 struct crypto_testsuite_params *ts_params,
11440                 struct crypto_unittest_params *ut_params,
11441                 const struct test_crypto_vector *reference)
11442 {
11443         return test_authentication_verify_fail_when_data_corruption(
11444                         ts_params, ut_params, reference, 0);
11445 }
11446
11447 static int
11448 test_authentication_verify_GMAC_fail_when_data_corrupted(
11449                 struct crypto_testsuite_params *ts_params,
11450                 struct crypto_unittest_params *ut_params,
11451                 const struct test_crypto_vector *reference)
11452 {
11453         return test_authentication_verify_GMAC_fail_when_corruption(
11454                         ts_params, ut_params, reference, 1);
11455 }
11456
11457 static int
11458 test_authentication_verify_GMAC_fail_when_tag_corrupted(
11459                 struct crypto_testsuite_params *ts_params,
11460                 struct crypto_unittest_params *ut_params,
11461                 const struct test_crypto_vector *reference)
11462 {
11463         return test_authentication_verify_GMAC_fail_when_corruption(
11464                         ts_params, ut_params, reference, 0);
11465 }
11466
11467 static int
11468 test_authenticated_decryption_fail_when_data_corrupted(
11469                 struct crypto_testsuite_params *ts_params,
11470                 struct crypto_unittest_params *ut_params,
11471                 const struct test_crypto_vector *reference)
11472 {
11473         return test_authenticated_decryption_fail_when_corruption(
11474                         ts_params, ut_params, reference, 1);
11475 }
11476
11477 static int
11478 test_authenticated_decryption_fail_when_tag_corrupted(
11479                 struct crypto_testsuite_params *ts_params,
11480                 struct crypto_unittest_params *ut_params,
11481                 const struct test_crypto_vector *reference)
11482 {
11483         return test_authenticated_decryption_fail_when_corruption(
11484                         ts_params, ut_params, reference, 0);
11485 }
11486
11487 static int
11488 authentication_verify_HMAC_SHA1_fail_data_corrupt(void)
11489 {
11490         return test_authentication_verify_fail_when_data_corrupted(
11491                         &testsuite_params, &unittest_params,
11492                         &hmac_sha1_test_crypto_vector);
11493 }
11494
11495 static int
11496 authentication_verify_HMAC_SHA1_fail_tag_corrupt(void)
11497 {
11498         return test_authentication_verify_fail_when_tag_corrupted(
11499                         &testsuite_params, &unittest_params,
11500                         &hmac_sha1_test_crypto_vector);
11501 }
11502
11503 static int
11504 authentication_verify_AES128_GMAC_fail_data_corrupt(void)
11505 {
11506         return test_authentication_verify_GMAC_fail_when_data_corrupted(
11507                         &testsuite_params, &unittest_params,
11508                         &aes128_gmac_test_vector);
11509 }
11510
11511 static int
11512 authentication_verify_AES128_GMAC_fail_tag_corrupt(void)
11513 {
11514         return test_authentication_verify_GMAC_fail_when_tag_corrupted(
11515                         &testsuite_params, &unittest_params,
11516                         &aes128_gmac_test_vector);
11517 }
11518
11519 static int
11520 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void)
11521 {
11522         return test_authenticated_decryption_fail_when_data_corrupted(
11523                         &testsuite_params,
11524                         &unittest_params,
11525                         &aes128cbc_hmac_sha1_test_vector);
11526 }
11527
11528 static int
11529 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void)
11530 {
11531         return test_authenticated_decryption_fail_when_tag_corrupted(
11532                         &testsuite_params,
11533                         &unittest_params,
11534                         &aes128cbc_hmac_sha1_test_vector);
11535 }
11536
11537 static int
11538 auth_encrypt_AES128CBC_HMAC_SHA1_esn_check(void)
11539 {
11540         return test_authenticated_encryt_with_esn(
11541                         &testsuite_params,
11542                         &unittest_params,
11543                         &aes128cbc_hmac_sha1_aad_test_vector);
11544 }
11545
11546 static int
11547 auth_decrypt_AES128CBC_HMAC_SHA1_esn_check(void)
11548 {
11549         return test_authenticated_decrypt_with_esn(
11550                         &testsuite_params,
11551                         &unittest_params,
11552                         &aes128cbc_hmac_sha1_aad_test_vector);
11553 }
11554
11555 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
11556
11557 /* global AESNI slave IDs for the scheduler test */
11558 uint8_t aesni_ids[2];
11559
11560 static int
11561 test_scheduler_attach_slave_op(void)
11562 {
11563         struct crypto_testsuite_params *ts_params = &testsuite_params;
11564         uint8_t sched_id = ts_params->valid_devs[0];
11565         uint32_t nb_devs, i, nb_devs_attached = 0;
11566         int ret;
11567         char vdev_name[32];
11568
11569         /* create 2 AESNI_MB if necessary */
11570         nb_devs = rte_cryptodev_device_count_by_driver(
11571                         rte_cryptodev_driver_id_get(
11572                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)));
11573         if (nb_devs < 2) {
11574                 for (i = nb_devs; i < 2; i++) {
11575                         snprintf(vdev_name, sizeof(vdev_name), "%s_%u",
11576                                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD),
11577                                         i);
11578                         ret = rte_vdev_init(vdev_name, NULL);
11579
11580                         TEST_ASSERT(ret == 0,
11581                                 "Failed to create instance %u of"
11582                                 " pmd : %s",
11583                                 i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
11584                 }
11585         }
11586
11587         /* attach 2 AESNI_MB cdevs */
11588         for (i = 0; i < rte_cryptodev_count() && nb_devs_attached < 2;
11589                         i++) {
11590                 struct rte_cryptodev_info info;
11591                 unsigned int session_size;
11592
11593                 rte_cryptodev_info_get(i, &info);
11594                 if (info.driver_id != rte_cryptodev_driver_id_get(
11595                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)))
11596                         continue;
11597
11598                 session_size = rte_cryptodev_sym_get_private_session_size(i);
11599                 /*
11600                  * Create the session mempool again, since now there are new devices
11601                  * to use the mempool.
11602                  */
11603                 if (ts_params->session_mpool) {
11604                         rte_mempool_free(ts_params->session_mpool);
11605                         ts_params->session_mpool = NULL;
11606                 }
11607                 if (ts_params->session_priv_mpool) {
11608                         rte_mempool_free(ts_params->session_priv_mpool);
11609                         ts_params->session_priv_mpool = NULL;
11610                 }
11611
11612                 if (info.sym.max_nb_sessions != 0 &&
11613                                 info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
11614                         RTE_LOG(ERR, USER1,
11615                                         "Device does not support "
11616                                         "at least %u sessions\n",
11617                                         MAX_NB_SESSIONS);
11618                         return TEST_FAILED;
11619                 }
11620                 /*
11621                  * Create mempool with maximum number of sessions,
11622                  * to include the session headers
11623                  */
11624                 if (ts_params->session_mpool == NULL) {
11625                         ts_params->session_mpool =
11626                                 rte_cryptodev_sym_session_pool_create(
11627                                                 "test_sess_mp",
11628                                                 MAX_NB_SESSIONS, 0, 0, 0,
11629                                                 SOCKET_ID_ANY);
11630                         TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
11631                                         "session mempool allocation failed");
11632                 }
11633
11634                 /*
11635                  * Create mempool with maximum number of sessions,
11636                  * to include device specific session private data
11637                  */
11638                 if (ts_params->session_priv_mpool == NULL) {
11639                         ts_params->session_priv_mpool = rte_mempool_create(
11640                                         "test_sess_mp_priv",
11641                                         MAX_NB_SESSIONS,
11642                                         session_size,
11643                                         0, 0, NULL, NULL, NULL,
11644                                         NULL, SOCKET_ID_ANY,
11645                                         0);
11646
11647                         TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
11648                                         "session mempool allocation failed");
11649                 }
11650
11651                 ts_params->qp_conf.mp_session = ts_params->session_mpool;
11652                 ts_params->qp_conf.mp_session_private =
11653                                 ts_params->session_priv_mpool;
11654
11655                 ret = rte_cryptodev_scheduler_slave_attach(sched_id,
11656                                 (uint8_t)i);
11657
11658                 TEST_ASSERT(ret == 0,
11659                         "Failed to attach device %u of pmd : %s", i,
11660                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
11661
11662                 aesni_ids[nb_devs_attached] = (uint8_t)i;
11663
11664                 nb_devs_attached++;
11665         }
11666
11667         return 0;
11668 }
11669
11670 static int
11671 test_scheduler_detach_slave_op(void)
11672 {
11673         struct crypto_testsuite_params *ts_params = &testsuite_params;
11674         uint8_t sched_id = ts_params->valid_devs[0];
11675         uint32_t i;
11676         int ret;
11677
11678         for (i = 0; i < 2; i++) {
11679                 ret = rte_cryptodev_scheduler_slave_detach(sched_id,
11680                                 aesni_ids[i]);
11681                 TEST_ASSERT(ret == 0,
11682                         "Failed to detach device %u", aesni_ids[i]);
11683         }
11684
11685         return 0;
11686 }
11687
11688 static int
11689 test_scheduler_mode_op(enum rte_cryptodev_scheduler_mode scheduler_mode)
11690 {
11691         struct crypto_testsuite_params *ts_params = &testsuite_params;
11692         uint8_t sched_id = ts_params->valid_devs[0];
11693         /* set mode */
11694         return rte_cryptodev_scheduler_mode_set(sched_id,
11695                 scheduler_mode);
11696 }
11697
11698 static int
11699 test_scheduler_mode_roundrobin_op(void)
11700 {
11701         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) ==
11702                         0, "Failed to set roundrobin mode");
11703         return 0;
11704
11705 }
11706
11707 static int
11708 test_scheduler_mode_multicore_op(void)
11709 {
11710         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) ==
11711                         0, "Failed to set multicore mode");
11712
11713         return 0;
11714 }
11715
11716 static int
11717 test_scheduler_mode_failover_op(void)
11718 {
11719         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) ==
11720                         0, "Failed to set failover mode");
11721
11722         return 0;
11723 }
11724
11725 static int
11726 test_scheduler_mode_pkt_size_distr_op(void)
11727 {
11728         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) ==
11729                         0, "Failed to set pktsize mode");
11730
11731         return 0;
11732 }
11733
11734 static struct unit_test_suite cryptodev_scheduler_testsuite  = {
11735         .suite_name = "Crypto Device Scheduler Unit Test Suite",
11736         .setup = testsuite_setup,
11737         .teardown = testsuite_teardown,
11738         .unit_test_cases = {
11739                 /* Multi Core */
11740                 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
11741                 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_multicore_op),
11742                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
11743                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
11744                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
11745                 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
11746
11747                 /* Round Robin */
11748                 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
11749                 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_roundrobin_op),
11750                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
11751                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
11752                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
11753                 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
11754
11755                 /* Fail over */
11756                 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
11757                 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_failover_op),
11758                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
11759                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
11760                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
11761                 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
11762
11763                 /* PKT SIZE */
11764                 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
11765                 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_pkt_size_distr_op),
11766                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
11767                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
11768                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
11769                 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
11770
11771                 TEST_CASES_END() /**< NULL terminate unit test array */
11772         }
11773 };
11774
11775 #endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
11776
11777 static struct unit_test_suite cryptodev_testsuite  = {
11778         .suite_name = "Crypto Unit Test Suite",
11779         .setup = testsuite_setup,
11780         .teardown = testsuite_teardown,
11781         .unit_test_cases = {
11782                 TEST_CASE_ST(ut_setup, ut_teardown,
11783                                 test_device_configure_invalid_dev_id),
11784                 TEST_CASE_ST(ut_setup, ut_teardown,
11785                                 test_queue_pair_descriptor_setup),
11786                 TEST_CASE_ST(ut_setup, ut_teardown,
11787                                 test_device_configure_invalid_queue_pair_ids),
11788
11789                 TEST_CASE_ST(ut_setup, ut_teardown,
11790                                 test_multi_session),
11791                 TEST_CASE_ST(ut_setup, ut_teardown,
11792                                 test_multi_session_random_usage),
11793
11794                 TEST_CASE_ST(ut_setup, ut_teardown,
11795                         test_null_invalid_operation),
11796                 TEST_CASE_ST(ut_setup, ut_teardown, test_null_burst_operation),
11797
11798                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
11799                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
11800                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
11801                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
11802                 TEST_CASE_ST(ut_setup, ut_teardown, test_DES_cipheronly_all),
11803                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_docsis_all),
11804                 TEST_CASE_ST(ut_setup, ut_teardown, test_DES_docsis_all),
11805                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
11806                 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
11807
11808                 /** AES CCM Authenticated Encryption 128 bits key */
11809                 TEST_CASE_ST(ut_setup, ut_teardown,
11810                         test_AES_CCM_authenticated_encryption_test_case_128_1),
11811                 TEST_CASE_ST(ut_setup, ut_teardown,
11812                         test_AES_CCM_authenticated_encryption_test_case_128_2),
11813                 TEST_CASE_ST(ut_setup, ut_teardown,
11814                         test_AES_CCM_authenticated_encryption_test_case_128_3),
11815
11816                 /** AES CCM Authenticated Decryption 128 bits key*/
11817                 TEST_CASE_ST(ut_setup, ut_teardown,
11818                         test_AES_CCM_authenticated_decryption_test_case_128_1),
11819                 TEST_CASE_ST(ut_setup, ut_teardown,
11820                         test_AES_CCM_authenticated_decryption_test_case_128_2),
11821                 TEST_CASE_ST(ut_setup, ut_teardown,
11822                         test_AES_CCM_authenticated_decryption_test_case_128_3),
11823
11824                 /** AES CCM Authenticated Encryption 192 bits key */
11825                 TEST_CASE_ST(ut_setup, ut_teardown,
11826                         test_AES_CCM_authenticated_encryption_test_case_192_1),
11827                 TEST_CASE_ST(ut_setup, ut_teardown,
11828                         test_AES_CCM_authenticated_encryption_test_case_192_2),
11829                 TEST_CASE_ST(ut_setup, ut_teardown,
11830                         test_AES_CCM_authenticated_encryption_test_case_192_3),
11831
11832                 /** AES CCM Authenticated Decryption 192 bits key*/
11833                 TEST_CASE_ST(ut_setup, ut_teardown,
11834                         test_AES_CCM_authenticated_decryption_test_case_192_1),
11835                 TEST_CASE_ST(ut_setup, ut_teardown,
11836                         test_AES_CCM_authenticated_decryption_test_case_192_2),
11837                 TEST_CASE_ST(ut_setup, ut_teardown,
11838                         test_AES_CCM_authenticated_decryption_test_case_192_3),
11839
11840                 /** AES CCM Authenticated Encryption 256 bits key */
11841                 TEST_CASE_ST(ut_setup, ut_teardown,
11842                         test_AES_CCM_authenticated_encryption_test_case_256_1),
11843                 TEST_CASE_ST(ut_setup, ut_teardown,
11844                         test_AES_CCM_authenticated_encryption_test_case_256_2),
11845                 TEST_CASE_ST(ut_setup, ut_teardown,
11846                         test_AES_CCM_authenticated_encryption_test_case_256_3),
11847
11848                 /** AES CCM Authenticated Decryption 256 bits key*/
11849                 TEST_CASE_ST(ut_setup, ut_teardown,
11850                         test_AES_CCM_authenticated_decryption_test_case_256_1),
11851                 TEST_CASE_ST(ut_setup, ut_teardown,
11852                         test_AES_CCM_authenticated_decryption_test_case_256_2),
11853                 TEST_CASE_ST(ut_setup, ut_teardown,
11854                         test_AES_CCM_authenticated_decryption_test_case_256_3),
11855
11856                 /** AES GCM Authenticated Encryption */
11857                 TEST_CASE_ST(ut_setup, ut_teardown,
11858                         test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
11859                 TEST_CASE_ST(ut_setup, ut_teardown,
11860                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
11861                 TEST_CASE_ST(ut_setup, ut_teardown,
11862                         test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
11863                 TEST_CASE_ST(ut_setup, ut_teardown,
11864                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
11865                 TEST_CASE_ST(ut_setup, ut_teardown,
11866                         test_AES_GCM_authenticated_encryption_test_case_1),
11867                 TEST_CASE_ST(ut_setup, ut_teardown,
11868                         test_AES_GCM_authenticated_encryption_test_case_2),
11869                 TEST_CASE_ST(ut_setup, ut_teardown,
11870                         test_AES_GCM_authenticated_encryption_test_case_3),
11871                 TEST_CASE_ST(ut_setup, ut_teardown,
11872                         test_AES_GCM_authenticated_encryption_test_case_4),
11873                 TEST_CASE_ST(ut_setup, ut_teardown,
11874                         test_AES_GCM_authenticated_encryption_test_case_5),
11875                 TEST_CASE_ST(ut_setup, ut_teardown,
11876                         test_AES_GCM_authenticated_encryption_test_case_6),
11877                 TEST_CASE_ST(ut_setup, ut_teardown,
11878                         test_AES_GCM_authenticated_encryption_test_case_7),
11879                 TEST_CASE_ST(ut_setup, ut_teardown,
11880                         test_AES_GCM_authenticated_encryption_test_case_8),
11881                 TEST_CASE_ST(ut_setup, ut_teardown,
11882                         test_AES_GCM_J0_authenticated_encryption_test_case_1),
11883
11884                 /** AES GCM Authenticated Decryption */
11885                 TEST_CASE_ST(ut_setup, ut_teardown,
11886                         test_AES_GCM_authenticated_decryption_test_case_1),
11887                 TEST_CASE_ST(ut_setup, ut_teardown,
11888                         test_AES_GCM_authenticated_decryption_test_case_2),
11889                 TEST_CASE_ST(ut_setup, ut_teardown,
11890                         test_AES_GCM_authenticated_decryption_test_case_3),
11891                 TEST_CASE_ST(ut_setup, ut_teardown,
11892                         test_AES_GCM_authenticated_decryption_test_case_4),
11893                 TEST_CASE_ST(ut_setup, ut_teardown,
11894                         test_AES_GCM_authenticated_decryption_test_case_5),
11895                 TEST_CASE_ST(ut_setup, ut_teardown,
11896                         test_AES_GCM_authenticated_decryption_test_case_6),
11897                 TEST_CASE_ST(ut_setup, ut_teardown,
11898                         test_AES_GCM_authenticated_decryption_test_case_7),
11899                 TEST_CASE_ST(ut_setup, ut_teardown,
11900                         test_AES_GCM_authenticated_decryption_test_case_8),
11901                 TEST_CASE_ST(ut_setup, ut_teardown,
11902                         test_AES_GCM_J0_authenticated_decryption_test_case_1),
11903
11904                 /** AES GCM Authenticated Encryption 192 bits key */
11905                 TEST_CASE_ST(ut_setup, ut_teardown,
11906                         test_AES_GCM_auth_encryption_test_case_192_1),
11907                 TEST_CASE_ST(ut_setup, ut_teardown,
11908                         test_AES_GCM_auth_encryption_test_case_192_2),
11909                 TEST_CASE_ST(ut_setup, ut_teardown,
11910                         test_AES_GCM_auth_encryption_test_case_192_3),
11911                 TEST_CASE_ST(ut_setup, ut_teardown,
11912                         test_AES_GCM_auth_encryption_test_case_192_4),
11913                 TEST_CASE_ST(ut_setup, ut_teardown,
11914                         test_AES_GCM_auth_encryption_test_case_192_5),
11915                 TEST_CASE_ST(ut_setup, ut_teardown,
11916                         test_AES_GCM_auth_encryption_test_case_192_6),
11917                 TEST_CASE_ST(ut_setup, ut_teardown,
11918                         test_AES_GCM_auth_encryption_test_case_192_7),
11919
11920                 /** AES GCM Authenticated Decryption 192 bits key */
11921                 TEST_CASE_ST(ut_setup, ut_teardown,
11922                         test_AES_GCM_auth_decryption_test_case_192_1),
11923                 TEST_CASE_ST(ut_setup, ut_teardown,
11924                         test_AES_GCM_auth_decryption_test_case_192_2),
11925                 TEST_CASE_ST(ut_setup, ut_teardown,
11926                         test_AES_GCM_auth_decryption_test_case_192_3),
11927                 TEST_CASE_ST(ut_setup, ut_teardown,
11928                         test_AES_GCM_auth_decryption_test_case_192_4),
11929                 TEST_CASE_ST(ut_setup, ut_teardown,
11930                         test_AES_GCM_auth_decryption_test_case_192_5),
11931                 TEST_CASE_ST(ut_setup, ut_teardown,
11932                         test_AES_GCM_auth_decryption_test_case_192_6),
11933                 TEST_CASE_ST(ut_setup, ut_teardown,
11934                         test_AES_GCM_auth_decryption_test_case_192_7),
11935
11936                 /** AES GCM Authenticated Encryption 256 bits key */
11937                 TEST_CASE_ST(ut_setup, ut_teardown,
11938                         test_AES_GCM_auth_encryption_test_case_256_1),
11939                 TEST_CASE_ST(ut_setup, ut_teardown,
11940                         test_AES_GCM_auth_encryption_test_case_256_2),
11941                 TEST_CASE_ST(ut_setup, ut_teardown,
11942                         test_AES_GCM_auth_encryption_test_case_256_3),
11943                 TEST_CASE_ST(ut_setup, ut_teardown,
11944                         test_AES_GCM_auth_encryption_test_case_256_4),
11945                 TEST_CASE_ST(ut_setup, ut_teardown,
11946                         test_AES_GCM_auth_encryption_test_case_256_5),
11947                 TEST_CASE_ST(ut_setup, ut_teardown,
11948                         test_AES_GCM_auth_encryption_test_case_256_6),
11949                 TEST_CASE_ST(ut_setup, ut_teardown,
11950                         test_AES_GCM_auth_encryption_test_case_256_7),
11951
11952                 /** AES GCM Authenticated Decryption 256 bits key */
11953                 TEST_CASE_ST(ut_setup, ut_teardown,
11954                         test_AES_GCM_auth_decryption_test_case_256_1),
11955                 TEST_CASE_ST(ut_setup, ut_teardown,
11956                         test_AES_GCM_auth_decryption_test_case_256_2),
11957                 TEST_CASE_ST(ut_setup, ut_teardown,
11958                         test_AES_GCM_auth_decryption_test_case_256_3),
11959                 TEST_CASE_ST(ut_setup, ut_teardown,
11960                         test_AES_GCM_auth_decryption_test_case_256_4),
11961                 TEST_CASE_ST(ut_setup, ut_teardown,
11962                         test_AES_GCM_auth_decryption_test_case_256_5),
11963                 TEST_CASE_ST(ut_setup, ut_teardown,
11964                         test_AES_GCM_auth_decryption_test_case_256_6),
11965                 TEST_CASE_ST(ut_setup, ut_teardown,
11966                         test_AES_GCM_auth_decryption_test_case_256_7),
11967
11968                 /** AES GCM Authenticated Encryption big aad size */
11969                 TEST_CASE_ST(ut_setup, ut_teardown,
11970                         test_AES_GCM_auth_encryption_test_case_aad_1),
11971                 TEST_CASE_ST(ut_setup, ut_teardown,
11972                         test_AES_GCM_auth_encryption_test_case_aad_2),
11973
11974                 /** AES GCM Authenticated Decryption big aad size */
11975                 TEST_CASE_ST(ut_setup, ut_teardown,
11976                         test_AES_GCM_auth_decryption_test_case_aad_1),
11977                 TEST_CASE_ST(ut_setup, ut_teardown,
11978                         test_AES_GCM_auth_decryption_test_case_aad_2),
11979
11980                 /** Out of place tests */
11981                 TEST_CASE_ST(ut_setup, ut_teardown,
11982                         test_AES_GCM_authenticated_encryption_oop_test_case_1),
11983                 TEST_CASE_ST(ut_setup, ut_teardown,
11984                         test_AES_GCM_authenticated_decryption_oop_test_case_1),
11985
11986                 /** Session-less tests */
11987                 TEST_CASE_ST(ut_setup, ut_teardown,
11988                         test_AES_GCM_authenticated_encryption_sessionless_test_case_1),
11989                 TEST_CASE_ST(ut_setup, ut_teardown,
11990                         test_AES_GCM_authenticated_decryption_sessionless_test_case_1),
11991
11992                 /** AES GMAC Authentication */
11993                 TEST_CASE_ST(ut_setup, ut_teardown,
11994                         test_AES_GMAC_authentication_test_case_1),
11995                 TEST_CASE_ST(ut_setup, ut_teardown,
11996                         test_AES_GMAC_authentication_verify_test_case_1),
11997                 TEST_CASE_ST(ut_setup, ut_teardown,
11998                         test_AES_GMAC_authentication_test_case_2),
11999                 TEST_CASE_ST(ut_setup, ut_teardown,
12000                         test_AES_GMAC_authentication_verify_test_case_2),
12001                 TEST_CASE_ST(ut_setup, ut_teardown,
12002                         test_AES_GMAC_authentication_test_case_3),
12003                 TEST_CASE_ST(ut_setup, ut_teardown,
12004                         test_AES_GMAC_authentication_verify_test_case_3),
12005                 TEST_CASE_ST(ut_setup, ut_teardown,
12006                         test_AES_GMAC_authentication_test_case_4),
12007                 TEST_CASE_ST(ut_setup, ut_teardown,
12008                         test_AES_GMAC_authentication_verify_test_case_4),
12009
12010                 /** SNOW 3G encrypt only (UEA2) */
12011                 TEST_CASE_ST(ut_setup, ut_teardown,
12012                         test_snow3g_encryption_test_case_1),
12013                 TEST_CASE_ST(ut_setup, ut_teardown,
12014                         test_snow3g_encryption_test_case_2),
12015                 TEST_CASE_ST(ut_setup, ut_teardown,
12016                         test_snow3g_encryption_test_case_3),
12017                 TEST_CASE_ST(ut_setup, ut_teardown,
12018                         test_snow3g_encryption_test_case_4),
12019                 TEST_CASE_ST(ut_setup, ut_teardown,
12020                         test_snow3g_encryption_test_case_5),
12021
12022                 TEST_CASE_ST(ut_setup, ut_teardown,
12023                         test_snow3g_encryption_test_case_1_oop),
12024                 TEST_CASE_ST(ut_setup, ut_teardown,
12025                         test_snow3g_encryption_test_case_1_oop_sgl),
12026                 TEST_CASE_ST(ut_setup, ut_teardown,
12027                         test_snow3g_encryption_test_case_1_offset_oop),
12028                 TEST_CASE_ST(ut_setup, ut_teardown,
12029                         test_snow3g_decryption_test_case_1_oop),
12030
12031                 /** SNOW 3G generate auth, then encrypt (UEA2) */
12032                 TEST_CASE_ST(ut_setup, ut_teardown,
12033                         test_snow3g_auth_cipher_test_case_1),
12034                 TEST_CASE_ST(ut_setup, ut_teardown,
12035                         test_snow3g_auth_cipher_test_case_2),
12036                 TEST_CASE_ST(ut_setup, ut_teardown,
12037                         test_snow3g_auth_cipher_test_case_2_oop),
12038                 TEST_CASE_ST(ut_setup, ut_teardown,
12039                         test_snow3g_auth_cipher_part_digest_enc),
12040                 TEST_CASE_ST(ut_setup, ut_teardown,
12041                         test_snow3g_auth_cipher_part_digest_enc_oop),
12042                 TEST_CASE_ST(ut_setup, ut_teardown,
12043                         test_snow3g_auth_cipher_test_case_3_sgl),
12044                 TEST_CASE_ST(ut_setup, ut_teardown,
12045                         test_snow3g_auth_cipher_test_case_3_oop_sgl),
12046                 TEST_CASE_ST(ut_setup, ut_teardown,
12047                         test_snow3g_auth_cipher_part_digest_enc_sgl),
12048                 TEST_CASE_ST(ut_setup, ut_teardown,
12049                         test_snow3g_auth_cipher_part_digest_enc_oop_sgl),
12050
12051                 /** SNOW 3G decrypt (UEA2), then verify auth */
12052                 TEST_CASE_ST(ut_setup, ut_teardown,
12053                         test_snow3g_auth_cipher_verify_test_case_1),
12054                 TEST_CASE_ST(ut_setup, ut_teardown,
12055                         test_snow3g_auth_cipher_verify_test_case_2),
12056                 TEST_CASE_ST(ut_setup, ut_teardown,
12057                         test_snow3g_auth_cipher_verify_test_case_2_oop),
12058                 TEST_CASE_ST(ut_setup, ut_teardown,
12059                         test_snow3g_auth_cipher_verify_part_digest_enc),
12060                 TEST_CASE_ST(ut_setup, ut_teardown,
12061                         test_snow3g_auth_cipher_verify_part_digest_enc_oop),
12062                 TEST_CASE_ST(ut_setup, ut_teardown,
12063                         test_snow3g_auth_cipher_verify_test_case_3_sgl),
12064                 TEST_CASE_ST(ut_setup, ut_teardown,
12065                         test_snow3g_auth_cipher_verify_test_case_3_oop_sgl),
12066                 TEST_CASE_ST(ut_setup, ut_teardown,
12067                         test_snow3g_auth_cipher_verify_part_digest_enc_sgl),
12068                 TEST_CASE_ST(ut_setup, ut_teardown,
12069                         test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl),
12070
12071                 /** SNOW 3G decrypt only (UEA2) */
12072                 TEST_CASE_ST(ut_setup, ut_teardown,
12073                         test_snow3g_decryption_test_case_1),
12074                 TEST_CASE_ST(ut_setup, ut_teardown,
12075                         test_snow3g_decryption_test_case_2),
12076                 TEST_CASE_ST(ut_setup, ut_teardown,
12077                         test_snow3g_decryption_test_case_3),
12078                 TEST_CASE_ST(ut_setup, ut_teardown,
12079                         test_snow3g_decryption_test_case_4),
12080                 TEST_CASE_ST(ut_setup, ut_teardown,
12081                         test_snow3g_decryption_test_case_5),
12082                 TEST_CASE_ST(ut_setup, ut_teardown,
12083                         test_snow3g_decryption_with_digest_test_case_1),
12084                 TEST_CASE_ST(ut_setup, ut_teardown,
12085                         test_snow3g_hash_generate_test_case_1),
12086                 TEST_CASE_ST(ut_setup, ut_teardown,
12087                         test_snow3g_hash_generate_test_case_2),
12088                 TEST_CASE_ST(ut_setup, ut_teardown,
12089                         test_snow3g_hash_generate_test_case_3),
12090                 /* Tests with buffers which length is not byte-aligned */
12091                 TEST_CASE_ST(ut_setup, ut_teardown,
12092                         test_snow3g_hash_generate_test_case_4),
12093                 TEST_CASE_ST(ut_setup, ut_teardown,
12094                         test_snow3g_hash_generate_test_case_5),
12095                 TEST_CASE_ST(ut_setup, ut_teardown,
12096                         test_snow3g_hash_generate_test_case_6),
12097                 TEST_CASE_ST(ut_setup, ut_teardown,
12098                         test_snow3g_hash_verify_test_case_1),
12099                 TEST_CASE_ST(ut_setup, ut_teardown,
12100                         test_snow3g_hash_verify_test_case_2),
12101                 TEST_CASE_ST(ut_setup, ut_teardown,
12102                         test_snow3g_hash_verify_test_case_3),
12103                 /* Tests with buffers which length is not byte-aligned */
12104                 TEST_CASE_ST(ut_setup, ut_teardown,
12105                         test_snow3g_hash_verify_test_case_4),
12106                 TEST_CASE_ST(ut_setup, ut_teardown,
12107                         test_snow3g_hash_verify_test_case_5),
12108                 TEST_CASE_ST(ut_setup, ut_teardown,
12109                         test_snow3g_hash_verify_test_case_6),
12110                 TEST_CASE_ST(ut_setup, ut_teardown,
12111                         test_snow3g_cipher_auth_test_case_1),
12112                 TEST_CASE_ST(ut_setup, ut_teardown,
12113                         test_snow3g_auth_cipher_with_digest_test_case_1),
12114
12115                 /** ZUC encrypt only (EEA3) */
12116                 TEST_CASE_ST(ut_setup, ut_teardown,
12117                         test_zuc_encryption_test_case_1),
12118                 TEST_CASE_ST(ut_setup, ut_teardown,
12119                         test_zuc_encryption_test_case_2),
12120                 TEST_CASE_ST(ut_setup, ut_teardown,
12121                         test_zuc_encryption_test_case_3),
12122                 TEST_CASE_ST(ut_setup, ut_teardown,
12123                         test_zuc_encryption_test_case_4),
12124                 TEST_CASE_ST(ut_setup, ut_teardown,
12125                         test_zuc_encryption_test_case_5),
12126                 TEST_CASE_ST(ut_setup, ut_teardown,
12127                         test_zuc_encryption_test_case_6_sgl),
12128
12129                 /** ZUC authenticate (EIA3) */
12130                 TEST_CASE_ST(ut_setup, ut_teardown,
12131                         test_zuc_hash_generate_test_case_1),
12132                 TEST_CASE_ST(ut_setup, ut_teardown,
12133                         test_zuc_hash_generate_test_case_2),
12134                 TEST_CASE_ST(ut_setup, ut_teardown,
12135                         test_zuc_hash_generate_test_case_3),
12136                 TEST_CASE_ST(ut_setup, ut_teardown,
12137                         test_zuc_hash_generate_test_case_4),
12138                 TEST_CASE_ST(ut_setup, ut_teardown,
12139                         test_zuc_hash_generate_test_case_5),
12140                 TEST_CASE_ST(ut_setup, ut_teardown,
12141                         test_zuc_hash_generate_test_case_6),
12142                 TEST_CASE_ST(ut_setup, ut_teardown,
12143                         test_zuc_hash_generate_test_case_7),
12144                 TEST_CASE_ST(ut_setup, ut_teardown,
12145                         test_zuc_hash_generate_test_case_8),
12146
12147                 /** ZUC alg-chain (EEA3/EIA3) */
12148                 TEST_CASE_ST(ut_setup, ut_teardown,
12149                         test_zuc_cipher_auth_test_case_1),
12150                 TEST_CASE_ST(ut_setup, ut_teardown,
12151                         test_zuc_cipher_auth_test_case_2),
12152
12153                 /** ZUC generate auth, then encrypt (EEA3) */
12154                 TEST_CASE_ST(ut_setup, ut_teardown,
12155                         test_zuc_auth_cipher_test_case_1),
12156                 TEST_CASE_ST(ut_setup, ut_teardown,
12157                         test_zuc_auth_cipher_test_case_1_oop),
12158                 TEST_CASE_ST(ut_setup, ut_teardown,
12159                         test_zuc_auth_cipher_test_case_1_sgl),
12160                 TEST_CASE_ST(ut_setup, ut_teardown,
12161                         test_zuc_auth_cipher_test_case_1_oop_sgl),
12162
12163                 /** ZUC decrypt (EEA3), then verify auth */
12164                 TEST_CASE_ST(ut_setup, ut_teardown,
12165                         test_zuc_auth_cipher_verify_test_case_1),
12166                 TEST_CASE_ST(ut_setup, ut_teardown,
12167                         test_zuc_auth_cipher_verify_test_case_1_oop),
12168                 TEST_CASE_ST(ut_setup, ut_teardown,
12169                         test_zuc_auth_cipher_verify_test_case_1_sgl),
12170                 TEST_CASE_ST(ut_setup, ut_teardown,
12171                         test_zuc_auth_cipher_verify_test_case_1_oop_sgl),
12172
12173                 /** HMAC_MD5 Authentication */
12174                 TEST_CASE_ST(ut_setup, ut_teardown,
12175                         test_MD5_HMAC_generate_case_1),
12176                 TEST_CASE_ST(ut_setup, ut_teardown,
12177                         test_MD5_HMAC_verify_case_1),
12178                 TEST_CASE_ST(ut_setup, ut_teardown,
12179                         test_MD5_HMAC_generate_case_2),
12180                 TEST_CASE_ST(ut_setup, ut_teardown,
12181                         test_MD5_HMAC_verify_case_2),
12182
12183                 /** KASUMI hash only (UIA1) */
12184                 TEST_CASE_ST(ut_setup, ut_teardown,
12185                         test_kasumi_hash_generate_test_case_1),
12186                 TEST_CASE_ST(ut_setup, ut_teardown,
12187                         test_kasumi_hash_generate_test_case_2),
12188                 TEST_CASE_ST(ut_setup, ut_teardown,
12189                         test_kasumi_hash_generate_test_case_3),
12190                 TEST_CASE_ST(ut_setup, ut_teardown,
12191                         test_kasumi_hash_generate_test_case_4),
12192                 TEST_CASE_ST(ut_setup, ut_teardown,
12193                         test_kasumi_hash_generate_test_case_5),
12194                 TEST_CASE_ST(ut_setup, ut_teardown,
12195                         test_kasumi_hash_generate_test_case_6),
12196
12197                 TEST_CASE_ST(ut_setup, ut_teardown,
12198                         test_kasumi_hash_verify_test_case_1),
12199                 TEST_CASE_ST(ut_setup, ut_teardown,
12200                         test_kasumi_hash_verify_test_case_2),
12201                 TEST_CASE_ST(ut_setup, ut_teardown,
12202                         test_kasumi_hash_verify_test_case_3),
12203                 TEST_CASE_ST(ut_setup, ut_teardown,
12204                         test_kasumi_hash_verify_test_case_4),
12205                 TEST_CASE_ST(ut_setup, ut_teardown,
12206                         test_kasumi_hash_verify_test_case_5),
12207
12208                 /** KASUMI encrypt only (UEA1) */
12209                 TEST_CASE_ST(ut_setup, ut_teardown,
12210                         test_kasumi_encryption_test_case_1),
12211                 TEST_CASE_ST(ut_setup, ut_teardown,
12212                         test_kasumi_encryption_test_case_1_sgl),
12213                 TEST_CASE_ST(ut_setup, ut_teardown,
12214                         test_kasumi_encryption_test_case_1_oop),
12215                 TEST_CASE_ST(ut_setup, ut_teardown,
12216                         test_kasumi_encryption_test_case_1_oop_sgl),
12217                 TEST_CASE_ST(ut_setup, ut_teardown,
12218                         test_kasumi_encryption_test_case_2),
12219                 TEST_CASE_ST(ut_setup, ut_teardown,
12220                         test_kasumi_encryption_test_case_3),
12221                 TEST_CASE_ST(ut_setup, ut_teardown,
12222                         test_kasumi_encryption_test_case_4),
12223                 TEST_CASE_ST(ut_setup, ut_teardown,
12224                         test_kasumi_encryption_test_case_5),
12225
12226                 /** KASUMI decrypt only (UEA1) */
12227                 TEST_CASE_ST(ut_setup, ut_teardown,
12228                         test_kasumi_decryption_test_case_1),
12229                 TEST_CASE_ST(ut_setup, ut_teardown,
12230                         test_kasumi_decryption_test_case_2),
12231                 TEST_CASE_ST(ut_setup, ut_teardown,
12232                         test_kasumi_decryption_test_case_3),
12233                 TEST_CASE_ST(ut_setup, ut_teardown,
12234                         test_kasumi_decryption_test_case_4),
12235                 TEST_CASE_ST(ut_setup, ut_teardown,
12236                         test_kasumi_decryption_test_case_5),
12237                 TEST_CASE_ST(ut_setup, ut_teardown,
12238                         test_kasumi_decryption_test_case_1_oop),
12239
12240                 TEST_CASE_ST(ut_setup, ut_teardown,
12241                         test_kasumi_cipher_auth_test_case_1),
12242
12243                 /** KASUMI generate auth, then encrypt (F8) */
12244                 TEST_CASE_ST(ut_setup, ut_teardown,
12245                         test_kasumi_auth_cipher_test_case_1),
12246                 TEST_CASE_ST(ut_setup, ut_teardown,
12247                         test_kasumi_auth_cipher_test_case_2),
12248                 TEST_CASE_ST(ut_setup, ut_teardown,
12249                         test_kasumi_auth_cipher_test_case_2_oop),
12250                 TEST_CASE_ST(ut_setup, ut_teardown,
12251                         test_kasumi_auth_cipher_test_case_2_sgl),
12252                 TEST_CASE_ST(ut_setup, ut_teardown,
12253                         test_kasumi_auth_cipher_test_case_2_oop_sgl),
12254
12255                 /** KASUMI decrypt (F8), then verify auth */
12256                 TEST_CASE_ST(ut_setup, ut_teardown,
12257                         test_kasumi_auth_cipher_verify_test_case_1),
12258                 TEST_CASE_ST(ut_setup, ut_teardown,
12259                         test_kasumi_auth_cipher_verify_test_case_2),
12260                 TEST_CASE_ST(ut_setup, ut_teardown,
12261                         test_kasumi_auth_cipher_verify_test_case_2_oop),
12262                 TEST_CASE_ST(ut_setup, ut_teardown,
12263                         test_kasumi_auth_cipher_verify_test_case_2_sgl),
12264                 TEST_CASE_ST(ut_setup, ut_teardown,
12265                         test_kasumi_auth_cipher_verify_test_case_2_oop_sgl),
12266
12267                 /** ESN Testcase */
12268                 TEST_CASE_ST(ut_setup, ut_teardown,
12269                         auth_encrypt_AES128CBC_HMAC_SHA1_esn_check),
12270                 TEST_CASE_ST(ut_setup, ut_teardown,
12271                         auth_decrypt_AES128CBC_HMAC_SHA1_esn_check),
12272
12273                 /** Negative tests */
12274                 TEST_CASE_ST(ut_setup, ut_teardown,
12275                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
12276                 TEST_CASE_ST(ut_setup, ut_teardown,
12277                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
12278                 TEST_CASE_ST(ut_setup, ut_teardown,
12279                         test_AES_GCM_auth_encryption_fail_iv_corrupt),
12280                 TEST_CASE_ST(ut_setup, ut_teardown,
12281                         test_AES_GCM_auth_encryption_fail_in_data_corrupt),
12282                 TEST_CASE_ST(ut_setup, ut_teardown,
12283                         test_AES_GCM_auth_encryption_fail_out_data_corrupt),
12284                 TEST_CASE_ST(ut_setup, ut_teardown,
12285                         test_AES_GCM_auth_encryption_fail_aad_len_corrupt),
12286                 TEST_CASE_ST(ut_setup, ut_teardown,
12287                         test_AES_GCM_auth_encryption_fail_aad_corrupt),
12288                 TEST_CASE_ST(ut_setup, ut_teardown,
12289                         test_AES_GCM_auth_encryption_fail_tag_corrupt),
12290                 TEST_CASE_ST(ut_setup, ut_teardown,
12291                         test_AES_GCM_auth_decryption_fail_iv_corrupt),
12292                 TEST_CASE_ST(ut_setup, ut_teardown,
12293                         test_AES_GCM_auth_decryption_fail_in_data_corrupt),
12294                 TEST_CASE_ST(ut_setup, ut_teardown,
12295                         test_AES_GCM_auth_decryption_fail_out_data_corrupt),
12296                 TEST_CASE_ST(ut_setup, ut_teardown,
12297                         test_AES_GCM_auth_decryption_fail_aad_len_corrupt),
12298                 TEST_CASE_ST(ut_setup, ut_teardown,
12299                         test_AES_GCM_auth_decryption_fail_aad_corrupt),
12300                 TEST_CASE_ST(ut_setup, ut_teardown,
12301                         test_AES_GCM_auth_decryption_fail_tag_corrupt),
12302                 TEST_CASE_ST(ut_setup, ut_teardown,
12303                         authentication_verify_AES128_GMAC_fail_data_corrupt),
12304                 TEST_CASE_ST(ut_setup, ut_teardown,
12305                         authentication_verify_AES128_GMAC_fail_tag_corrupt),
12306                 TEST_CASE_ST(ut_setup, ut_teardown,
12307                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
12308                 TEST_CASE_ST(ut_setup, ut_teardown,
12309                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
12310
12311                 /** Mixed CIPHER + HASH algorithms */
12312                 /** AUTH AES CMAC + CIPHER AES CTR */
12313                 TEST_CASE_ST(ut_setup, ut_teardown,
12314                         test_aes_cmac_aes_ctr_digest_enc_test_case_1),
12315                 TEST_CASE_ST(ut_setup, ut_teardown,
12316                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
12317                 TEST_CASE_ST(ut_setup, ut_teardown,
12318                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
12319                 TEST_CASE_ST(ut_setup, ut_teardown,
12320                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
12321                 TEST_CASE_ST(ut_setup, ut_teardown,
12322                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1),
12323                 TEST_CASE_ST(ut_setup, ut_teardown,
12324                        test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
12325                 TEST_CASE_ST(ut_setup, ut_teardown,
12326                        test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
12327                 TEST_CASE_ST(ut_setup, ut_teardown,
12328                    test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
12329
12330                 /** AUTH ZUC + CIPHER SNOW3G */
12331                 TEST_CASE_ST(ut_setup, ut_teardown,
12332                         test_auth_zuc_cipher_snow_test_case_1),
12333                 TEST_CASE_ST(ut_setup, ut_teardown,
12334                         test_verify_auth_zuc_cipher_snow_test_case_1),
12335                 /** AUTH AES CMAC + CIPHER SNOW3G */
12336                 TEST_CASE_ST(ut_setup, ut_teardown,
12337                         test_auth_aes_cmac_cipher_snow_test_case_1),
12338                 TEST_CASE_ST(ut_setup, ut_teardown,
12339                         test_verify_auth_aes_cmac_cipher_snow_test_case_1),
12340                 /** AUTH ZUC + CIPHER AES CTR */
12341                 TEST_CASE_ST(ut_setup, ut_teardown,
12342                         test_auth_zuc_cipher_aes_ctr_test_case_1),
12343                 TEST_CASE_ST(ut_setup, ut_teardown,
12344                         test_verify_auth_zuc_cipher_aes_ctr_test_case_1),
12345                 /** AUTH SNOW3G + CIPHER AES CTR */
12346                 TEST_CASE_ST(ut_setup, ut_teardown,
12347                         test_auth_snow_cipher_aes_ctr_test_case_1),
12348                 TEST_CASE_ST(ut_setup, ut_teardown,
12349                         test_verify_auth_snow_cipher_aes_ctr_test_case_1),
12350                 /** AUTH SNOW3G + CIPHER ZUC */
12351                 TEST_CASE_ST(ut_setup, ut_teardown,
12352                         test_auth_snow_cipher_zuc_test_case_1),
12353                 TEST_CASE_ST(ut_setup, ut_teardown,
12354                         test_verify_auth_snow_cipher_zuc_test_case_1),
12355                 /** AUTH AES CMAC + CIPHER ZUC */
12356                 TEST_CASE_ST(ut_setup, ut_teardown,
12357                         test_auth_aes_cmac_cipher_zuc_test_case_1),
12358                 TEST_CASE_ST(ut_setup, ut_teardown,
12359                         test_verify_auth_aes_cmac_cipher_zuc_test_case_1),
12360
12361                 /** AUTH NULL + CIPHER SNOW3G */
12362                 TEST_CASE_ST(ut_setup, ut_teardown,
12363                         test_auth_null_cipher_snow_test_case_1),
12364                 TEST_CASE_ST(ut_setup, ut_teardown,
12365                         test_verify_auth_null_cipher_snow_test_case_1),
12366                 /** AUTH NULL + CIPHER ZUC */
12367                 TEST_CASE_ST(ut_setup, ut_teardown,
12368                         test_auth_null_cipher_zuc_test_case_1),
12369                 TEST_CASE_ST(ut_setup, ut_teardown,
12370                         test_verify_auth_null_cipher_zuc_test_case_1),
12371                 /** AUTH SNOW3G + CIPHER NULL */
12372                 TEST_CASE_ST(ut_setup, ut_teardown,
12373                         test_auth_snow_cipher_null_test_case_1),
12374                 TEST_CASE_ST(ut_setup, ut_teardown,
12375                         test_verify_auth_snow_cipher_null_test_case_1),
12376                 /** AUTH ZUC + CIPHER NULL */
12377                 TEST_CASE_ST(ut_setup, ut_teardown,
12378                         test_auth_zuc_cipher_null_test_case_1),
12379                 TEST_CASE_ST(ut_setup, ut_teardown,
12380                         test_verify_auth_zuc_cipher_null_test_case_1),
12381                 /** AUTH NULL + CIPHER AES CTR */
12382                 TEST_CASE_ST(ut_setup, ut_teardown,
12383                         test_auth_null_cipher_aes_ctr_test_case_1),
12384                 TEST_CASE_ST(ut_setup, ut_teardown,
12385                         test_verify_auth_null_cipher_aes_ctr_test_case_1),
12386                 /** AUTH AES CMAC + CIPHER NULL */
12387                 TEST_CASE_ST(ut_setup, ut_teardown,
12388                         test_auth_aes_cmac_cipher_null_test_case_1),
12389                 TEST_CASE_ST(ut_setup, ut_teardown,
12390                         test_verify_auth_aes_cmac_cipher_null_test_case_1),
12391
12392 #ifdef RTE_LIBRTE_SECURITY
12393                 TEST_CASE_ST(ut_setup, ut_teardown,
12394                         test_PDCP_PROTO_all),
12395 #endif
12396                 TEST_CASES_END() /**< NULL terminate unit test array */
12397         }
12398 };
12399
12400 static struct unit_test_suite cryptodev_virtio_testsuite = {
12401         .suite_name = "Crypto VIRTIO Unit Test Suite",
12402         .setup = testsuite_setup,
12403         .teardown = testsuite_teardown,
12404         .unit_test_cases = {
12405                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
12406
12407                 TEST_CASES_END() /**< NULL terminate unit test array */
12408         }
12409 };
12410
12411 static struct unit_test_suite cryptodev_caam_jr_testsuite  = {
12412         .suite_name = "Crypto CAAM JR Unit Test Suite",
12413         .setup = testsuite_setup,
12414         .teardown = testsuite_teardown,
12415         .unit_test_cases = {
12416                 TEST_CASE_ST(ut_setup, ut_teardown,
12417                              test_device_configure_invalid_dev_id),
12418                 TEST_CASE_ST(ut_setup, ut_teardown,
12419                              test_multi_session),
12420
12421                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
12422                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
12423                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
12424                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
12425                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
12426
12427                 TEST_CASES_END() /**< NULL terminate unit test array */
12428         }
12429 };
12430
12431 static struct unit_test_suite cryptodev_armv8_testsuite  = {
12432         .suite_name = "Crypto Device ARMv8 Unit Test Suite",
12433         .setup = testsuite_setup,
12434         .teardown = testsuite_teardown,
12435         .unit_test_cases = {
12436                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
12437
12438                 /** Negative tests */
12439                 TEST_CASE_ST(ut_setup, ut_teardown,
12440                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
12441                 TEST_CASE_ST(ut_setup, ut_teardown,
12442                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
12443
12444                 TEST_CASES_END() /**< NULL terminate unit test array */
12445         }
12446 };
12447
12448 static struct unit_test_suite cryptodev_mrvl_testsuite  = {
12449         .suite_name = "Crypto Device Marvell Component Test Suite",
12450         .setup = testsuite_setup,
12451         .teardown = testsuite_teardown,
12452         .unit_test_cases = {
12453                 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
12454                 TEST_CASE_ST(ut_setup, ut_teardown,
12455                                 test_multi_session_random_usage),
12456                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
12457                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
12458                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
12459                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
12460                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
12461
12462                 /** Negative tests */
12463                 TEST_CASE_ST(ut_setup, ut_teardown,
12464                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
12465                 TEST_CASE_ST(ut_setup, ut_teardown,
12466                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
12467                 TEST_CASE_ST(ut_setup, ut_teardown,
12468                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
12469                 TEST_CASE_ST(ut_setup, ut_teardown,
12470                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
12471
12472                 TEST_CASES_END() /**< NULL terminate unit test array */
12473         }
12474 };
12475
12476 static struct unit_test_suite cryptodev_ccp_testsuite  = {
12477         .suite_name = "Crypto Device CCP Unit Test Suite",
12478         .setup = testsuite_setup,
12479         .teardown = testsuite_teardown,
12480         .unit_test_cases = {
12481                 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
12482                 TEST_CASE_ST(ut_setup, ut_teardown,
12483                                 test_multi_session_random_usage),
12484                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
12485                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
12486                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
12487                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
12488                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
12489
12490                 /** Negative tests */
12491                 TEST_CASE_ST(ut_setup, ut_teardown,
12492                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
12493                 TEST_CASE_ST(ut_setup, ut_teardown,
12494                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
12495                 TEST_CASE_ST(ut_setup, ut_teardown,
12496                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
12497                 TEST_CASE_ST(ut_setup, ut_teardown,
12498                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
12499
12500                 TEST_CASES_END() /**< NULL terminate unit test array */
12501         }
12502 };
12503
12504 static struct unit_test_suite cryptodev_octeontx_testsuite  = {
12505         .suite_name = "Crypto Device OCTEONTX Unit Test Suite",
12506         .setup = testsuite_setup,
12507         .teardown = testsuite_teardown,
12508         .unit_test_cases = {
12509                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
12510                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
12511                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
12512                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
12513                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
12514
12515                 /** AES GCM Authenticated Encryption */
12516                 TEST_CASE_ST(ut_setup, ut_teardown,
12517                         test_AES_GCM_authenticated_encryption_test_case_1),
12518                 TEST_CASE_ST(ut_setup, ut_teardown,
12519                         test_AES_GCM_authenticated_encryption_test_case_2),
12520                 TEST_CASE_ST(ut_setup, ut_teardown,
12521                         test_AES_GCM_authenticated_encryption_test_case_3),
12522                 TEST_CASE_ST(ut_setup, ut_teardown,
12523                         test_AES_GCM_authenticated_encryption_test_case_4),
12524                 TEST_CASE_ST(ut_setup, ut_teardown,
12525                         test_AES_GCM_authenticated_encryption_test_case_5),
12526                 TEST_CASE_ST(ut_setup, ut_teardown,
12527                         test_AES_GCM_authenticated_encryption_test_case_6),
12528                 TEST_CASE_ST(ut_setup, ut_teardown,
12529                         test_AES_GCM_authenticated_encryption_test_case_7),
12530
12531                 /** AES GCM Authenticated Decryption */
12532                 TEST_CASE_ST(ut_setup, ut_teardown,
12533                         test_AES_GCM_authenticated_decryption_test_case_1),
12534                 TEST_CASE_ST(ut_setup, ut_teardown,
12535                         test_AES_GCM_authenticated_decryption_test_case_2),
12536                 TEST_CASE_ST(ut_setup, ut_teardown,
12537                         test_AES_GCM_authenticated_decryption_test_case_3),
12538                 TEST_CASE_ST(ut_setup, ut_teardown,
12539                         test_AES_GCM_authenticated_decryption_test_case_4),
12540                 TEST_CASE_ST(ut_setup, ut_teardown,
12541                         test_AES_GCM_authenticated_decryption_test_case_5),
12542                 TEST_CASE_ST(ut_setup, ut_teardown,
12543                         test_AES_GCM_authenticated_decryption_test_case_6),
12544                 TEST_CASE_ST(ut_setup, ut_teardown,
12545                         test_AES_GCM_authenticated_decryption_test_case_7),
12546                 /** AES GMAC Authentication */
12547                 TEST_CASE_ST(ut_setup, ut_teardown,
12548                         test_AES_GMAC_authentication_test_case_1),
12549                 TEST_CASE_ST(ut_setup, ut_teardown,
12550                         test_AES_GMAC_authentication_verify_test_case_1),
12551                 TEST_CASE_ST(ut_setup, ut_teardown,
12552                         test_AES_GMAC_authentication_test_case_2),
12553                 TEST_CASE_ST(ut_setup, ut_teardown,
12554                         test_AES_GMAC_authentication_verify_test_case_2),
12555                 TEST_CASE_ST(ut_setup, ut_teardown,
12556                         test_AES_GMAC_authentication_test_case_3),
12557                 TEST_CASE_ST(ut_setup, ut_teardown,
12558                         test_AES_GMAC_authentication_verify_test_case_3),
12559
12560                 /** SNOW 3G encrypt only (UEA2) */
12561                 TEST_CASE_ST(ut_setup, ut_teardown,
12562                         test_snow3g_encryption_test_case_1),
12563                 TEST_CASE_ST(ut_setup, ut_teardown,
12564                         test_snow3g_encryption_test_case_2),
12565                 TEST_CASE_ST(ut_setup, ut_teardown,
12566                         test_snow3g_encryption_test_case_3),
12567                 TEST_CASE_ST(ut_setup, ut_teardown,
12568                         test_snow3g_encryption_test_case_4),
12569                 TEST_CASE_ST(ut_setup, ut_teardown,
12570                         test_snow3g_encryption_test_case_5),
12571
12572                 TEST_CASE_ST(ut_setup, ut_teardown,
12573                         test_snow3g_encryption_test_case_1_oop),
12574                 TEST_CASE_ST(ut_setup, ut_teardown,
12575                         test_snow3g_decryption_test_case_1_oop),
12576                 TEST_CASE_ST(ut_setup, ut_teardown,
12577                         test_snow3g_encryption_test_case_1_oop_sgl),
12578
12579                 /** SNOW 3G decrypt only (UEA2) */
12580                 TEST_CASE_ST(ut_setup, ut_teardown,
12581                         test_snow3g_decryption_test_case_1),
12582                 TEST_CASE_ST(ut_setup, ut_teardown,
12583                         test_snow3g_decryption_test_case_2),
12584                 TEST_CASE_ST(ut_setup, ut_teardown,
12585                         test_snow3g_decryption_test_case_3),
12586                 TEST_CASE_ST(ut_setup, ut_teardown,
12587                         test_snow3g_decryption_test_case_4),
12588                 TEST_CASE_ST(ut_setup, ut_teardown,
12589                         test_snow3g_decryption_test_case_5),
12590
12591                 TEST_CASE_ST(ut_setup, ut_teardown,
12592                         test_snow3g_hash_generate_test_case_1),
12593                 TEST_CASE_ST(ut_setup, ut_teardown,
12594                         test_snow3g_hash_generate_test_case_2),
12595                 TEST_CASE_ST(ut_setup, ut_teardown,
12596                         test_snow3g_hash_generate_test_case_3),
12597                 TEST_CASE_ST(ut_setup, ut_teardown,
12598                         test_snow3g_hash_verify_test_case_1),
12599                 TEST_CASE_ST(ut_setup, ut_teardown,
12600                         test_snow3g_hash_verify_test_case_2),
12601                 TEST_CASE_ST(ut_setup, ut_teardown,
12602                         test_snow3g_hash_verify_test_case_3),
12603
12604                 /** ZUC encrypt only (EEA3) */
12605                 TEST_CASE_ST(ut_setup, ut_teardown,
12606                         test_zuc_encryption_test_case_1),
12607                 TEST_CASE_ST(ut_setup, ut_teardown,
12608                         test_zuc_encryption_test_case_2),
12609                 TEST_CASE_ST(ut_setup, ut_teardown,
12610                         test_zuc_encryption_test_case_3),
12611                 TEST_CASE_ST(ut_setup, ut_teardown,
12612                         test_zuc_encryption_test_case_4),
12613                 TEST_CASE_ST(ut_setup, ut_teardown,
12614                         test_zuc_encryption_test_case_5),
12615                 TEST_CASE_ST(ut_setup, ut_teardown,
12616                         test_zuc_hash_generate_test_case_1),
12617                 TEST_CASE_ST(ut_setup, ut_teardown,
12618                         test_zuc_hash_generate_test_case_2),
12619                 TEST_CASE_ST(ut_setup, ut_teardown,
12620                         test_zuc_hash_generate_test_case_3),
12621                 TEST_CASE_ST(ut_setup, ut_teardown,
12622                         test_zuc_hash_generate_test_case_4),
12623                 TEST_CASE_ST(ut_setup, ut_teardown,
12624                         test_zuc_hash_generate_test_case_5),
12625                 TEST_CASE_ST(ut_setup, ut_teardown,
12626                         test_zuc_encryption_test_case_6_sgl),
12627
12628                 /** KASUMI encrypt only (UEA1) */
12629                 TEST_CASE_ST(ut_setup, ut_teardown,
12630                         test_kasumi_encryption_test_case_1),
12631                 TEST_CASE_ST(ut_setup, ut_teardown,
12632                         test_kasumi_encryption_test_case_2),
12633                 TEST_CASE_ST(ut_setup, ut_teardown,
12634                         test_kasumi_encryption_test_case_3),
12635                 TEST_CASE_ST(ut_setup, ut_teardown,
12636                         test_kasumi_encryption_test_case_4),
12637                 TEST_CASE_ST(ut_setup, ut_teardown,
12638                         test_kasumi_encryption_test_case_5),
12639                 TEST_CASE_ST(ut_setup, ut_teardown,
12640                         test_kasumi_encryption_test_case_1_sgl),
12641                 TEST_CASE_ST(ut_setup, ut_teardown,
12642                         test_kasumi_encryption_test_case_1_oop_sgl),
12643                 /** KASUMI decrypt only (UEA1) */
12644                 TEST_CASE_ST(ut_setup, ut_teardown,
12645                         test_kasumi_decryption_test_case_1),
12646                 TEST_CASE_ST(ut_setup, ut_teardown,
12647                         test_kasumi_decryption_test_case_2),
12648                 TEST_CASE_ST(ut_setup, ut_teardown,
12649                         test_kasumi_decryption_test_case_3),
12650                 TEST_CASE_ST(ut_setup, ut_teardown,
12651                         test_kasumi_decryption_test_case_4),
12652                 TEST_CASE_ST(ut_setup, ut_teardown,
12653                         test_kasumi_decryption_test_case_5),
12654
12655                 TEST_CASE_ST(ut_setup, ut_teardown,
12656                         test_kasumi_encryption_test_case_1_oop),
12657                 TEST_CASE_ST(ut_setup, ut_teardown,
12658                         test_kasumi_decryption_test_case_1_oop),
12659
12660                 /** KASUMI hash only (UIA1) */
12661                 TEST_CASE_ST(ut_setup, ut_teardown,
12662                         test_kasumi_hash_generate_test_case_1),
12663                 TEST_CASE_ST(ut_setup, ut_teardown,
12664                         test_kasumi_hash_generate_test_case_2),
12665                 TEST_CASE_ST(ut_setup, ut_teardown,
12666                         test_kasumi_hash_generate_test_case_3),
12667                 TEST_CASE_ST(ut_setup, ut_teardown,
12668                         test_kasumi_hash_generate_test_case_4),
12669                 TEST_CASE_ST(ut_setup, ut_teardown,
12670                         test_kasumi_hash_generate_test_case_5),
12671                 TEST_CASE_ST(ut_setup, ut_teardown,
12672                         test_kasumi_hash_generate_test_case_6),
12673                 TEST_CASE_ST(ut_setup, ut_teardown,
12674                         test_kasumi_hash_verify_test_case_1),
12675                 TEST_CASE_ST(ut_setup, ut_teardown,
12676                         test_kasumi_hash_verify_test_case_2),
12677                 TEST_CASE_ST(ut_setup, ut_teardown,
12678                         test_kasumi_hash_verify_test_case_3),
12679                 TEST_CASE_ST(ut_setup, ut_teardown,
12680                         test_kasumi_hash_verify_test_case_4),
12681                 TEST_CASE_ST(ut_setup, ut_teardown,
12682                         test_kasumi_hash_verify_test_case_5),
12683
12684                 /** NULL tests */
12685                 TEST_CASE_ST(ut_setup, ut_teardown,
12686                         test_null_cipher_only_operation),
12687                 TEST_CASE_ST(ut_setup, ut_teardown,
12688                         test_null_auth_only_operation),
12689                 TEST_CASE_ST(ut_setup, ut_teardown,
12690                         test_null_cipher_auth_operation),
12691                 TEST_CASE_ST(ut_setup, ut_teardown,
12692                         test_null_auth_cipher_operation),
12693
12694                 /** Negative tests */
12695                 TEST_CASE_ST(ut_setup, ut_teardown,
12696                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
12697                 TEST_CASE_ST(ut_setup, ut_teardown,
12698                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
12699                 TEST_CASE_ST(ut_setup, ut_teardown,
12700                         authentication_verify_AES128_GMAC_fail_data_corrupt),
12701                 TEST_CASE_ST(ut_setup, ut_teardown,
12702                         authentication_verify_AES128_GMAC_fail_tag_corrupt),
12703                 TEST_CASE_ST(ut_setup, ut_teardown,
12704                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
12705                 TEST_CASE_ST(ut_setup, ut_teardown,
12706                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
12707                 TEST_CASES_END() /**< NULL terminate unit test array */
12708         }
12709 };
12710
12711 static struct unit_test_suite cryptodev_nitrox_testsuite  = {
12712         .suite_name = "Crypto NITROX Unit Test Suite",
12713         .setup = testsuite_setup,
12714         .teardown = testsuite_teardown,
12715         .unit_test_cases = {
12716                 TEST_CASE_ST(ut_setup, ut_teardown,
12717                              test_device_configure_invalid_dev_id),
12718                 TEST_CASE_ST(ut_setup, ut_teardown,
12719                                 test_device_configure_invalid_queue_pair_ids),
12720                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
12721                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
12722
12723                 TEST_CASES_END() /**< NULL terminate unit test array */
12724         }
12725 };
12726
12727 static struct unit_test_suite cryptodev_octeontx2_testsuite  = {
12728         .suite_name = "Crypto Device OCTEON TX2 Unit Test Suite",
12729         .setup = testsuite_setup,
12730         .teardown = testsuite_teardown,
12731         .unit_test_cases = {
12732                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
12733                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
12734                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
12735                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
12736                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
12737
12738                 /** AES GCM Authenticated Encryption */
12739                 TEST_CASE_ST(ut_setup, ut_teardown,
12740                         test_AES_GCM_authenticated_encryption_test_case_1),
12741                 TEST_CASE_ST(ut_setup, ut_teardown,
12742                         test_AES_GCM_authenticated_encryption_test_case_2),
12743                 TEST_CASE_ST(ut_setup, ut_teardown,
12744                         test_AES_GCM_authenticated_encryption_test_case_3),
12745                 TEST_CASE_ST(ut_setup, ut_teardown,
12746                         test_AES_GCM_authenticated_encryption_test_case_4),
12747                 TEST_CASE_ST(ut_setup, ut_teardown,
12748                         test_AES_GCM_authenticated_encryption_test_case_5),
12749                 TEST_CASE_ST(ut_setup, ut_teardown,
12750                         test_AES_GCM_authenticated_encryption_test_case_6),
12751                 TEST_CASE_ST(ut_setup, ut_teardown,
12752                         test_AES_GCM_authenticated_encryption_test_case_7),
12753
12754                 /** AES GCM Authenticated Decryption */
12755                 TEST_CASE_ST(ut_setup, ut_teardown,
12756                         test_AES_GCM_authenticated_decryption_test_case_1),
12757                 TEST_CASE_ST(ut_setup, ut_teardown,
12758                         test_AES_GCM_authenticated_decryption_test_case_2),
12759                 TEST_CASE_ST(ut_setup, ut_teardown,
12760                         test_AES_GCM_authenticated_decryption_test_case_3),
12761                 TEST_CASE_ST(ut_setup, ut_teardown,
12762                         test_AES_GCM_authenticated_decryption_test_case_4),
12763                 TEST_CASE_ST(ut_setup, ut_teardown,
12764                         test_AES_GCM_authenticated_decryption_test_case_5),
12765                 TEST_CASE_ST(ut_setup, ut_teardown,
12766                         test_AES_GCM_authenticated_decryption_test_case_6),
12767                 TEST_CASE_ST(ut_setup, ut_teardown,
12768                         test_AES_GCM_authenticated_decryption_test_case_7),
12769                 /** AES GMAC Authentication */
12770                 TEST_CASE_ST(ut_setup, ut_teardown,
12771                         test_AES_GMAC_authentication_test_case_1),
12772                 TEST_CASE_ST(ut_setup, ut_teardown,
12773                         test_AES_GMAC_authentication_verify_test_case_1),
12774                 TEST_CASE_ST(ut_setup, ut_teardown,
12775                         test_AES_GMAC_authentication_test_case_2),
12776                 TEST_CASE_ST(ut_setup, ut_teardown,
12777                         test_AES_GMAC_authentication_verify_test_case_2),
12778                 TEST_CASE_ST(ut_setup, ut_teardown,
12779                         test_AES_GMAC_authentication_test_case_3),
12780                 TEST_CASE_ST(ut_setup, ut_teardown,
12781                         test_AES_GMAC_authentication_verify_test_case_3),
12782
12783                 /** SNOW 3G encrypt only (UEA2) */
12784                 TEST_CASE_ST(ut_setup, ut_teardown,
12785                         test_snow3g_encryption_test_case_1),
12786                 TEST_CASE_ST(ut_setup, ut_teardown,
12787                         test_snow3g_encryption_test_case_2),
12788                 TEST_CASE_ST(ut_setup, ut_teardown,
12789                         test_snow3g_encryption_test_case_3),
12790                 TEST_CASE_ST(ut_setup, ut_teardown,
12791                         test_snow3g_encryption_test_case_4),
12792                 TEST_CASE_ST(ut_setup, ut_teardown,
12793                         test_snow3g_encryption_test_case_5),
12794
12795                 TEST_CASE_ST(ut_setup, ut_teardown,
12796                         test_snow3g_encryption_test_case_1_oop),
12797                 TEST_CASE_ST(ut_setup, ut_teardown,
12798                         test_snow3g_decryption_test_case_1_oop),
12799                 TEST_CASE_ST(ut_setup, ut_teardown,
12800                         test_snow3g_encryption_test_case_1_oop_sgl),
12801
12802                 /** SNOW 3G decrypt only (UEA2) */
12803                 TEST_CASE_ST(ut_setup, ut_teardown,
12804                         test_snow3g_decryption_test_case_1),
12805                 TEST_CASE_ST(ut_setup, ut_teardown,
12806                         test_snow3g_decryption_test_case_2),
12807                 TEST_CASE_ST(ut_setup, ut_teardown,
12808                         test_snow3g_decryption_test_case_3),
12809                 TEST_CASE_ST(ut_setup, ut_teardown,
12810                         test_snow3g_decryption_test_case_4),
12811                 TEST_CASE_ST(ut_setup, ut_teardown,
12812                         test_snow3g_decryption_test_case_5),
12813
12814                 TEST_CASE_ST(ut_setup, ut_teardown,
12815                         test_snow3g_hash_generate_test_case_1),
12816                 TEST_CASE_ST(ut_setup, ut_teardown,
12817                         test_snow3g_hash_generate_test_case_2),
12818                 TEST_CASE_ST(ut_setup, ut_teardown,
12819                         test_snow3g_hash_generate_test_case_3),
12820                 TEST_CASE_ST(ut_setup, ut_teardown,
12821                         test_snow3g_hash_verify_test_case_1),
12822                 TEST_CASE_ST(ut_setup, ut_teardown,
12823                         test_snow3g_hash_verify_test_case_2),
12824                 TEST_CASE_ST(ut_setup, ut_teardown,
12825                         test_snow3g_hash_verify_test_case_3),
12826
12827                 /** ZUC encrypt only (EEA3) */
12828                 TEST_CASE_ST(ut_setup, ut_teardown,
12829                         test_zuc_encryption_test_case_1),
12830                 TEST_CASE_ST(ut_setup, ut_teardown,
12831                         test_zuc_encryption_test_case_2),
12832                 TEST_CASE_ST(ut_setup, ut_teardown,
12833                         test_zuc_encryption_test_case_3),
12834                 TEST_CASE_ST(ut_setup, ut_teardown,
12835                         test_zuc_encryption_test_case_4),
12836                 TEST_CASE_ST(ut_setup, ut_teardown,
12837                         test_zuc_encryption_test_case_5),
12838                 TEST_CASE_ST(ut_setup, ut_teardown,
12839                         test_zuc_hash_generate_test_case_1),
12840                 TEST_CASE_ST(ut_setup, ut_teardown,
12841                         test_zuc_hash_generate_test_case_2),
12842                 TEST_CASE_ST(ut_setup, ut_teardown,
12843                         test_zuc_hash_generate_test_case_3),
12844                 TEST_CASE_ST(ut_setup, ut_teardown,
12845                         test_zuc_hash_generate_test_case_4),
12846                 TEST_CASE_ST(ut_setup, ut_teardown,
12847                         test_zuc_hash_generate_test_case_5),
12848                 TEST_CASE_ST(ut_setup, ut_teardown,
12849                         test_zuc_encryption_test_case_6_sgl),
12850
12851                 /** KASUMI encrypt only (UEA1) */
12852                 TEST_CASE_ST(ut_setup, ut_teardown,
12853                         test_kasumi_encryption_test_case_1),
12854                 TEST_CASE_ST(ut_setup, ut_teardown,
12855                         test_kasumi_encryption_test_case_2),
12856                 TEST_CASE_ST(ut_setup, ut_teardown,
12857                         test_kasumi_encryption_test_case_3),
12858                 TEST_CASE_ST(ut_setup, ut_teardown,
12859                         test_kasumi_encryption_test_case_4),
12860                 TEST_CASE_ST(ut_setup, ut_teardown,
12861                         test_kasumi_encryption_test_case_5),
12862                 TEST_CASE_ST(ut_setup, ut_teardown,
12863                         test_kasumi_encryption_test_case_1_sgl),
12864                 TEST_CASE_ST(ut_setup, ut_teardown,
12865                         test_kasumi_encryption_test_case_1_oop_sgl),
12866                 /** KASUMI decrypt only (UEA1) */
12867                 TEST_CASE_ST(ut_setup, ut_teardown,
12868                         test_kasumi_decryption_test_case_1),
12869                 TEST_CASE_ST(ut_setup, ut_teardown,
12870                         test_kasumi_decryption_test_case_2),
12871                 TEST_CASE_ST(ut_setup, ut_teardown,
12872                         test_kasumi_decryption_test_case_3),
12873                 TEST_CASE_ST(ut_setup, ut_teardown,
12874                         test_kasumi_decryption_test_case_4),
12875                 TEST_CASE_ST(ut_setup, ut_teardown,
12876                         test_kasumi_decryption_test_case_5),
12877
12878                 TEST_CASE_ST(ut_setup, ut_teardown,
12879                         test_kasumi_encryption_test_case_1_oop),
12880                 TEST_CASE_ST(ut_setup, ut_teardown,
12881                         test_kasumi_decryption_test_case_1_oop),
12882
12883                 /** KASUMI hash only (UIA1) */
12884                 TEST_CASE_ST(ut_setup, ut_teardown,
12885                         test_kasumi_hash_generate_test_case_1),
12886                 TEST_CASE_ST(ut_setup, ut_teardown,
12887                         test_kasumi_hash_generate_test_case_2),
12888                 TEST_CASE_ST(ut_setup, ut_teardown,
12889                         test_kasumi_hash_generate_test_case_3),
12890                 TEST_CASE_ST(ut_setup, ut_teardown,
12891                         test_kasumi_hash_generate_test_case_4),
12892                 TEST_CASE_ST(ut_setup, ut_teardown,
12893                         test_kasumi_hash_generate_test_case_5),
12894                 TEST_CASE_ST(ut_setup, ut_teardown,
12895                         test_kasumi_hash_generate_test_case_6),
12896                 TEST_CASE_ST(ut_setup, ut_teardown,
12897                         test_kasumi_hash_verify_test_case_1),
12898                 TEST_CASE_ST(ut_setup, ut_teardown,
12899                         test_kasumi_hash_verify_test_case_2),
12900                 TEST_CASE_ST(ut_setup, ut_teardown,
12901                         test_kasumi_hash_verify_test_case_3),
12902                 TEST_CASE_ST(ut_setup, ut_teardown,
12903                         test_kasumi_hash_verify_test_case_4),
12904                 TEST_CASE_ST(ut_setup, ut_teardown,
12905                         test_kasumi_hash_verify_test_case_5),
12906
12907                 /** NULL tests */
12908                 TEST_CASE_ST(ut_setup, ut_teardown,
12909                         test_null_cipher_only_operation),
12910                 TEST_CASE_ST(ut_setup, ut_teardown,
12911                         test_null_auth_only_operation),
12912                 TEST_CASE_ST(ut_setup, ut_teardown,
12913                         test_null_cipher_auth_operation),
12914                 TEST_CASE_ST(ut_setup, ut_teardown,
12915                         test_null_auth_cipher_operation),
12916
12917                 /** Negative tests */
12918                 TEST_CASE_ST(ut_setup, ut_teardown,
12919                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
12920                 TEST_CASE_ST(ut_setup, ut_teardown,
12921                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
12922                 TEST_CASE_ST(ut_setup, ut_teardown,
12923                         authentication_verify_AES128_GMAC_fail_data_corrupt),
12924                 TEST_CASE_ST(ut_setup, ut_teardown,
12925                         authentication_verify_AES128_GMAC_fail_tag_corrupt),
12926                 TEST_CASE_ST(ut_setup, ut_teardown,
12927                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
12928                 TEST_CASE_ST(ut_setup, ut_teardown,
12929                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
12930                 TEST_CASES_END() /**< NULL terminate unit test array */
12931         }
12932 };
12933
12934 static int
12935 test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/)
12936 {
12937         gbl_driver_id = rte_cryptodev_driver_id_get(
12938                         RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
12939
12940         if (gbl_driver_id == -1) {
12941                 RTE_LOG(ERR, USER1, "QAT PMD must be loaded. Check that both "
12942                 "CONFIG_RTE_LIBRTE_PMD_QAT and CONFIG_RTE_LIBRTE_PMD_QAT_SYM "
12943                 "are enabled in config file to run this testsuite.\n");
12944                 return TEST_SKIPPED;
12945         }
12946
12947         return unit_test_suite_runner(&cryptodev_testsuite);
12948 }
12949
12950 static int
12951 test_cryptodev_virtio(void /*argv __rte_unused, int argc __rte_unused*/)
12952 {
12953         gbl_driver_id = rte_cryptodev_driver_id_get(
12954                         RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD));
12955
12956         if (gbl_driver_id == -1) {
12957                 RTE_LOG(ERR, USER1, "VIRTIO PMD must be loaded. Check if "
12958                                 "CONFIG_RTE_LIBRTE_PMD_VIRTIO_CRYPTO is enabled "
12959                                 "in config file to run this testsuite.\n");
12960                 return TEST_FAILED;
12961         }
12962
12963         return unit_test_suite_runner(&cryptodev_virtio_testsuite);
12964 }
12965
12966 static int
12967 test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/)
12968 {
12969         gbl_driver_id = rte_cryptodev_driver_id_get(
12970                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
12971
12972         if (gbl_driver_id == -1) {
12973                 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded. Check if "
12974                                 "CONFIG_RTE_LIBRTE_PMD_AESNI_MB is enabled "
12975                                 "in config file to run this testsuite.\n");
12976                 return TEST_SKIPPED;
12977         }
12978
12979         return unit_test_suite_runner(&cryptodev_testsuite);
12980 }
12981
12982 static int
12983 test_cryptodev_cpu_aesni_mb(void)
12984 {
12985         int32_t rc;
12986         enum rte_security_session_action_type at;
12987
12988         gbl_driver_id = rte_cryptodev_driver_id_get(
12989                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
12990
12991         if (gbl_driver_id == -1) {
12992                 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded. Check if "
12993                                 "CONFIG_RTE_LIBRTE_PMD_AESNI_MB is enabled "
12994                                 "in config file to run this testsuite.\n");
12995                 return TEST_SKIPPED;
12996         }
12997
12998         at = gbl_action_type;
12999         gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
13000         rc = unit_test_suite_runner(&cryptodev_testsuite);
13001         gbl_action_type = at;
13002         return rc;
13003 }
13004
13005 static int
13006 test_cryptodev_openssl(void)
13007 {
13008         gbl_driver_id = rte_cryptodev_driver_id_get(
13009                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
13010
13011         if (gbl_driver_id == -1) {
13012                 RTE_LOG(ERR, USER1, "OPENSSL PMD must be loaded. Check if "
13013                                 "CONFIG_RTE_LIBRTE_PMD_OPENSSL is enabled "
13014                                 "in config file to run this testsuite.\n");
13015                 return TEST_SKIPPED;
13016         }
13017
13018         return unit_test_suite_runner(&cryptodev_testsuite);
13019 }
13020
13021 static int
13022 test_cryptodev_aesni_gcm(void)
13023 {
13024         gbl_driver_id = rte_cryptodev_driver_id_get(
13025                         RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
13026
13027         if (gbl_driver_id == -1) {
13028                 RTE_LOG(ERR, USER1, "AESNI GCM PMD must be loaded. Check if "
13029                                 "CONFIG_RTE_LIBRTE_PMD_AESNI_GCM is enabled "
13030                                 "in config file to run this testsuite.\n");
13031                 return TEST_SKIPPED;
13032         }
13033
13034         return unit_test_suite_runner(&cryptodev_testsuite);
13035 }
13036
13037 static int
13038 test_cryptodev_cpu_aesni_gcm(void)
13039 {
13040         int32_t rc;
13041         enum rte_security_session_action_type at;
13042
13043         gbl_driver_id = rte_cryptodev_driver_id_get(
13044                         RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
13045
13046         if (gbl_driver_id == -1) {
13047                 RTE_LOG(ERR, USER1, "AESNI GCM PMD must be loaded. Check if "
13048                                 "CONFIG_RTE_LIBRTE_PMD_AESNI_GCM is enabled "
13049                                 "in config file to run this testsuite.\n");
13050                 return TEST_SKIPPED;
13051         }
13052
13053         at = gbl_action_type;
13054         gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
13055         rc = unit_test_suite_runner(&cryptodev_testsuite);
13056         gbl_action_type = at;
13057         return rc;
13058 }
13059
13060 static int
13061 test_cryptodev_null(void)
13062 {
13063         gbl_driver_id = rte_cryptodev_driver_id_get(
13064                         RTE_STR(CRYPTODEV_NAME_NULL_PMD));
13065
13066         if (gbl_driver_id == -1) {
13067                 RTE_LOG(ERR, USER1, "NULL PMD must be loaded. Check if "
13068                                 "CONFIG_RTE_LIBRTE_PMD_NULL is enabled "
13069                                 "in config file to run this testsuite.\n");
13070                 return TEST_SKIPPED;
13071         }
13072
13073         return unit_test_suite_runner(&cryptodev_testsuite);
13074 }
13075
13076 static int
13077 test_cryptodev_sw_snow3g(void /*argv __rte_unused, int argc __rte_unused*/)
13078 {
13079         gbl_driver_id = rte_cryptodev_driver_id_get(
13080                         RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
13081
13082         if (gbl_driver_id == -1) {
13083                 RTE_LOG(ERR, USER1, "SNOW3G PMD must be loaded. Check if "
13084                                 "CONFIG_RTE_LIBRTE_PMD_SNOW3G is enabled "
13085                                 "in config file to run this testsuite.\n");
13086                 return TEST_SKIPPED;
13087         }
13088
13089         return unit_test_suite_runner(&cryptodev_testsuite);
13090 }
13091
13092 static int
13093 test_cryptodev_sw_kasumi(void /*argv __rte_unused, int argc __rte_unused*/)
13094 {
13095         gbl_driver_id = rte_cryptodev_driver_id_get(
13096                         RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
13097
13098         if (gbl_driver_id == -1) {
13099                 RTE_LOG(ERR, USER1, "ZUC PMD must be loaded. Check if "
13100                                 "CONFIG_RTE_LIBRTE_PMD_KASUMI is enabled "
13101                                 "in config file to run this testsuite.\n");
13102                 return TEST_SKIPPED;
13103         }
13104
13105         return unit_test_suite_runner(&cryptodev_testsuite);
13106 }
13107
13108 static int
13109 test_cryptodev_sw_zuc(void /*argv __rte_unused, int argc __rte_unused*/)
13110 {
13111         gbl_driver_id = rte_cryptodev_driver_id_get(
13112                         RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
13113
13114         if (gbl_driver_id == -1) {
13115                 RTE_LOG(ERR, USER1, "ZUC PMD must be loaded. Check if "
13116                                 "CONFIG_RTE_LIBRTE_PMD_ZUC is enabled "
13117                                 "in config file to run this testsuite.\n");
13118                 return TEST_SKIPPED;
13119         }
13120
13121         return unit_test_suite_runner(&cryptodev_testsuite);
13122 }
13123
13124 static int
13125 test_cryptodev_armv8(void)
13126 {
13127         gbl_driver_id = rte_cryptodev_driver_id_get(
13128                         RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
13129
13130         if (gbl_driver_id == -1) {
13131                 RTE_LOG(ERR, USER1, "ARMV8 PMD must be loaded. Check if "
13132                                 "CONFIG_RTE_LIBRTE_PMD_ARMV8 is enabled "
13133                                 "in config file to run this testsuite.\n");
13134                 return TEST_SKIPPED;
13135         }
13136
13137         return unit_test_suite_runner(&cryptodev_armv8_testsuite);
13138 }
13139
13140 static int
13141 test_cryptodev_mrvl(void)
13142 {
13143         gbl_driver_id = rte_cryptodev_driver_id_get(
13144                         RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
13145
13146         if (gbl_driver_id == -1) {
13147                 RTE_LOG(ERR, USER1, "MVSAM PMD must be loaded. Check if "
13148                                 "CONFIG_RTE_LIBRTE_PMD_MVSAM_CRYPTO is enabled "
13149                                 "in config file to run this testsuite.\n");
13150                 return TEST_SKIPPED;
13151         }
13152
13153         return unit_test_suite_runner(&cryptodev_mrvl_testsuite);
13154 }
13155
13156 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
13157
13158 static int
13159 test_cryptodev_scheduler(void /*argv __rte_unused, int argc __rte_unused*/)
13160 {
13161         gbl_driver_id = rte_cryptodev_driver_id_get(
13162                         RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
13163
13164         if (gbl_driver_id == -1) {
13165                 RTE_LOG(ERR, USER1, "SCHEDULER PMD must be loaded. Check if "
13166                                 "CONFIG_RTE_LIBRTE_PMD_SCHEDULER is enabled "
13167                                 "in config file to run this testsuite.\n");
13168                 return TEST_SKIPPED;
13169         }
13170
13171         if (rte_cryptodev_driver_id_get(
13172                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) == -1) {
13173                 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_MB must be"
13174                         " enabled in config file to run this testsuite.\n");
13175                 return TEST_SKIPPED;
13176 }
13177         return unit_test_suite_runner(&cryptodev_scheduler_testsuite);
13178 }
13179
13180 REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler);
13181
13182 #endif
13183
13184 static int
13185 test_cryptodev_dpaa2_sec(void /*argv __rte_unused, int argc __rte_unused*/)
13186 {
13187         gbl_driver_id = rte_cryptodev_driver_id_get(
13188                         RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
13189
13190         if (gbl_driver_id == -1) {
13191                 RTE_LOG(ERR, USER1, "DPAA2 SEC PMD must be loaded. Check if "
13192                                 "CONFIG_RTE_LIBRTE_PMD_DPAA2_SEC is enabled "
13193                                 "in config file to run this testsuite.\n");
13194                 return TEST_SKIPPED;
13195         }
13196
13197         return unit_test_suite_runner(&cryptodev_testsuite);
13198 }
13199
13200 static int
13201 test_cryptodev_dpaa_sec(void /*argv __rte_unused, int argc __rte_unused*/)
13202 {
13203         gbl_driver_id = rte_cryptodev_driver_id_get(
13204                         RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD));
13205
13206         if (gbl_driver_id == -1) {
13207                 RTE_LOG(ERR, USER1, "DPAA SEC PMD must be loaded. Check if "
13208                                 "CONFIG_RTE_LIBRTE_PMD_DPAA_SEC is enabled "
13209                                 "in config file to run this testsuite.\n");
13210                 return TEST_SKIPPED;
13211         }
13212
13213         return unit_test_suite_runner(&cryptodev_testsuite);
13214 }
13215
13216 static int
13217 test_cryptodev_ccp(void)
13218 {
13219         gbl_driver_id = rte_cryptodev_driver_id_get(
13220                         RTE_STR(CRYPTODEV_NAME_CCP_PMD));
13221
13222         if (gbl_driver_id == -1) {
13223                 RTE_LOG(ERR, USER1, "CCP PMD must be loaded. Check if "
13224                                 "CONFIG_RTE_LIBRTE_PMD_CCP is enabled "
13225                                 "in config file to run this testsuite.\n");
13226                 return TEST_FAILED;
13227         }
13228
13229         return unit_test_suite_runner(&cryptodev_ccp_testsuite);
13230 }
13231
13232 static int
13233 test_cryptodev_octeontx(void)
13234 {
13235         gbl_driver_id = rte_cryptodev_driver_id_get(
13236                         RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD));
13237         if (gbl_driver_id == -1) {
13238                 RTE_LOG(ERR, USER1, "OCTEONTX PMD must be loaded. Check if "
13239                                 "CONFIG_RTE_LIBRTE_PMD_OCTEONTX_CRYPTO is "
13240                                 "enabled in config file to run this "
13241                                 "testsuite.\n");
13242                 return TEST_FAILED;
13243         }
13244         return unit_test_suite_runner(&cryptodev_octeontx_testsuite);
13245 }
13246
13247 static int
13248 test_cryptodev_octeontx2(void)
13249 {
13250         gbl_driver_id = rte_cryptodev_driver_id_get(
13251                         RTE_STR(CRYPTODEV_NAME_OCTEONTX2_PMD));
13252         if (gbl_driver_id == -1) {
13253                 RTE_LOG(ERR, USER1, "OCTEON TX2 PMD must be loaded. Check if "
13254                                 "CONFIG_RTE_LIBRTE_PMD_OCTEONTX2_CRYPTO is "
13255                                 "enabled in config file to run this "
13256                                 "testsuite.\n");
13257                 return TEST_FAILED;
13258         }
13259         return unit_test_suite_runner(&cryptodev_octeontx2_testsuite);
13260 }
13261
13262 static int
13263 test_cryptodev_caam_jr(void /*argv __rte_unused, int argc __rte_unused*/)
13264 {
13265         gbl_driver_id = rte_cryptodev_driver_id_get(
13266                         RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD));
13267
13268         if (gbl_driver_id == -1) {
13269                 RTE_LOG(ERR, USER1, "CAAM_JR PMD must be loaded. Check if "
13270                                 "CONFIG_RTE_LIBRTE_PMD_CAAM_JR is enabled "
13271                                 "in config file to run this testsuite.\n");
13272                 return TEST_FAILED;
13273         }
13274
13275         return unit_test_suite_runner(&cryptodev_caam_jr_testsuite);
13276 }
13277
13278 static int
13279 test_cryptodev_nitrox(void)
13280 {
13281         gbl_driver_id = rte_cryptodev_driver_id_get(
13282                         RTE_STR(CRYPTODEV_NAME_NITROX_PMD));
13283
13284         if (gbl_driver_id == -1) {
13285                 RTE_LOG(ERR, USER1, "NITROX PMD must be loaded. Check if "
13286                                 "CONFIG_RTE_LIBRTE_PMD_NITROX is enabled "
13287                                 "in config file to run this testsuite.\n");
13288                 return TEST_FAILED;
13289         }
13290
13291         return unit_test_suite_runner(&cryptodev_nitrox_testsuite);
13292 }
13293
13294 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
13295 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
13296 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_mb_autotest,
13297         test_cryptodev_cpu_aesni_mb);
13298 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl);
13299 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm);
13300 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_gcm_autotest,
13301         test_cryptodev_cpu_aesni_gcm);
13302 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null);
13303 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
13304 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);
13305 REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc);
13306 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_autotest, test_cryptodev_armv8);
13307 REGISTER_TEST_COMMAND(cryptodev_sw_mvsam_autotest, test_cryptodev_mrvl);
13308 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_autotest, test_cryptodev_dpaa2_sec);
13309 REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_autotest, test_cryptodev_dpaa_sec);
13310 REGISTER_TEST_COMMAND(cryptodev_ccp_autotest, test_cryptodev_ccp);
13311 REGISTER_TEST_COMMAND(cryptodev_virtio_autotest, test_cryptodev_virtio);
13312 REGISTER_TEST_COMMAND(cryptodev_octeontx_autotest, test_cryptodev_octeontx);
13313 REGISTER_TEST_COMMAND(cryptodev_octeontx2_autotest, test_cryptodev_octeontx2);
13314 REGISTER_TEST_COMMAND(cryptodev_caam_jr_autotest, test_cryptodev_caam_jr);
13315 REGISTER_TEST_COMMAND(cryptodev_nitrox_autotest, test_cryptodev_nitrox);