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