test/test/test_cryptodev.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2015-2017 Intel Corporation. All rights reserved.
   5  *
   6  *   Redistribution and use in source and binary forms, with or without
   7  *   modification, are permitted provided that the following conditions
   8  *   are met:
   9  *
  10  *       * Redistributions of source code must retain the above copyright
  11  *         notice, this list of conditions and the following disclaimer.
  12  *       * Redistributions in binary form must reproduce the above copyright
  13  *         notice, this list of conditions and the following disclaimer in
  14  *         the documentation and/or other materials provided with the
  15  *         distribution.
  16  *       * Neither the name of Intel Corporation nor the names of its
  17  *         contributors may be used to endorse or promote products derived
  18  *         from this software without specific prior written permission.
  19  *
  20  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  23  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  24  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  25  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  26  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  30  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 #include <rte_common.h>
  34 #include <rte_hexdump.h>
  35 #include <rte_mbuf.h>
  36 #include <rte_malloc.h>
  37 #include <rte_memcpy.h>
  38
  39 #include <rte_crypto.h>
  40 #include <rte_cryptodev.h>
  41 #include <rte_cryptodev_pmd.h>
  42
  43 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
  44 #include <rte_cryptodev_scheduler.h>
  45 #include <rte_cryptodev_scheduler_operations.h>
  46 #endif
  47
  48 #include "test.h"
  49 #include "test_cryptodev.h"
  50
  51 #include "test_cryptodev_blockcipher.h"
  52 #include "test_cryptodev_aes_test_vectors.h"
  53 #include "test_cryptodev_des_test_vectors.h"
  54 #include "test_cryptodev_hash_test_vectors.h"
  55 #include "test_cryptodev_kasumi_test_vectors.h"
  56 #include "test_cryptodev_kasumi_hash_test_vectors.h"
  57 #include "test_cryptodev_snow3g_test_vectors.h"
  58 #include "test_cryptodev_snow3g_hash_test_vectors.h"
  59 #include "test_cryptodev_zuc_test_vectors.h"
  60 #include "test_cryptodev_zuc_hash_test_vectors.h"
  61 #include "test_cryptodev_gcm_test_vectors.h"
  62 #include "test_cryptodev_hmac_test_vectors.h"
  63
  64 static enum rte_cryptodev_type gbl_cryptodev_type;
  65
  66 struct crypto_testsuite_params {
  67         struct rte_mempool *mbuf_pool;
  68         struct rte_mempool *large_mbuf_pool;
  69         struct rte_mempool *op_mpool;
  70         struct rte_cryptodev_config conf;
  71         struct rte_cryptodev_qp_conf qp_conf;
  72
  73         uint8_t valid_devs[RTE_CRYPTO_MAX_DEVS];
  74         uint8_t valid_dev_count;
  75 };
  76
  77 struct crypto_unittest_params {
  78         struct rte_crypto_sym_xform cipher_xform;
  79         struct rte_crypto_sym_xform auth_xform;
  80
  81         struct rte_cryptodev_sym_session *sess;
  82
  83         struct rte_crypto_op *op;
  84
  85         struct rte_mbuf *obuf, *ibuf;
  86
  87         uint8_t *digest;
  88 };
  89
  90 #define ALIGN_POW2_ROUNDUP(num, align) \
  91         (((num) + (align) - 1) & ~((align) - 1))
  92
  93 /*
  94  * Forward declarations.
  95  */
  96 static int
  97 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
  98                 struct crypto_unittest_params *ut_params, uint8_t *cipher_key,
  99                 uint8_t *hmac_key);
 100
 101 static int
 102 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
 103                 struct crypto_unittest_params *ut_params,
 104                 struct crypto_testsuite_params *ts_param,
 105                 const uint8_t *cipher,
 106                 const uint8_t *digest,
 107                 const uint8_t *iv);
 108
 109 static struct rte_mbuf *
 110 setup_test_string(struct rte_mempool *mpool,
 111                 const char *string, size_t len, uint8_t blocksize)
 112 {
 113         struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
 114         size_t t_len = len - (blocksize ? (len % blocksize) : 0);
 115
 116         memset(m->buf_addr, 0, m->buf_len);
 117         if (m) {
 118                 char *dst = rte_pktmbuf_append(m, t_len);
 119
 120                 if (!dst) {
 121                         rte_pktmbuf_free(m);
 122                         return NULL;
 123                 }
 124                 if (string != NULL)
 125                         rte_memcpy(dst, string, t_len);
 126                 else
 127                         memset(dst, 0, t_len);
 128         }
 129
 130         return m;
 131 }
 132
 133 /* Get number of bytes in X bits (rounding up) */
 134 static uint32_t
 135 ceil_byte_length(uint32_t num_bits)
 136 {
 137         if (num_bits % 8)
 138                 return ((num_bits >> 3) + 1);
 139         else
 140                 return (num_bits >> 3);
 141 }
 142
 143 static struct rte_crypto_op *
 144 process_crypto_request(uint8_t dev_id, struct rte_crypto_op *op)
 145 {
 146         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
 147                 printf("Error sending packet for encryption");
 148                 return NULL;
 149         }
 150
 151         op = NULL;
 152
 153         while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0)
 154                 rte_pause();
 155
 156         return op;
 157 }
 158
 159 static struct crypto_testsuite_params testsuite_params = { NULL };
 160 static struct crypto_unittest_params unittest_params;
 161
 162 static int
 163 testsuite_setup(void)
 164 {
 165         struct crypto_testsuite_params *ts_params = &testsuite_params;
 166         struct rte_cryptodev_info info;
 167         uint32_t i = 0, nb_devs, dev_id;
 168         int ret;
 169         uint16_t qp_id;
 170
 171         memset(ts_params, 0, sizeof(*ts_params));
 172
 173         ts_params->mbuf_pool = rte_mempool_lookup("CRYPTO_MBUFPOOL");
 174         if (ts_params->mbuf_pool == NULL) {
 175                 /* Not already created so create */
 176                 ts_params->mbuf_pool = rte_pktmbuf_pool_create(
 177                                 "CRYPTO_MBUFPOOL",
 178                                 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
 179                                 rte_socket_id());
 180                 if (ts_params->mbuf_pool == NULL) {
 181                         RTE_LOG(ERR, USER1, "Can't create CRYPTO_MBUFPOOL\n");
 182                         return TEST_FAILED;
 183                 }
 184         }
 185
 186         ts_params->large_mbuf_pool = rte_mempool_lookup(
 187                         "CRYPTO_LARGE_MBUFPOOL");
 188         if (ts_params->large_mbuf_pool == NULL) {
 189                 /* Not already created so create */
 190                 ts_params->large_mbuf_pool = rte_pktmbuf_pool_create(
 191                                 "CRYPTO_LARGE_MBUFPOOL",
 192                                 1, 0, 0, UINT16_MAX,
 193                                 rte_socket_id());
 194                 if (ts_params->large_mbuf_pool == NULL) {
 195                         RTE_LOG(ERR, USER1,
 196                                 "Can't create CRYPTO_LARGE_MBUFPOOL\n");
 197                         return TEST_FAILED;
 198                 }
 199         }
 200
 201         ts_params->op_mpool = rte_crypto_op_pool_create(
 202                         "MBUF_CRYPTO_SYM_OP_POOL",
 203                         RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 204                         NUM_MBUFS, MBUF_CACHE_SIZE,
 205                         DEFAULT_NUM_XFORMS *
 206                         sizeof(struct rte_crypto_sym_xform),
 207                         rte_socket_id());
 208         if (ts_params->op_mpool == NULL) {
 209                 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
 210                 return TEST_FAILED;
 211         }
 212
 213         /* Create 2 AESNI MB devices if required */
 214         if (gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD) {
 215 #ifndef RTE_LIBRTE_PMD_AESNI_MB
 216                 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_MB must be"
 217                         " enabled in config file to run this testsuite.\n");
 218                 return TEST_FAILED;
 219 #endif
 220                 nb_devs = rte_cryptodev_count_devtype(
 221                                 RTE_CRYPTODEV_AESNI_MB_PMD);
 222                 if (nb_devs < 2) {
 223                         for (i = nb_devs; i < 2; i++) {
 224                                 ret = rte_eal_vdev_init(
 225                                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL);
 226
 227                                 TEST_ASSERT(ret == 0,
 228                                         "Failed to create instance %u of"
 229                                         " pmd : %s",
 230                                         i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
 231                         }
 232                 }
 233         }
 234
 235         /* Create 2 AESNI GCM devices if required */
 236         if (gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_GCM_PMD) {
 237 #ifndef RTE_LIBRTE_PMD_AESNI_GCM
 238                 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_GCM must be"
 239                         " enabled in config file to run this testsuite.\n");
 240                 return TEST_FAILED;
 241 #endif
 242                 nb_devs = rte_cryptodev_count_devtype(
 243                                 RTE_CRYPTODEV_AESNI_GCM_PMD);
 244                 if (nb_devs < 2) {
 245                         for (i = nb_devs; i < 2; i++) {
 246                                 TEST_ASSERT_SUCCESS(rte_eal_vdev_init(
 247                                         RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD), NULL),
 248                                         "Failed to create instance %u of"
 249                                         " pmd : %s",
 250                                         i, RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
 251                         }
 252                 }
 253         }
 254
 255         /* Create 2 SNOW 3G devices if required */
 256         if (gbl_cryptodev_type == RTE_CRYPTODEV_SNOW3G_PMD) {
 257 #ifndef RTE_LIBRTE_PMD_SNOW3G
 258                 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_SNOW3G must be"
 259                         " enabled in config file to run this testsuite.\n");
 260                 return TEST_FAILED;
 261 #endif
 262                 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_SNOW3G_PMD);
 263                 if (nb_devs < 2) {
 264                         for (i = nb_devs; i < 2; i++) {
 265                                 TEST_ASSERT_SUCCESS(rte_eal_vdev_init(
 266                                         RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD), NULL),
 267                                         "Failed to create instance %u of"
 268                                         " pmd : %s",
 269                                         i, RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
 270                         }
 271                 }
 272         }
 273
 274         /* Create 2 KASUMI devices if required */
 275         if (gbl_cryptodev_type == RTE_CRYPTODEV_KASUMI_PMD) {
 276 #ifndef RTE_LIBRTE_PMD_KASUMI
 277                 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_KASUMI must be"
 278                         " enabled in config file to run this testsuite.\n");
 279                 return TEST_FAILED;
 280 #endif
 281                 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_KASUMI_PMD);
 282                 if (nb_devs < 2) {
 283                         for (i = nb_devs; i < 2; i++) {
 284                                 TEST_ASSERT_SUCCESS(rte_eal_vdev_init(
 285                                         RTE_STR(CRYPTODEV_NAME_KASUMI_PMD), NULL),
 286                                         "Failed to create instance %u of"
 287                                         " pmd : %s",
 288                                         i, RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
 289                         }
 290                 }
 291         }
 292
 293         /* Create 2 ZUC devices if required */
 294         if (gbl_cryptodev_type == RTE_CRYPTODEV_ZUC_PMD) {
 295 #ifndef RTE_LIBRTE_PMD_ZUC
 296                 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_ZUC must be"
 297                         " enabled in config file to run this testsuite.\n");
 298                 return TEST_FAILED;
 299 #endif
 300                 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_ZUC_PMD);
 301                 if (nb_devs < 2) {
 302                         for (i = nb_devs; i < 2; i++) {
 303                                 TEST_ASSERT_SUCCESS(rte_eal_vdev_init(
 304                                         RTE_STR(CRYPTODEV_NAME_ZUC_PMD), NULL),
 305                                         "Failed to create instance %u of"
 306                                         " pmd : %s",
 307                                         i, RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
 308                         }
 309                 }
 310         }
 311
 312         /* Create 2 NULL devices if required */
 313         if (gbl_cryptodev_type == RTE_CRYPTODEV_NULL_PMD) {
 314 #ifndef RTE_LIBRTE_PMD_NULL_CRYPTO
 315                 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_NULL_CRYPTO must be"
 316                         " enabled in config file to run this testsuite.\n");
 317                 return TEST_FAILED;
 318 #endif
 319                 nb_devs = rte_cryptodev_count_devtype(
 320                                 RTE_CRYPTODEV_NULL_PMD);
 321                 if (nb_devs < 2) {
 322                         for (i = nb_devs; i < 2; i++) {
 323                                 int dev_id = rte_eal_vdev_init(
 324                                         RTE_STR(CRYPTODEV_NAME_NULL_PMD), NULL);
 325
 326                                 TEST_ASSERT(dev_id >= 0,
 327                                         "Failed to create instance %u of"
 328                                         " pmd : %s",
 329                                         i, RTE_STR(CRYPTODEV_NAME_NULL_PMD));
 330                         }
 331                 }
 332         }
 333
 334         /* Create 2 OPENSSL devices if required */
 335         if (gbl_cryptodev_type == RTE_CRYPTODEV_OPENSSL_PMD) {
 336 #ifndef RTE_LIBRTE_PMD_OPENSSL
 337                 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_OPENSSL must be"
 338                         " enabled in config file to run this testsuite.\n");
 339                 return TEST_FAILED;
 340 #endif
 341                 nb_devs = rte_cryptodev_count_devtype(
 342                                 RTE_CRYPTODEV_OPENSSL_PMD);
 343                 if (nb_devs < 2) {
 344                         for (i = nb_devs; i < 2; i++) {
 345                                 ret = rte_eal_vdev_init(
 346                                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD),
 347                                         NULL);
 348
 349                                 TEST_ASSERT(ret == 0, "Failed to create "
 350                                         "instance %u of pmd : %s", i,
 351                                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
 352                         }
 353                 }
 354         }
 355
 356         /* Create 2 ARMv8 devices if required */
 357         if (gbl_cryptodev_type == RTE_CRYPTODEV_ARMV8_PMD) {
 358 #ifndef RTE_LIBRTE_PMD_ARMV8_CRYPTO
 359                 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_ARMV8_CRYPTO must be"
 360                         " enabled in config file to run this testsuite.\n");
 361                 return TEST_FAILED;
 362 #endif
 363                 nb_devs = rte_cryptodev_count_devtype(
 364                                 RTE_CRYPTODEV_ARMV8_PMD);
 365                 if (nb_devs < 2) {
 366                         for (i = nb_devs; i < 2; i++) {
 367                                 ret = rte_eal_vdev_init(
 368                                         RTE_STR(CRYPTODEV_NAME_ARMV8_PMD),
 369                                         NULL);
 370
 371                                 TEST_ASSERT(ret == 0, "Failed to create "
 372                                         "instance %u of pmd : %s", i,
 373                                         RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
 374                         }
 375                 }
 376         }
 377
 378 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
 379         if (gbl_cryptodev_type == RTE_CRYPTODEV_SCHEDULER_PMD) {
 380
 381 #ifndef RTE_LIBRTE_PMD_AESNI_MB
 382                 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_MB must be"
 383                         " enabled in config file to run this testsuite.\n");
 384                 return TEST_FAILED;
 385 #endif
 386                 nb_devs = rte_cryptodev_count_devtype(
 387                                 RTE_CRYPTODEV_SCHEDULER_PMD);
 388                 if (nb_devs < 1) {
 389                         ret = rte_eal_vdev_init(
 390                                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),
 391                                 NULL);
 392
 393                         TEST_ASSERT(ret == 0,
 394                                 "Failed to create instance %u of"
 395                                 " pmd : %s",
 396                                 i, RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
 397                 }
 398         }
 399 #endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
 400
 401 #ifndef RTE_LIBRTE_PMD_QAT
 402         if (gbl_cryptodev_type == RTE_CRYPTODEV_QAT_SYM_PMD) {
 403                 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_QAT must be enabled "
 404                                 "in config file to run this testsuite.\n");
 405                 return TEST_FAILED;
 406         }
 407 #endif
 408
 409         nb_devs = rte_cryptodev_count();
 410         if (nb_devs < 1) {
 411                 RTE_LOG(ERR, USER1, "No crypto devices found?\n");
 412                 return TEST_FAILED;
 413         }
 414
 415         /* Create list of valid crypto devs */
 416         for (i = 0; i < nb_devs; i++) {
 417                 rte_cryptodev_info_get(i, &info);
 418                 if (info.dev_type == gbl_cryptodev_type)
 419                         ts_params->valid_devs[ts_params->valid_dev_count++] = i;
 420         }
 421
 422         if (ts_params->valid_dev_count < 1)
 423                 return TEST_FAILED;
 424
 425         /* Set up all the qps on the first of the valid devices found */
 426
 427         dev_id = ts_params->valid_devs[0];
 428
 429         rte_cryptodev_info_get(dev_id, &info);
 430
 431         ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
 432         ts_params->conf.socket_id = SOCKET_ID_ANY;
 433         ts_params->conf.session_mp.nb_objs = info.sym.max_nb_sessions;
 434
 435         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id,
 436                         &ts_params->conf),
 437                         "Failed to configure cryptodev %u with %u qps",
 438                         dev_id, ts_params->conf.nb_queue_pairs);
 439
 440         ts_params->qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
 441
 442         for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) {
 443                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 444                         dev_id, qp_id, &ts_params->qp_conf,
 445                         rte_cryptodev_socket_id(dev_id)),
 446                         "Failed to setup queue pair %u on cryptodev %u",
 447                         qp_id, dev_id);
 448         }
 449
 450         return TEST_SUCCESS;
 451 }
 452
 453 static void
 454 testsuite_teardown(void)
 455 {
 456         struct crypto_testsuite_params *ts_params = &testsuite_params;
 457
 458         if (ts_params->mbuf_pool != NULL) {
 459                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
 460                 rte_mempool_avail_count(ts_params->mbuf_pool));
 461         }
 462
 463         if (ts_params->op_mpool != NULL) {
 464                 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n",
 465                 rte_mempool_avail_count(ts_params->op_mpool));
 466         }
 467
 468 }
 469
 470 static int
 471 ut_setup(void)
 472 {
 473         struct crypto_testsuite_params *ts_params = &testsuite_params;
 474         struct crypto_unittest_params *ut_params = &unittest_params;
 475
 476         uint16_t qp_id;
 477
 478         /* Clear unit test parameters before running test */
 479         memset(ut_params, 0, sizeof(*ut_params));
 480
 481         /* Reconfigure device to default parameters */
 482         ts_params->conf.socket_id = SOCKET_ID_ANY;
 483         ts_params->conf.session_mp.nb_objs = DEFAULT_NUM_OPS_INFLIGHT;
 484
 485         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 486                         &ts_params->conf),
 487                         "Failed to configure cryptodev %u",
 488                         ts_params->valid_devs[0]);
 489
 490         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
 491                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 492                         ts_params->valid_devs[0], qp_id,
 493                         &ts_params->qp_conf,
 494                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
 495                         "Failed to setup queue pair %u on cryptodev %u",
 496                         qp_id, ts_params->valid_devs[0]);
 497         }
 498
 499
 500         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
 501
 502         /* Start the device */
 503         TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
 504                         "Failed to start cryptodev %u",
 505                         ts_params->valid_devs[0]);
 506
 507         return TEST_SUCCESS;
 508 }
 509
 510 static void
 511 ut_teardown(void)
 512 {
 513         struct crypto_testsuite_params *ts_params = &testsuite_params;
 514         struct crypto_unittest_params *ut_params = &unittest_params;
 515         struct rte_cryptodev_stats stats;
 516
 517         /* free crypto session structure */
 518         if (ut_params->sess) {
 519                 rte_cryptodev_sym_session_free(ts_params->valid_devs[0],
 520                                 ut_params->sess);
 521                 ut_params->sess = NULL;
 522         }
 523
 524         /* free crypto operation structure */
 525         if (ut_params->op)
 526                 rte_crypto_op_free(ut_params->op);
 527
 528         /*
 529          * free mbuf - both obuf and ibuf are usually the same,
 530          * so check if they point at the same address is necessary,
 531          * to avoid freeing the mbuf twice.
 532          */
 533         if (ut_params->obuf) {
 534                 rte_pktmbuf_free(ut_params->obuf);
 535                 if (ut_params->ibuf == ut_params->obuf)
 536                         ut_params->ibuf = 0;
 537                 ut_params->obuf = 0;
 538         }
 539         if (ut_params->ibuf) {
 540                 rte_pktmbuf_free(ut_params->ibuf);
 541                 ut_params->ibuf = 0;
 542         }
 543
 544         if (ts_params->mbuf_pool != NULL)
 545                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
 546                         rte_mempool_avail_count(ts_params->mbuf_pool));
 547
 548         rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats);
 549
 550         /* Stop the device */
 551         rte_cryptodev_stop(ts_params->valid_devs[0]);
 552 }
 553
 554 static int
 555 test_device_configure_invalid_dev_id(void)
 556 {
 557         struct crypto_testsuite_params *ts_params = &testsuite_params;
 558         uint16_t dev_id, num_devs = 0;
 559
 560         TEST_ASSERT((num_devs = rte_cryptodev_count()) >= 1,
 561                         "Need at least %d devices for test", 1);
 562
 563         /* valid dev_id values */
 564         dev_id = ts_params->valid_devs[ts_params->valid_dev_count - 1];
 565
 566         /* Stop the device in case it's started so it can be configured */
 567         rte_cryptodev_stop(ts_params->valid_devs[dev_id]);
 568
 569         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf),
 570                         "Failed test for rte_cryptodev_configure: "
 571                         "invalid dev_num %u", dev_id);
 572
 573         /* invalid dev_id values */
 574         dev_id = num_devs;
 575
 576         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
 577                         "Failed test for rte_cryptodev_configure: "
 578                         "invalid dev_num %u", dev_id);
 579
 580         dev_id = 0xff;
 581
 582         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
 583                         "Failed test for rte_cryptodev_configure:"
 584                         "invalid dev_num %u", dev_id);
 585
 586         return TEST_SUCCESS;
 587 }
 588
 589 static int
 590 test_device_configure_invalid_queue_pair_ids(void)
 591 {
 592         struct crypto_testsuite_params *ts_params = &testsuite_params;
 593         uint16_t orig_nb_qps = ts_params->conf.nb_queue_pairs;
 594
 595         /* Stop the device in case it's started so it can be configured */
 596         rte_cryptodev_stop(ts_params->valid_devs[0]);
 597
 598         /* valid - one queue pairs */
 599         ts_params->conf.nb_queue_pairs = 1;
 600
 601         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 602                         &ts_params->conf),
 603                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
 604                         ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
 605
 606
 607         /* valid - max value queue pairs */
 608         ts_params->conf.nb_queue_pairs = MAX_NUM_QPS_PER_QAT_DEVICE;
 609
 610         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 611                         &ts_params->conf),
 612                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
 613                         ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
 614
 615
 616         /* invalid - zero queue pairs */
 617         ts_params->conf.nb_queue_pairs = 0;
 618
 619         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
 620                         &ts_params->conf),
 621                         "Failed test for rte_cryptodev_configure, dev_id %u,"
 622                         " invalid qps: %u",
 623                         ts_params->valid_devs[0],
 624                         ts_params->conf.nb_queue_pairs);
 625
 626
 627         /* invalid - max value supported by field queue pairs */
 628         ts_params->conf.nb_queue_pairs = UINT16_MAX;
 629
 630         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
 631                         &ts_params->conf),
 632                         "Failed test for rte_cryptodev_configure, dev_id %u,"
 633                         " invalid qps: %u",
 634                         ts_params->valid_devs[0],
 635                         ts_params->conf.nb_queue_pairs);
 636
 637
 638         /* invalid - max value + 1 queue pairs */
 639         ts_params->conf.nb_queue_pairs = MAX_NUM_QPS_PER_QAT_DEVICE + 1;
 640
 641         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
 642                         &ts_params->conf),
 643                         "Failed test for rte_cryptodev_configure, dev_id %u,"
 644                         " invalid qps: %u",
 645                         ts_params->valid_devs[0],
 646                         ts_params->conf.nb_queue_pairs);
 647
 648         /* revert to original testsuite value */
 649         ts_params->conf.nb_queue_pairs = orig_nb_qps;
 650
 651         return TEST_SUCCESS;
 652 }
 653
 654 static int
 655 test_queue_pair_descriptor_setup(void)
 656 {
 657         struct crypto_testsuite_params *ts_params = &testsuite_params;
 658         struct rte_cryptodev_info dev_info;
 659         struct rte_cryptodev_qp_conf qp_conf = {
 660                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
 661         };
 662
 663         uint16_t qp_id;
 664
 665         /* Stop the device in case it's started so it can be configured */
 666         rte_cryptodev_stop(ts_params->valid_devs[0]);
 667
 668
 669         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 670
 671         ts_params->conf.session_mp.nb_objs = dev_info.sym.max_nb_sessions;
 672
 673         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 674                         &ts_params->conf), "Failed to configure cryptodev %u",
 675                         ts_params->valid_devs[0]);
 676
 677
 678         /*
 679          * Test various ring sizes on this device. memzones can't be
 680          * freed so are re-used if ring is released and re-created.
 681          */
 682         qp_conf.nb_descriptors = MIN_NUM_OPS_INFLIGHT; /* min size*/
 683
 684         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 685                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 686                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 687                                 rte_cryptodev_socket_id(
 688                                                 ts_params->valid_devs[0])),
 689                                 "Failed test for "
 690                                 "rte_cryptodev_queue_pair_setup: num_inflights "
 691                                 "%u on qp %u on cryptodev %u",
 692                                 qp_conf.nb_descriptors, qp_id,
 693                                 ts_params->valid_devs[0]);
 694         }
 695
 696         qp_conf.nb_descriptors = (uint32_t)(MAX_NUM_OPS_INFLIGHT / 2);
 697
 698         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 699                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 700                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 701                                 rte_cryptodev_socket_id(
 702                                                 ts_params->valid_devs[0])),
 703                                 "Failed test for"
 704                                 " rte_cryptodev_queue_pair_setup: num_inflights"
 705                                 " %u on qp %u on cryptodev %u",
 706                                 qp_conf.nb_descriptors, qp_id,
 707                                 ts_params->valid_devs[0]);
 708         }
 709
 710         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; /* valid */
 711
 712         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 713                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 714                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 715                                 rte_cryptodev_socket_id(
 716                                                 ts_params->valid_devs[0])),
 717                                 "Failed test for "
 718                                 "rte_cryptodev_queue_pair_setup: num_inflights"
 719                                 " %u on qp %u on cryptodev %u",
 720                                 qp_conf.nb_descriptors, qp_id,
 721                                 ts_params->valid_devs[0]);
 722         }
 723
 724         /* invalid number of descriptors - max supported + 2 */
 725         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT + 2;
 726
 727         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 728                 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 729                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 730                                 rte_cryptodev_socket_id(
 731                                                 ts_params->valid_devs[0])),
 732                                 "Unexpectedly passed test for "
 733                                 "rte_cryptodev_queue_pair_setup:"
 734                                 "num_inflights %u on qp %u on cryptodev %u",
 735                                 qp_conf.nb_descriptors, qp_id,
 736                                 ts_params->valid_devs[0]);
 737         }
 738
 739         /* invalid number of descriptors - max value of parameter */
 740         qp_conf.nb_descriptors = UINT32_MAX-1;
 741
 742         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 743                 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 744                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 745                                 rte_cryptodev_socket_id(
 746                                                 ts_params->valid_devs[0])),
 747                                 "Unexpectedly passed test for "
 748                                 "rte_cryptodev_queue_pair_setup:"
 749                                 "num_inflights %u on qp %u on cryptodev %u",
 750                                 qp_conf.nb_descriptors, qp_id,
 751                                 ts_params->valid_devs[0]);
 752         }
 753
 754         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
 755
 756         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 757                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 758                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 759                                 rte_cryptodev_socket_id(
 760                                                 ts_params->valid_devs[0])),
 761                                 "Failed test for"
 762                                 " rte_cryptodev_queue_pair_setup:"
 763                                 "num_inflights %u on qp %u on cryptodev %u",
 764                                 qp_conf.nb_descriptors, qp_id,
 765                                 ts_params->valid_devs[0]);
 766         }
 767
 768         /* invalid number of descriptors - max supported + 1 */
 769         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT + 1;
 770
 771         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
 772                 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 773                                 ts_params->valid_devs[0], qp_id, &qp_conf,
 774                                 rte_cryptodev_socket_id(
 775                                                 ts_params->valid_devs[0])),
 776                                 "Unexpectedly passed test for "
 777                                 "rte_cryptodev_queue_pair_setup:"
 778                                 "num_inflights %u on qp %u on cryptodev %u",
 779                                 qp_conf.nb_descriptors, qp_id,
 780                                 ts_params->valid_devs[0]);
 781         }
 782
 783         /* test invalid queue pair id */
 784         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;      /*valid */
 785
 786         qp_id = DEFAULT_NUM_QPS_PER_QAT_DEVICE;         /*invalid */
 787
 788         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 789                         ts_params->valid_devs[0],
 790                         qp_id, &qp_conf,
 791                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
 792                         "Failed test for rte_cryptodev_queue_pair_setup:"
 793                         "invalid qp %u on cryptodev %u",
 794                         qp_id, ts_params->valid_devs[0]);
 795
 796         qp_id = 0xffff; /*invalid*/
 797
 798         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 799                         ts_params->valid_devs[0],
 800                         qp_id, &qp_conf,
 801                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
 802                         "Failed test for rte_cryptodev_queue_pair_setup:"
 803                         "invalid qp %u on cryptodev %u",
 804                         qp_id, ts_params->valid_devs[0]);
 805
 806         return TEST_SUCCESS;
 807 }
 808
 809 /* ***** Plaintext data for tests ***** */
 810
 811 const char catch_22_quote_1[] =
 812                 "There was only one catch and that was Catch-22, which "
 813                 "specified that a concern for one's safety in the face of "
 814                 "dangers that were real and immediate was the process of a "
 815                 "rational mind. Orr was crazy and could be grounded. All he "
 816                 "had to do was ask; and as soon as he did, he would no longer "
 817                 "be crazy and would have to fly more missions. Orr would be "
 818                 "crazy to fly more missions and sane if he didn't, but if he "
 819                 "was sane he had to fly them. If he flew them he was crazy "
 820                 "and didn't have to; but if he didn't want to he was sane and "
 821                 "had to. Yossarian was moved very deeply by the absolute "
 822                 "simplicity of this clause of Catch-22 and let out a "
 823                 "respectful whistle. \"That's some catch, that Catch-22\", he "
 824                 "observed. \"It's the best there is,\" Doc Daneeka agreed.";
 825
 826 const char catch_22_quote[] =
 827                 "What a lousy earth! He wondered how many people were "
 828                 "destitute that same night even in his own prosperous country, "
 829                 "how many homes were shanties, how many husbands were drunk "
 830                 "and wives socked, and how many children were bullied, abused, "
 831                 "or abandoned. How many families hungered for food they could "
 832                 "not afford to buy? How many hearts were broken? How many "
 833                 "suicides would take place that same night, how many people "
 834                 "would go insane? How many cockroaches and landlords would "
 835                 "triumph? How many winners were losers, successes failures, "
 836                 "and rich men poor men? How many wise guys were stupid? How "
 837                 "many happy endings were unhappy endings? How many honest men "
 838                 "were liars, brave men cowards, loyal men traitors, how many "
 839                 "sainted men were corrupt, how many people in positions of "
 840                 "trust had sold their souls to bodyguards, how many had never "
 841                 "had souls? How many straight-and-narrow paths were crooked "
 842                 "paths? How many best families were worst families and how "
 843                 "many good people were bad people? When you added them all up "
 844                 "and then subtracted, you might be left with only the children, "
 845                 "and perhaps with Albert Einstein and an old violinist or "
 846                 "sculptor somewhere.";
 847
 848 #define QUOTE_480_BYTES         (480)
 849 #define QUOTE_512_BYTES         (512)
 850 #define QUOTE_768_BYTES         (768)
 851 #define QUOTE_1024_BYTES        (1024)
 852
 853
 854
 855 /* ***** SHA1 Hash Tests ***** */
 856
 857 #define HMAC_KEY_LENGTH_SHA1    (DIGEST_BYTE_LENGTH_SHA1)
 858
 859 static uint8_t hmac_sha1_key[] = {
 860         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
 861         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
 862         0xDE, 0xF4, 0xDE, 0xAD };
 863
 864 /* ***** SHA224 Hash Tests ***** */
 865
 866 #define HMAC_KEY_LENGTH_SHA224  (DIGEST_BYTE_LENGTH_SHA224)
 867
 868
 869 /* ***** AES-CBC Cipher Tests ***** */
 870
 871 #define CIPHER_KEY_LENGTH_AES_CBC       (16)
 872 #define CIPHER_IV_LENGTH_AES_CBC        (CIPHER_KEY_LENGTH_AES_CBC)
 873
 874 static uint8_t aes_cbc_key[] = {
 875         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
 876         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A };
 877
 878 static uint8_t aes_cbc_iv[] = {
 879         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 880         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
 881
 882
 883 /* ***** AES-CBC / HMAC-SHA1 Hash Tests ***** */
 884
 885 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_ciphertext[] = {
 886         0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31,
 887         0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76,
 888         0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E,
 889         0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A,
 890         0x3F, 0x6B, 0x5D, 0xDF, 0x52, 0x85, 0x5F, 0x8E,
 891         0x42, 0x3C, 0xFB, 0xE9, 0x1A, 0x24, 0xD6, 0x08,
 892         0xDD, 0xFD, 0x16, 0xFB, 0xE9, 0x55, 0xEF, 0xF0,
 893         0xA0, 0x8D, 0x13, 0xAB, 0x81, 0xC6, 0x90, 0x01,
 894         0xB5, 0x18, 0x84, 0xB3, 0xF6, 0xE6, 0x11, 0x57,
 895         0xD6, 0x71, 0xC6, 0x3C, 0x3F, 0x2F, 0x33, 0xEE,
 896         0x24, 0x42, 0x6E, 0xAC, 0x0B, 0xCA, 0xEC, 0xF9,
 897         0x84, 0xF8, 0x22, 0xAA, 0x60, 0xF0, 0x32, 0xA9,
 898         0x75, 0x75, 0x3B, 0xCB, 0x70, 0x21, 0x0A, 0x8D,
 899         0x0F, 0xE0, 0xC4, 0x78, 0x2B, 0xF8, 0x97, 0xE3,
 900         0xE4, 0x26, 0x4B, 0x29, 0xDA, 0x88, 0xCD, 0x46,
 901         0xEC, 0xAA, 0xF9, 0x7F, 0xF1, 0x15, 0xEA, 0xC3,
 902         0x87, 0xE6, 0x31, 0xF2, 0xCF, 0xDE, 0x4D, 0x80,
 903         0x70, 0x91, 0x7E, 0x0C, 0xF7, 0x26, 0x3A, 0x92,
 904         0x4F, 0x18, 0x83, 0xC0, 0x8F, 0x59, 0x01, 0xA5,
 905         0x88, 0xD1, 0xDB, 0x26, 0x71, 0x27, 0x16, 0xF5,
 906         0xEE, 0x10, 0x82, 0xAC, 0x68, 0x26, 0x9B, 0xE2,
 907         0x6D, 0xD8, 0x9A, 0x80, 0xDF, 0x04, 0x31, 0xD5,
 908         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
 909         0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
 910         0x73, 0x02, 0x42, 0xC9, 0x23, 0x18, 0x8E, 0xB4,
 911         0x6F, 0xB4, 0xA3, 0x54, 0x6E, 0x88, 0x3B, 0x62,
 912         0x7C, 0x02, 0x8D, 0x4C, 0x9F, 0xC8, 0x45, 0xF4,
 913         0xC9, 0xDE, 0x4F, 0xEB, 0x22, 0x83, 0x1B, 0xE4,
 914         0x49, 0x37, 0xE4, 0xAD, 0xE7, 0xCD, 0x21, 0x54,
 915         0xBC, 0x1C, 0xC2, 0x04, 0x97, 0xB4, 0x10, 0x61,
 916         0xF0, 0xE4, 0xEF, 0x27, 0x63, 0x3A, 0xDA, 0x91,
 917         0x41, 0x25, 0x62, 0x1C, 0x5C, 0xB6, 0x38, 0x4A,
 918         0x88, 0x71, 0x59, 0x5A, 0x8D, 0xA0, 0x09, 0xAF,
 919         0x72, 0x94, 0xD7, 0x79, 0x5C, 0x60, 0x7C, 0x8F,
 920         0x4C, 0xF5, 0xD9, 0xA1, 0x39, 0x6D, 0x81, 0x28,
 921         0xEF, 0x13, 0x28, 0xDF, 0xF5, 0x3E, 0xF7, 0x8E,
 922         0x09, 0x9C, 0x78, 0x18, 0x79, 0xB8, 0x68, 0xD7,
 923         0xA8, 0x29, 0x62, 0xAD, 0xDE, 0xE1, 0x61, 0x76,
 924         0x1B, 0x05, 0x16, 0xCD, 0xBF, 0x02, 0x8E, 0xA6,
 925         0x43, 0x6E, 0x92, 0x55, 0x4F, 0x60, 0x9C, 0x03,
 926         0xB8, 0x4F, 0xA3, 0x02, 0xAC, 0xA8, 0xA7, 0x0C,
 927         0x1E, 0xB5, 0x6B, 0xF8, 0xC8, 0x4D, 0xDE, 0xD2,
 928         0xB0, 0x29, 0x6E, 0x40, 0xE6, 0xD6, 0xC9, 0xE6,
 929         0xB9, 0x0F, 0xB6, 0x63, 0xF5, 0xAA, 0x2B, 0x96,
 930         0xA7, 0x16, 0xAC, 0x4E, 0x0A, 0x33, 0x1C, 0xA6,
 931         0xE6, 0xBD, 0x8A, 0xCF, 0x40, 0xA9, 0xB2, 0xFA,
 932         0x63, 0x27, 0xFD, 0x9B, 0xD9, 0xFC, 0xD5, 0x87,
 933         0x8D, 0x4C, 0xB6, 0xA4, 0xCB, 0xE7, 0x74, 0x55,
 934         0xF4, 0xFB, 0x41, 0x25, 0xB5, 0x4B, 0x0A, 0x1B,
 935         0xB1, 0xD6, 0xB7, 0xD9, 0x47, 0x2A, 0xC3, 0x98,
 936         0x6A, 0xC4, 0x03, 0x73, 0x1F, 0x93, 0x6E, 0x53,
 937         0x19, 0x25, 0x64, 0x15, 0x83, 0xF9, 0x73, 0x2A,
 938         0x74, 0xB4, 0x93, 0x69, 0xC4, 0x72, 0xFC, 0x26,
 939         0xA2, 0x9F, 0x43, 0x45, 0xDD, 0xB9, 0xEF, 0x36,
 940         0xC8, 0x3A, 0xCD, 0x99, 0x9B, 0x54, 0x1A, 0x36,
 941         0xC1, 0x59, 0xF8, 0x98, 0xA8, 0xCC, 0x28, 0x0D,
 942         0x73, 0x4C, 0xEE, 0x98, 0xCB, 0x7C, 0x58, 0x7E,
 943         0x20, 0x75, 0x1E, 0xB7, 0xC9, 0xF8, 0xF2, 0x0E,
 944         0x63, 0x9E, 0x05, 0x78, 0x1A, 0xB6, 0xA8, 0x7A,
 945         0xF9, 0x98, 0x6A, 0xA6, 0x46, 0x84, 0x2E, 0xF6,
 946         0x4B, 0xDC, 0x9B, 0x8F, 0x9B, 0x8F, 0xEE, 0xB4,
 947         0xAA, 0x3F, 0xEE, 0xC0, 0x37, 0x27, 0x76, 0xC7,
 948         0x95, 0xBB, 0x26, 0x74, 0x69, 0x12, 0x7F, 0xF1,
 949         0xBB, 0xFF, 0xAE, 0xB5, 0x99, 0x6E, 0xCB, 0x0C
 950 };
 951
 952 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest[] = {
 953         0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60,
 954         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
 955         0x18, 0x8c, 0x1d, 0x32
 956 };
 957
 958
 959 /* Multisession Vector context Test */
 960 /*Begin Session 0 */
 961 static uint8_t ms_aes_cbc_key0[] = {
 962         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
 963         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
 964 };
 965
 966 static uint8_t ms_aes_cbc_iv0[] = {
 967         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
 968         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
 969 };
 970
 971 static const uint8_t ms_aes_cbc_cipher0[] = {
 972                 0x3C, 0xE4, 0xEE, 0x42, 0xB6, 0x9B, 0xC3, 0x38,
 973                 0x5F, 0xAD, 0x54, 0xDC, 0xA8, 0x32, 0x81, 0xDC,
 974                 0x7A, 0x6F, 0x85, 0x58, 0x07, 0x35, 0xED, 0xEB,
 975                 0xAD, 0x79, 0x79, 0x96, 0xD3, 0x0E, 0xA6, 0xD9,
 976                 0xAA, 0x86, 0xA4, 0x8F, 0xB5, 0xD6, 0x6E, 0x6D,
 977                 0x0C, 0x91, 0x2F, 0xC4, 0x67, 0x98, 0x0E, 0xC4,
 978                 0x8D, 0x83, 0x68, 0x69, 0xC4, 0xD3, 0x94, 0x34,
 979                 0xC4, 0x5D, 0x60, 0x55, 0x22, 0x87, 0x8F, 0x6F,
 980                 0x17, 0x8E, 0x75, 0xE4, 0x02, 0xF5, 0x1B, 0x99,
 981                 0xC8, 0x39, 0xA9, 0xAB, 0x23, 0x91, 0x12, 0xED,
 982                 0x08, 0xE7, 0xD9, 0x25, 0x89, 0x24, 0x4F, 0x8D,
 983                 0x68, 0xF3, 0x10, 0x39, 0x0A, 0xEE, 0x45, 0x24,
 984                 0xDF, 0x7A, 0x9D, 0x00, 0x25, 0xE5, 0x35, 0x71,
 985                 0x4E, 0x40, 0x59, 0x6F, 0x0A, 0x13, 0xB3, 0x72,
 986                 0x1D, 0x98, 0x63, 0x94, 0x89, 0xA5, 0x39, 0x8E,
 987                 0xD3, 0x9C, 0x8A, 0x7F, 0x71, 0x2F, 0xC7, 0xCD,
 988                 0x81, 0x05, 0xDC, 0xC0, 0x8D, 0xCE, 0x6D, 0x18,
 989                 0x30, 0xC4, 0x72, 0x51, 0xF0, 0x27, 0xC8, 0xF6,
 990                 0x60, 0x5B, 0x7C, 0xB2, 0xE3, 0x49, 0x0C, 0x29,
 991                 0xC6, 0x9F, 0x39, 0x57, 0x80, 0x55, 0x24, 0x2C,
 992                 0x9B, 0x0F, 0x5A, 0xB3, 0x89, 0x55, 0x31, 0x96,
 993                 0x0D, 0xCD, 0xF6, 0x51, 0x03, 0x2D, 0x89, 0x26,
 994                 0x74, 0x44, 0xD6, 0xE8, 0xDC, 0xEA, 0x44, 0x55,
 995                 0x64, 0x71, 0x9C, 0x9F, 0x5D, 0xBA, 0x39, 0x46,
 996                 0xA8, 0x17, 0xA1, 0x9C, 0x52, 0x9D, 0xBC, 0x6B,
 997                 0x4A, 0x98, 0xE6, 0xEA, 0x33, 0xEC, 0x58, 0xB4,
 998                 0x43, 0xF0, 0x32, 0x45, 0xA4, 0xC1, 0x55, 0xB7,
 999                 0x5D, 0xB5, 0x59, 0xB2, 0xE3, 0x96, 0xFF, 0xA5,
1000                 0xAF, 0xE1, 0x86, 0x1B, 0x42, 0xE6, 0x3B, 0xA0,
1001                 0x90, 0x4A, 0xE8, 0x8C, 0x21, 0x7F, 0x36, 0x1E,
1002                 0x5B, 0x65, 0x25, 0xD1, 0xC1, 0x5A, 0xCA, 0x3D,
1003                 0x10, 0xED, 0x2D, 0x79, 0xD0, 0x0F, 0x58, 0x44,
1004                 0x69, 0x81, 0xF5, 0xD4, 0xC9, 0x0F, 0x90, 0x76,
1005                 0x1F, 0x54, 0xD2, 0xD5, 0x97, 0xCE, 0x2C, 0xE3,
1006                 0xEF, 0xF4, 0xB7, 0xC6, 0x3A, 0x87, 0x7F, 0x83,
1007                 0x2A, 0xAF, 0xCD, 0x90, 0x12, 0xA7, 0x7D, 0x85,
1008                 0x1D, 0x62, 0xD3, 0x85, 0x25, 0x05, 0xDB, 0x45,
1009                 0x92, 0xA3, 0xF6, 0xA2, 0xA8, 0x41, 0xE4, 0x25,
1010                 0x86, 0x87, 0x67, 0x24, 0xEC, 0x89, 0x23, 0x2A,
1011                 0x9B, 0x20, 0x4D, 0x93, 0xEE, 0xE2, 0x2E, 0xC1,
1012                 0x0B, 0x15, 0x33, 0xCF, 0x00, 0xD1, 0x1A, 0xDA,
1013                 0x93, 0xFD, 0x28, 0x21, 0x5B, 0xCF, 0xD1, 0xF3,
1014                 0x5A, 0x81, 0xBA, 0x82, 0x5E, 0x2F, 0x61, 0xB4,
1015                 0x05, 0x71, 0xB5, 0xF4, 0x39, 0x3C, 0x1F, 0x60,
1016                 0x00, 0x7A, 0xC4, 0xF8, 0x35, 0x20, 0x6C, 0x3A,
1017                 0xCC, 0x03, 0x8F, 0x7B, 0xA2, 0xB6, 0x65, 0x8A,
1018                 0xB6, 0x5F, 0xFD, 0x25, 0xD3, 0x5F, 0x92, 0xF9,
1019                 0xAE, 0x17, 0x9B, 0x5E, 0x6E, 0x9A, 0xE4, 0x55,
1020                 0x10, 0x25, 0x07, 0xA4, 0xAF, 0x21, 0x69, 0x13,
1021                 0xD8, 0xFA, 0x31, 0xED, 0xF7, 0xA7, 0xA7, 0x3B,
1022                 0xB8, 0x96, 0x8E, 0x10, 0x86, 0x74, 0xD8, 0xB1,
1023                 0x34, 0x9E, 0x9B, 0x6A, 0x26, 0xA8, 0xD4, 0xD0,
1024                 0xB5, 0xF6, 0xDE, 0xE7, 0xCA, 0x06, 0xDC, 0xA3,
1025                 0x6F, 0xEE, 0x6B, 0x1E, 0xB5, 0x30, 0x99, 0x23,
1026                 0xF9, 0x76, 0xF0, 0xA0, 0xCF, 0x3B, 0x94, 0x7B,
1027                 0x19, 0x8D, 0xA5, 0x0C, 0x18, 0xA6, 0x1D, 0x07,
1028                 0x89, 0xBE, 0x5B, 0x61, 0xE5, 0xF1, 0x42, 0xDB,
1029                 0xD4, 0x2E, 0x02, 0x1F, 0xCE, 0xEF, 0x92, 0xB1,
1030                 0x1B, 0x56, 0x50, 0xF2, 0x16, 0xE5, 0xE7, 0x4F,
1031                 0xFD, 0xBB, 0x3E, 0xD2, 0xFC, 0x3C, 0xC6, 0x0F,
1032                 0xF9, 0x12, 0x4E, 0xCB, 0x1E, 0x0C, 0x15, 0x84,
1033                 0x2A, 0x14, 0x8A, 0x02, 0xE4, 0x7E, 0x95, 0x5B,
1034                 0x86, 0xDB, 0x9B, 0x62, 0x5B, 0x19, 0xD2, 0x17,
1035                 0xFA, 0x13, 0xBB, 0x6B, 0x3F, 0x45, 0x9F, 0xBF
1036 };
1037
1038
1039 static  uint8_t ms_hmac_key0[] = {
1040                 0xFF, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1041                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1042                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1043                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1044                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1045                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1046                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1047                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1048 };
1049
1050 static const uint8_t ms_hmac_digest0[] = {
1051                 0x43, 0x52, 0xED, 0x34, 0xAB, 0x36, 0xB2, 0x51,
1052                 0xFB, 0xA3, 0xA6, 0x7C, 0x38, 0xFC, 0x42, 0x8F,
1053                 0x57, 0x64, 0xAB, 0x81, 0xA7, 0x89, 0xB7, 0x6C,
1054                 0xA0, 0xDC, 0xB9, 0x4D, 0xC4, 0x30, 0xF9, 0xD4,
1055                 0x10, 0x82, 0x55, 0xD0, 0xAB, 0x32, 0xFB, 0x56,
1056                 0x0D, 0xE4, 0x68, 0x3D, 0x76, 0xD0, 0x7B, 0xE4,
1057                 0xA6, 0x2C, 0x34, 0x9E, 0x8C, 0x41, 0xF8, 0x23,
1058                 0x28, 0x1B, 0x3A, 0x90, 0x26, 0x34, 0x47, 0x90
1059                 };
1060
1061 /* End Session 0 */
1062 /* Begin session 1 */
1063
1064 static  uint8_t ms_aes_cbc_key1[] = {
1065                 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1066                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1067 };
1068
1069 static  uint8_t ms_aes_cbc_iv1[] = {
1070         0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1071         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1072 };
1073
1074 static const uint8_t ms_aes_cbc_cipher1[] = {
1075                 0x5A, 0x7A, 0x67, 0x5D, 0xB8, 0xE1, 0xDC, 0x71,
1076                 0x39, 0xA8, 0x74, 0x93, 0x9C, 0x4C, 0xFE, 0x23,
1077                 0x61, 0xCD, 0xA4, 0xB3, 0xD9, 0xCE, 0x99, 0x09,
1078                 0x2A, 0x23, 0xF3, 0x29, 0xBF, 0x4C, 0xB4, 0x6A,
1079                 0x1B, 0x6B, 0x73, 0x4D, 0x48, 0x0C, 0xCF, 0x6C,
1080                 0x5E, 0x34, 0x9E, 0x7F, 0xBC, 0x8F, 0xCC, 0x8F,
1081                 0x75, 0x1D, 0x3D, 0x77, 0x10, 0x76, 0xC8, 0xB9,
1082                 0x99, 0x6F, 0xD6, 0x56, 0x75, 0xA9, 0xB2, 0x66,
1083                 0xC2, 0x24, 0x2B, 0x9C, 0xFE, 0x40, 0x8E, 0x43,
1084                 0x20, 0x97, 0x1B, 0xFA, 0xD0, 0xCF, 0x04, 0xAB,
1085                 0xBB, 0xF6, 0x5D, 0xF5, 0xA0, 0x19, 0x7C, 0x23,
1086                 0x5D, 0x80, 0x8C, 0x49, 0xF6, 0x76, 0x88, 0x29,
1087                 0x27, 0x4C, 0x59, 0x2B, 0x43, 0xA6, 0xB2, 0x26,
1088                 0x27, 0x78, 0xBE, 0x1B, 0xE1, 0x4F, 0x5A, 0x1F,
1089                 0xFC, 0x68, 0x08, 0xE7, 0xC4, 0xD1, 0x34, 0x68,
1090                 0xB7, 0x13, 0x14, 0x41, 0x62, 0x6B, 0x1F, 0x77,
1091                 0x0C, 0x68, 0x1D, 0x0D, 0xED, 0x89, 0xAA, 0xD8,
1092                 0x97, 0x02, 0xBA, 0x5E, 0xD4, 0x84, 0x25, 0x97,
1093                 0x03, 0xA5, 0xA6, 0x13, 0x66, 0x02, 0xF4, 0xC3,
1094                 0xF3, 0xD3, 0xCC, 0x95, 0xC3, 0x87, 0x46, 0x90,
1095                 0x1F, 0x6E, 0x14, 0xA8, 0x00, 0xF2, 0x6F, 0xD5,
1096                 0xA1, 0xAD, 0xD5, 0x40, 0xA2, 0x0F, 0x32, 0x7E,
1097                 0x99, 0xA3, 0xF5, 0x53, 0xC3, 0x26, 0xA1, 0x45,
1098                 0x01, 0x88, 0x57, 0x84, 0x3E, 0x7B, 0x4E, 0x0B,
1099                 0x3C, 0xB5, 0x3E, 0x9E, 0xE9, 0x78, 0x77, 0xC5,
1100                 0xC0, 0x89, 0xA8, 0xF8, 0xF1, 0xA5, 0x2D, 0x5D,
1101                 0xF9, 0xC6, 0xFB, 0xCB, 0x05, 0x23, 0xBD, 0x6E,
1102                 0x5E, 0x14, 0xC6, 0x57, 0x73, 0xCF, 0x98, 0xBD,
1103                 0x10, 0x8B, 0x18, 0xA6, 0x01, 0x5B, 0x13, 0xAE,
1104                 0x8E, 0xDE, 0x1F, 0xB5, 0xB7, 0x40, 0x6C, 0xC1,
1105                 0x1E, 0xA1, 0x19, 0x20, 0x9E, 0x95, 0xE0, 0x2F,
1106                 0x1C, 0xF5, 0xD9, 0xD0, 0x2B, 0x1E, 0x82, 0x25,
1107                 0x62, 0xB4, 0xEB, 0xA1, 0x1F, 0xCE, 0x44, 0xA1,
1108                 0xCB, 0x92, 0x01, 0x6B, 0xE4, 0x26, 0x23, 0xE3,
1109                 0xC5, 0x67, 0x35, 0x55, 0xDA, 0xE5, 0x27, 0xEE,
1110                 0x8D, 0x12, 0x84, 0xB7, 0xBA, 0xA7, 0x1C, 0xD6,
1111                 0x32, 0x3F, 0x67, 0xED, 0xFB, 0x5B, 0x8B, 0x52,
1112                 0x46, 0x8C, 0xF9, 0x69, 0xCD, 0xAE, 0x79, 0xAA,
1113                 0x37, 0x78, 0x49, 0xEB, 0xC6, 0x8E, 0x76, 0x63,
1114                 0x84, 0xFF, 0x9D, 0x22, 0x99, 0x51, 0xB7, 0x5E,
1115                 0x83, 0x4C, 0x8B, 0xDF, 0x5A, 0x07, 0xCC, 0xBA,
1116                 0x42, 0xA5, 0x98, 0xB6, 0x47, 0x0E, 0x66, 0xEB,
1117                 0x23, 0x0E, 0xBA, 0x44, 0xA8, 0xAA, 0x20, 0x71,
1118                 0x79, 0x9C, 0x77, 0x5F, 0xF5, 0xFE, 0xEC, 0xEF,
1119                 0xC6, 0x64, 0x3D, 0x84, 0xD0, 0x2B, 0xA7, 0x0A,
1120                 0xC3, 0x72, 0x5B, 0x9C, 0xFA, 0xA8, 0x87, 0x95,
1121                 0x94, 0x11, 0x38, 0xA7, 0x1E, 0x58, 0xE3, 0x73,
1122                 0xC6, 0xC9, 0xD1, 0x7B, 0x92, 0xDB, 0x0F, 0x49,
1123                 0x74, 0xC2, 0xA2, 0x0E, 0x35, 0x57, 0xAC, 0xDB,
1124                 0x9A, 0x1C, 0xCF, 0x5A, 0x32, 0x3E, 0x26, 0x9B,
1125                 0xEC, 0xB3, 0xEF, 0x9C, 0xFE, 0xBE, 0x52, 0xAC,
1126                 0xB1, 0x29, 0xDD, 0xFD, 0x07, 0xE2, 0xEE, 0xED,
1127                 0xE4, 0x46, 0x37, 0xFE, 0xD1, 0xDC, 0xCD, 0x02,
1128                 0xF9, 0x31, 0xB0, 0xFB, 0x36, 0xB7, 0x34, 0xA4,
1129                 0x76, 0xE8, 0x57, 0xBF, 0x99, 0x92, 0xC7, 0xAF,
1130                 0x98, 0x10, 0xE2, 0x70, 0xCA, 0xC9, 0x2B, 0x82,
1131                 0x06, 0x96, 0x88, 0x0D, 0xB3, 0xAC, 0x9E, 0x6D,
1132                 0x43, 0xBC, 0x5B, 0x31, 0xCF, 0x65, 0x8D, 0xA6,
1133                 0xC7, 0xFE, 0x73, 0xE1, 0x54, 0xF7, 0x10, 0xF9,
1134                 0x86, 0xF7, 0xDF, 0xA1, 0xA1, 0xD8, 0xAE, 0x35,
1135                 0xB3, 0x90, 0xDC, 0x6F, 0x43, 0x7A, 0x8B, 0xE0,
1136                 0xFE, 0x8F, 0x33, 0x4D, 0x29, 0x6C, 0x45, 0x53,
1137                 0x73, 0xDD, 0x21, 0x0B, 0x85, 0x30, 0xB5, 0xA5,
1138                 0xF3, 0x5D, 0xEC, 0x79, 0x61, 0x9D, 0x9E, 0xB3
1139
1140 };
1141
1142 static uint8_t ms_hmac_key1[] = {
1143                 0xFE, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1144                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1145                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1146                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1147                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1148                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1149                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1150                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1151 };
1152
1153 static const uint8_t ms_hmac_digest1[] = {
1154                 0xCE, 0x6E, 0x5F, 0x77, 0x96, 0x9A, 0xB1, 0x69,
1155                 0x2D, 0x5E, 0xF3, 0x2F, 0x32, 0x10, 0xCB, 0x50,
1156                 0x0E, 0x09, 0x56, 0x25, 0x07, 0x34, 0xC9, 0x20,
1157                 0xEC, 0x13, 0x43, 0x23, 0x5C, 0x08, 0x8B, 0xCD,
1158                 0xDC, 0x86, 0x8C, 0xEE, 0x0A, 0x95, 0x2E, 0xB9,
1159                 0x8C, 0x7B, 0x02, 0x7A, 0xD4, 0xE1, 0x49, 0xB4,
1160                 0x45, 0xB5, 0x52, 0x37, 0xC6, 0xFF, 0xFE, 0xAA,
1161                 0x0A, 0x87, 0xB8, 0x51, 0xF9, 0x2A, 0x01, 0x8F
1162 };
1163 /* End Session 1  */
1164 /* Begin Session 2 */
1165 static  uint8_t ms_aes_cbc_key2[] = {
1166                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1167                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1168 };
1169
1170 static  uint8_t ms_aes_cbc_iv2[] = {
1171                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1172                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1173 };
1174
1175 static const uint8_t ms_aes_cbc_cipher2[] = {
1176                 0xBB, 0x3C, 0x68, 0x25, 0xFD, 0xB6, 0xA2, 0x91,
1177                 0x20, 0x56, 0xF6, 0x30, 0x35, 0xFC, 0x9E, 0x97,
1178                 0xF2, 0x90, 0xFC, 0x7E, 0x3E, 0x0A, 0x75, 0xC8,
1179                 0x4C, 0xF2, 0x2D, 0xAC, 0xD3, 0x93, 0xF0, 0xC5,
1180                 0x14, 0x88, 0x8A, 0x23, 0xC2, 0x59, 0x9A, 0x98,
1181                 0x4B, 0xD5, 0x2C, 0xDA, 0x43, 0xA9, 0x34, 0x69,
1182                 0x7C, 0x6D, 0xDB, 0xDC, 0xCB, 0xC0, 0xA0, 0x09,
1183                 0xA7, 0x86, 0x16, 0x4B, 0xBF, 0xA8, 0xB6, 0xCF,
1184                 0x7F, 0x74, 0x1F, 0x22, 0xF0, 0xF6, 0xBB, 0x44,
1185                 0x8B, 0x4C, 0x9E, 0x23, 0xF8, 0x9F, 0xFC, 0x5B,
1186                 0x9E, 0x9C, 0x2A, 0x79, 0x30, 0x8F, 0xBF, 0xA9,
1187                 0x68, 0xA1, 0x20, 0x71, 0x7C, 0x77, 0x22, 0x34,
1188                 0x07, 0xCD, 0xC6, 0xF6, 0x50, 0x0A, 0x08, 0x99,
1189                 0x17, 0x98, 0xE3, 0x93, 0x8A, 0xB0, 0xEE, 0xDF,
1190                 0xC2, 0xBA, 0x3B, 0x44, 0x73, 0xDF, 0xDD, 0xDC,
1191                 0x14, 0x4D, 0x3B, 0xBB, 0x5E, 0x58, 0xC1, 0x26,
1192                 0xA7, 0xAE, 0x47, 0xF3, 0x24, 0x6D, 0x4F, 0xD3,
1193                 0x6E, 0x3E, 0x33, 0xE6, 0x7F, 0xCA, 0x50, 0xAF,
1194                 0x5D, 0x3D, 0xA0, 0xDD, 0xC9, 0xF3, 0x30, 0xD3,
1195                 0x6E, 0x8B, 0x2E, 0x12, 0x24, 0x34, 0xF0, 0xD3,
1196                 0xC7, 0x8D, 0x23, 0x29, 0xAA, 0x05, 0xE1, 0xFA,
1197                 0x2E, 0xF6, 0x8D, 0x37, 0x86, 0xC0, 0x6D, 0x13,
1198                 0x2D, 0x98, 0xF3, 0x52, 0x39, 0x22, 0xCE, 0x38,
1199                 0xC2, 0x1A, 0x72, 0xED, 0xFB, 0xCC, 0xE4, 0x71,
1200                 0x5A, 0x0C, 0x0D, 0x09, 0xF8, 0xE8, 0x1B, 0xBC,
1201                 0x53, 0xC8, 0xD8, 0x8F, 0xE5, 0x98, 0x5A, 0xB1,
1202                 0x06, 0xA6, 0x5B, 0xE6, 0xA2, 0x88, 0x21, 0x9E,
1203                 0x36, 0xC0, 0x34, 0xF9, 0xFB, 0x3B, 0x0A, 0x22,
1204                 0x00, 0x00, 0x39, 0x48, 0x8D, 0x23, 0x74, 0x62,
1205                 0x72, 0x91, 0xE6, 0x36, 0xAA, 0x77, 0x9C, 0x72,
1206                 0x9D, 0xA8, 0xC3, 0xA9, 0xD5, 0x44, 0x72, 0xA6,
1207                 0xB9, 0x28, 0x8F, 0x64, 0x4C, 0x8A, 0x64, 0xE6,
1208                 0x4E, 0xFA, 0xEF, 0x87, 0xDE, 0x7B, 0x22, 0x44,
1209                 0xB0, 0xDF, 0x2E, 0x5F, 0x0B, 0xA5, 0xF2, 0x24,
1210                 0x07, 0x5C, 0x2D, 0x39, 0xB7, 0x3D, 0x8A, 0xE5,
1211                 0x0E, 0x9D, 0x4E, 0x50, 0xED, 0x03, 0x99, 0x8E,
1212                 0xF0, 0x06, 0x55, 0x4E, 0xA2, 0x24, 0xE7, 0x17,
1213                 0x46, 0xDF, 0x6C, 0xCD, 0xC6, 0x44, 0xE8, 0xF9,
1214                 0xB9, 0x1B, 0x36, 0xF6, 0x7F, 0x10, 0xA4, 0x7D,
1215                 0x90, 0xBD, 0xE4, 0xAA, 0xD6, 0x9E, 0x18, 0x9D,
1216                 0x22, 0x35, 0xD6, 0x55, 0x54, 0xAA, 0xF7, 0x22,
1217                 0xA3, 0x3E, 0xEF, 0xC8, 0xA2, 0x34, 0x8D, 0xA9,
1218                 0x37, 0x63, 0xA6, 0xC3, 0x57, 0xCB, 0x0C, 0x49,
1219                 0x7D, 0x02, 0xBE, 0xAA, 0x13, 0x75, 0xB7, 0x4E,
1220                 0x52, 0x62, 0xA5, 0xC2, 0x33, 0xC7, 0x6C, 0x1B,
1221                 0xF6, 0x34, 0xF6, 0x09, 0xA5, 0x0C, 0xC7, 0xA2,
1222                 0x61, 0x48, 0x62, 0x7D, 0x17, 0x15, 0xE3, 0x95,
1223                 0xC8, 0x63, 0xD2, 0xA4, 0x43, 0xA9, 0x49, 0x07,
1224                 0xB2, 0x3B, 0x2B, 0x62, 0x7D, 0xCB, 0x51, 0xB3,
1225                 0x25, 0x33, 0x47, 0x0E, 0x14, 0x67, 0xDC, 0x6A,
1226                 0x9B, 0x51, 0xAC, 0x9D, 0x8F, 0xA2, 0x2B, 0x57,
1227                 0x8C, 0x5C, 0x5F, 0x76, 0x23, 0x92, 0x0F, 0x84,
1228                 0x46, 0x0E, 0x40, 0x85, 0x38, 0x60, 0xFA, 0x61,
1229                 0x20, 0xC5, 0xE3, 0xF1, 0x70, 0xAC, 0x1B, 0xBF,
1230                 0xC4, 0x2B, 0xC5, 0x67, 0xD1, 0x43, 0xC5, 0x17,
1231                 0x74, 0x71, 0x69, 0x6F, 0x82, 0x89, 0x19, 0x8A,
1232                 0x70, 0x43, 0x92, 0x01, 0xC4, 0x63, 0x7E, 0xB1,
1233                 0x59, 0x4E, 0xCD, 0xEA, 0x93, 0xA4, 0x52, 0x53,
1234                 0x9B, 0x61, 0x5B, 0xD2, 0x3E, 0x19, 0x39, 0xB7,
1235                 0x32, 0xEA, 0x8E, 0xF8, 0x1D, 0x76, 0x5C, 0xB2,
1236                 0x73, 0x2D, 0x91, 0xC0, 0x18, 0xED, 0x25, 0x2A,
1237                 0x53, 0x64, 0xF0, 0x92, 0x31, 0x55, 0x21, 0xA8,
1238                 0x24, 0xA9, 0xD1, 0x02, 0xF6, 0x6C, 0x2B, 0x70,
1239                 0xA9, 0x59, 0xC1, 0xD6, 0xC3, 0x57, 0x5B, 0x92
1240 };
1241
1242 static  uint8_t ms_hmac_key2[] = {
1243                 0xFC, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1244                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1245                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1246                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1247                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1248                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1249                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1250                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1251 };
1252
1253 static const uint8_t ms_hmac_digest2[] = {
1254                 0xA5, 0x0F, 0x9C, 0xFB, 0x08, 0x62, 0x59, 0xFF,
1255                 0x80, 0x2F, 0xEB, 0x4B, 0xE1, 0x46, 0x21, 0xD6,
1256                 0x02, 0x98, 0xF2, 0x8E, 0xF4, 0xEC, 0xD4, 0x77,
1257                 0x86, 0x4C, 0x31, 0x28, 0xC8, 0x25, 0x80, 0x27,
1258                 0x3A, 0x72, 0x5D, 0x6A, 0x56, 0x8A, 0xD3, 0x82,
1259                 0xB0, 0xEC, 0x31, 0x6D, 0x8B, 0x6B, 0xB4, 0x24,
1260                 0xE7, 0x62, 0xC1, 0x52, 0xBC, 0x14, 0x1B, 0x8E,
1261                 0xEC, 0x9A, 0xF1, 0x47, 0x80, 0xD2, 0xB0, 0x59
1262 };
1263
1264 /* End Session 2 */
1265
1266
1267 static int
1268 test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
1269 {
1270         struct crypto_testsuite_params *ts_params = &testsuite_params;
1271         struct crypto_unittest_params *ut_params = &unittest_params;
1272
1273         /* Generate test mbuf data and space for digest */
1274         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1275                         catch_22_quote, QUOTE_512_BYTES, 0);
1276
1277         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1278                         DIGEST_BYTE_LENGTH_SHA1);
1279         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1280
1281         /* Setup Cipher Parameters */
1282         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1283         ut_params->cipher_xform.next = &ut_params->auth_xform;
1284
1285         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1286         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
1287         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
1288         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1289
1290         /* Setup HMAC Parameters */
1291         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1292
1293         ut_params->auth_xform.next = NULL;
1294
1295         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
1296         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
1297         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1;
1298         ut_params->auth_xform.auth.key.data = hmac_sha1_key;
1299         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
1300
1301         /* Create crypto session*/
1302         ut_params->sess = rte_cryptodev_sym_session_create(
1303                         ts_params->valid_devs[0],
1304                         &ut_params->cipher_xform);
1305         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1306
1307         /* Generate crypto op data structure */
1308         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1309                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1310         TEST_ASSERT_NOT_NULL(ut_params->op,
1311                         "Failed to allocate symmetric crypto operation struct");
1312
1313         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1314
1315         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1316
1317         /* set crypto operation source mbuf */
1318         sym_op->m_src = ut_params->ibuf;
1319
1320         /* Set crypto operation authentication parameters */
1321         sym_op->auth.digest.data = ut_params->digest;
1322         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1323                         ut_params->ibuf, QUOTE_512_BYTES);
1324         sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA1;
1325
1326         sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1327         sym_op->auth.data.length = QUOTE_512_BYTES;
1328
1329         /* Set crypto operation cipher parameters */
1330         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf,
1331                         CIPHER_IV_LENGTH_AES_CBC);
1332         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1333         sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1334
1335         rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv,
1336                         CIPHER_IV_LENGTH_AES_CBC);
1337
1338         sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1339         sym_op->cipher.data.length = QUOTE_512_BYTES;
1340
1341         /* Process crypto operation */
1342         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
1343                         ut_params->op), "failed to process sym crypto op");
1344
1345         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1346                         "crypto op processing failed");
1347
1348         /* Validate obuf */
1349         uint8_t *ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
1350                         uint8_t *, CIPHER_IV_LENGTH_AES_CBC);
1351
1352         TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext,
1353                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1354                         QUOTE_512_BYTES,
1355                         "ciphertext data not as expected");
1356
1357         uint8_t *digest = ciphertext + QUOTE_512_BYTES;
1358
1359         TEST_ASSERT_BUFFERS_ARE_EQUAL(digest,
1360                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
1361                         gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD ?
1362                                         TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
1363                                         DIGEST_BYTE_LENGTH_SHA1,
1364                         "Generated digest data not as expected");
1365
1366         return TEST_SUCCESS;
1367 }
1368
1369 /* ***** AES-CBC / HMAC-SHA512 Hash Tests ***** */
1370
1371 #define HMAC_KEY_LENGTH_SHA512  (DIGEST_BYTE_LENGTH_SHA512)
1372
1373 static uint8_t hmac_sha512_key[] = {
1374         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1375         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1376         0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1377         0x9a, 0xaf, 0x88, 0x1b, 0xb6, 0x8f, 0xf8, 0x60,
1378         0xa2, 0x5a, 0x7f, 0x3f, 0xf4, 0x72, 0x70, 0xf1,
1379         0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1380         0x47, 0x3a, 0x75, 0x61, 0x5C, 0xa2, 0x10, 0x76,
1381         0x9a, 0xaf, 0x77, 0x5b, 0xb6, 0x7f, 0xf7, 0x60 };
1382
1383 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest[] = {
1384         0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8,
1385         0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48,
1386         0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8,
1387         0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70,
1388         0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8,
1389         0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E,
1390         0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D,
1391         0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A };
1392
1393
1394
1395 static int
1396 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1397                 struct crypto_unittest_params *ut_params,
1398                 uint8_t *cipher_key,
1399                 uint8_t *hmac_key);
1400
1401 static int
1402 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
1403                 struct crypto_unittest_params *ut_params,
1404                 struct crypto_testsuite_params *ts_params,
1405                 const uint8_t *cipher,
1406                 const uint8_t *digest,
1407                 const uint8_t *iv);
1408
1409
1410 static int
1411 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1412                 struct crypto_unittest_params *ut_params,
1413                 uint8_t *cipher_key,
1414                 uint8_t *hmac_key)
1415 {
1416
1417         /* Setup Cipher Parameters */
1418         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1419         ut_params->cipher_xform.next = NULL;
1420
1421         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1422         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
1423         ut_params->cipher_xform.cipher.key.data = cipher_key;
1424         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1425
1426         /* Setup HMAC Parameters */
1427         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1428         ut_params->auth_xform.next = &ut_params->cipher_xform;
1429
1430         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
1431         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC;
1432         ut_params->auth_xform.auth.key.data = hmac_key;
1433         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512;
1434         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512;
1435
1436         return TEST_SUCCESS;
1437 }
1438
1439
1440 static int
1441 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
1442                 struct crypto_unittest_params *ut_params,
1443                 struct crypto_testsuite_params *ts_params,
1444                 const uint8_t *cipher,
1445                 const uint8_t *digest,
1446                 const uint8_t *iv)
1447 {
1448         /* Generate test mbuf data and digest */
1449         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1450                         (const char *)
1451                         cipher,
1452                         QUOTE_512_BYTES, 0);
1453
1454         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1455                         DIGEST_BYTE_LENGTH_SHA512);
1456         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1457
1458         rte_memcpy(ut_params->digest,
1459                         digest,
1460                         DIGEST_BYTE_LENGTH_SHA512);
1461
1462         /* Generate Crypto op data structure */
1463         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1464                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1465         TEST_ASSERT_NOT_NULL(ut_params->op,
1466                         "Failed to allocate symmetric crypto operation struct");
1467
1468         rte_crypto_op_attach_sym_session(ut_params->op, sess);
1469
1470         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1471
1472         /* set crypto operation source mbuf */
1473         sym_op->m_src = ut_params->ibuf;
1474
1475         sym_op->auth.digest.data = ut_params->digest;
1476         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
1477                         ut_params->ibuf, QUOTE_512_BYTES);
1478         sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA512;
1479
1480         sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1481         sym_op->auth.data.length = QUOTE_512_BYTES;
1482
1483         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
1484                         ut_params->ibuf, CIPHER_IV_LENGTH_AES_CBC);
1485         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys_offset(
1486                         ut_params->ibuf, 0);
1487         sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1488
1489         rte_memcpy(sym_op->cipher.iv.data, iv,
1490                         CIPHER_IV_LENGTH_AES_CBC);
1491
1492         sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1493         sym_op->cipher.data.length = QUOTE_512_BYTES;
1494
1495         /* Process crypto operation */
1496         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
1497                         ut_params->op), "failed to process sym crypto op");
1498
1499         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1500                         "crypto op processing failed");
1501
1502         ut_params->obuf = ut_params->op->sym->m_src;
1503
1504         /* Validate obuf */
1505         TEST_ASSERT_BUFFERS_ARE_EQUAL(
1506                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) +
1507                         CIPHER_IV_LENGTH_AES_CBC, catch_22_quote,
1508                         QUOTE_512_BYTES,
1509                         "Plaintext data not as expected");
1510
1511         /* Validate obuf */
1512         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1513                         "Digest verification failed");
1514
1515         return TEST_SUCCESS;
1516 }
1517
1518 static int
1519 test_AES_cipheronly_mb_all(void)
1520 {
1521         struct crypto_testsuite_params *ts_params = &testsuite_params;
1522         int status;
1523
1524         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1525                 ts_params->op_mpool, ts_params->valid_devs[0],
1526                 RTE_CRYPTODEV_AESNI_MB_PMD,
1527                 BLKCIPHER_AES_CIPHERONLY_TYPE);
1528
1529         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1530
1531         return TEST_SUCCESS;
1532 }
1533
1534 static int
1535 test_AES_docsis_mb_all(void)
1536 {
1537         struct crypto_testsuite_params *ts_params = &testsuite_params;
1538         int status;
1539
1540         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1541                 ts_params->op_mpool, ts_params->valid_devs[0],
1542                 RTE_CRYPTODEV_AESNI_MB_PMD,
1543                 BLKCIPHER_AES_DOCSIS_TYPE);
1544
1545         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1546
1547         return TEST_SUCCESS;
1548 }
1549
1550 static int
1551 test_authonly_mb_all(void)
1552 {
1553         struct crypto_testsuite_params *ts_params = &testsuite_params;
1554         int status;
1555
1556         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1557                 ts_params->op_mpool, ts_params->valid_devs[0],
1558                 RTE_CRYPTODEV_AESNI_MB_PMD,
1559                 BLKCIPHER_AUTHONLY_TYPE);
1560
1561         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1562
1563         return TEST_SUCCESS;
1564 }
1565
1566 static int
1567 test_AES_chain_mb_all(void)
1568 {
1569         struct crypto_testsuite_params *ts_params = &testsuite_params;
1570         int status;
1571
1572         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1573                 ts_params->op_mpool, ts_params->valid_devs[0],
1574                 RTE_CRYPTODEV_AESNI_MB_PMD,
1575                 BLKCIPHER_AES_CHAIN_TYPE);
1576
1577         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1578
1579         return TEST_SUCCESS;
1580 }
1581
1582 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
1583
1584 static int
1585 test_AES_cipheronly_scheduler_all(void)
1586 {
1587         struct crypto_testsuite_params *ts_params = &testsuite_params;
1588         int status;
1589
1590         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1591                 ts_params->op_mpool, ts_params->valid_devs[0],
1592                 RTE_CRYPTODEV_SCHEDULER_PMD,
1593                 BLKCIPHER_AES_CIPHERONLY_TYPE);
1594
1595         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1596
1597         return TEST_SUCCESS;
1598 }
1599
1600 static int
1601 test_AES_chain_scheduler_all(void)
1602 {
1603         struct crypto_testsuite_params *ts_params = &testsuite_params;
1604         int status;
1605
1606         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1607                 ts_params->op_mpool, ts_params->valid_devs[0],
1608                 RTE_CRYPTODEV_SCHEDULER_PMD,
1609                 BLKCIPHER_AES_CHAIN_TYPE);
1610
1611         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1612
1613         return TEST_SUCCESS;
1614 }
1615
1616 static int
1617 test_authonly_scheduler_all(void)
1618 {
1619         struct crypto_testsuite_params *ts_params = &testsuite_params;
1620         int status;
1621
1622         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1623                 ts_params->op_mpool, ts_params->valid_devs[0],
1624                 RTE_CRYPTODEV_SCHEDULER_PMD,
1625                 BLKCIPHER_AUTHONLY_TYPE);
1626
1627         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1628
1629         return TEST_SUCCESS;
1630 }
1631
1632 #endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
1633
1634 static int
1635 test_AES_chain_openssl_all(void)
1636 {
1637         struct crypto_testsuite_params *ts_params = &testsuite_params;
1638         int status;
1639
1640         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1641                 ts_params->op_mpool, ts_params->valid_devs[0],
1642                 RTE_CRYPTODEV_OPENSSL_PMD,
1643                 BLKCIPHER_AES_CHAIN_TYPE);
1644
1645         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1646
1647         return TEST_SUCCESS;
1648 }
1649
1650 static int
1651 test_AES_cipheronly_openssl_all(void)
1652 {
1653         struct crypto_testsuite_params *ts_params = &testsuite_params;
1654         int status;
1655
1656         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1657                 ts_params->op_mpool, ts_params->valid_devs[0],
1658                 RTE_CRYPTODEV_OPENSSL_PMD,
1659                 BLKCIPHER_AES_CIPHERONLY_TYPE);
1660
1661         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1662
1663         return TEST_SUCCESS;
1664 }
1665
1666 static int
1667 test_AES_chain_qat_all(void)
1668 {
1669         struct crypto_testsuite_params *ts_params = &testsuite_params;
1670         int status;
1671
1672         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1673                 ts_params->op_mpool, ts_params->valid_devs[0],
1674                 RTE_CRYPTODEV_QAT_SYM_PMD,
1675                 BLKCIPHER_AES_CHAIN_TYPE);
1676
1677         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1678
1679         return TEST_SUCCESS;
1680 }
1681
1682 static int
1683 test_AES_cipheronly_qat_all(void)
1684 {
1685         struct crypto_testsuite_params *ts_params = &testsuite_params;
1686         int status;
1687
1688         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1689                 ts_params->op_mpool, ts_params->valid_devs[0],
1690                 RTE_CRYPTODEV_QAT_SYM_PMD,
1691                 BLKCIPHER_AES_CIPHERONLY_TYPE);
1692
1693         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1694
1695         return TEST_SUCCESS;
1696 }
1697
1698 static int
1699 test_authonly_openssl_all(void)
1700 {
1701         struct crypto_testsuite_params *ts_params = &testsuite_params;
1702         int status;
1703
1704         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1705                 ts_params->op_mpool, ts_params->valid_devs[0],
1706                 RTE_CRYPTODEV_OPENSSL_PMD,
1707                 BLKCIPHER_AUTHONLY_TYPE);
1708
1709         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1710
1711         return TEST_SUCCESS;
1712 }
1713
1714 static int
1715 test_AES_chain_armv8_all(void)
1716 {
1717         struct crypto_testsuite_params *ts_params = &testsuite_params;
1718         int status;
1719
1720         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1721                 ts_params->op_mpool, ts_params->valid_devs[0],
1722                 RTE_CRYPTODEV_ARMV8_PMD,
1723                 BLKCIPHER_AES_CHAIN_TYPE);
1724
1725         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1726
1727         return TEST_SUCCESS;
1728 }
1729
1730 /* ***** SNOW 3G Tests ***** */
1731 static int
1732 create_wireless_algo_hash_session(uint8_t dev_id,
1733         const uint8_t *key, const uint8_t key_len,
1734         const uint8_t aad_len, const uint8_t auth_len,
1735         enum rte_crypto_auth_operation op,
1736         enum rte_crypto_auth_algorithm algo)
1737 {
1738         uint8_t hash_key[key_len];
1739
1740         struct crypto_unittest_params *ut_params = &unittest_params;
1741
1742         memcpy(hash_key, key, key_len);
1743
1744         TEST_HEXDUMP(stdout, "key:", key, key_len);
1745
1746         /* Setup Authentication Parameters */
1747         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1748         ut_params->auth_xform.next = NULL;
1749
1750         ut_params->auth_xform.auth.op = op;
1751         ut_params->auth_xform.auth.algo = algo;
1752         ut_params->auth_xform.auth.key.length = key_len;
1753         ut_params->auth_xform.auth.key.data = hash_key;
1754         ut_params->auth_xform.auth.digest_length = auth_len;
1755         ut_params->auth_xform.auth.add_auth_data_length = aad_len;
1756         ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
1757                                 &ut_params->auth_xform);
1758         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1759         return 0;
1760 }
1761
1762 static int
1763 create_wireless_algo_cipher_session(uint8_t dev_id,
1764                         enum rte_crypto_cipher_operation op,
1765                         enum rte_crypto_cipher_algorithm algo,
1766                         const uint8_t *key, const uint8_t key_len)
1767 {
1768         uint8_t cipher_key[key_len];
1769
1770         struct crypto_unittest_params *ut_params = &unittest_params;
1771
1772         memcpy(cipher_key, key, key_len);
1773
1774         /* Setup Cipher Parameters */
1775         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1776         ut_params->cipher_xform.next = NULL;
1777
1778         ut_params->cipher_xform.cipher.algo = algo;
1779         ut_params->cipher_xform.cipher.op = op;
1780         ut_params->cipher_xform.cipher.key.data = cipher_key;
1781         ut_params->cipher_xform.cipher.key.length = key_len;
1782
1783         TEST_HEXDUMP(stdout, "key:", key, key_len);
1784
1785         /* Create Crypto session */
1786         ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
1787                                                 &ut_params->
1788                                                 cipher_xform);
1789         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1790         return 0;
1791 }
1792
1793 static int
1794 create_wireless_algo_cipher_operation(const uint8_t *iv, const unsigned iv_len,
1795                         const unsigned cipher_len,
1796                         const unsigned cipher_offset,
1797                         enum rte_crypto_cipher_algorithm algo)
1798 {
1799         struct crypto_testsuite_params *ts_params = &testsuite_params;
1800         struct crypto_unittest_params *ut_params = &unittest_params;
1801         unsigned iv_pad_len = 0;
1802
1803         /* Generate Crypto op data structure */
1804         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1805                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1806         TEST_ASSERT_NOT_NULL(ut_params->op,
1807                                 "Failed to allocate pktmbuf offload");
1808
1809         /* Set crypto operation data parameters */
1810         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1811
1812         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1813
1814         /* set crypto operation source mbuf */
1815         sym_op->m_src = ut_params->ibuf;
1816
1817         /* iv */
1818         if (algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
1819                 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
1820         else
1821                 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
1822
1823         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf
1824                         , iv_pad_len);
1825
1826         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
1827
1828         memset(sym_op->cipher.iv.data, 0, iv_pad_len);
1829         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1830         sym_op->cipher.iv.length = iv_pad_len;
1831
1832         rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
1833         sym_op->cipher.data.length = cipher_len;
1834         sym_op->cipher.data.offset = cipher_offset;
1835         return 0;
1836 }
1837
1838 static int
1839 create_wireless_algo_cipher_operation_oop(const uint8_t *iv, const uint8_t iv_len,
1840                         const unsigned cipher_len,
1841                         const unsigned cipher_offset,
1842                         enum rte_crypto_cipher_algorithm algo)
1843 {
1844         struct crypto_testsuite_params *ts_params = &testsuite_params;
1845         struct crypto_unittest_params *ut_params = &unittest_params;
1846         unsigned iv_pad_len = 0;
1847
1848         /* Generate Crypto op data structure */
1849         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1850                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1851         TEST_ASSERT_NOT_NULL(ut_params->op,
1852                                 "Failed to allocate pktmbuf offload");
1853
1854         /* Set crypto operation data parameters */
1855         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1856
1857         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1858
1859         /* set crypto operation source mbuf */
1860         sym_op->m_src = ut_params->ibuf;
1861         sym_op->m_dst = ut_params->obuf;
1862
1863         /* iv */
1864         if (algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
1865                 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
1866         else
1867                 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
1868         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf,
1869                                         iv_pad_len);
1870
1871         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
1872
1873         /* For OOP operation both buffers must have the same size */
1874         if (ut_params->obuf)
1875                 rte_pktmbuf_prepend(ut_params->obuf, iv_pad_len);
1876
1877         memset(sym_op->cipher.iv.data, 0, iv_pad_len);
1878         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
1879         sym_op->cipher.iv.length = iv_pad_len;
1880
1881         rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
1882         sym_op->cipher.data.length = cipher_len;
1883         sym_op->cipher.data.offset = cipher_offset;
1884         return 0;
1885 }
1886
1887 static int
1888 create_wireless_algo_cipher_auth_session(uint8_t dev_id,
1889                 enum rte_crypto_cipher_operation cipher_op,
1890                 enum rte_crypto_auth_operation auth_op,
1891                 enum rte_crypto_auth_algorithm auth_algo,
1892                 enum rte_crypto_cipher_algorithm cipher_algo,
1893                 const uint8_t *key, const uint8_t key_len,
1894                 const uint8_t aad_len, const uint8_t auth_len)
1895
1896 {
1897         uint8_t cipher_auth_key[key_len];
1898
1899         struct crypto_unittest_params *ut_params = &unittest_params;
1900
1901         memcpy(cipher_auth_key, key, key_len);
1902
1903         /* Setup Authentication Parameters */
1904         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1905         ut_params->auth_xform.next = NULL;
1906
1907         ut_params->auth_xform.auth.op = auth_op;
1908         ut_params->auth_xform.auth.algo = auth_algo;
1909         ut_params->auth_xform.auth.key.length = key_len;
1910         /* Hash key = cipher key */
1911         ut_params->auth_xform.auth.key.data = cipher_auth_key;
1912         ut_params->auth_xform.auth.digest_length = auth_len;
1913         ut_params->auth_xform.auth.add_auth_data_length = aad_len;
1914
1915         /* Setup Cipher Parameters */
1916         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1917         ut_params->cipher_xform.next = &ut_params->auth_xform;
1918
1919         ut_params->cipher_xform.cipher.algo = cipher_algo;
1920         ut_params->cipher_xform.cipher.op = cipher_op;
1921         ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
1922         ut_params->cipher_xform.cipher.key.length = key_len;
1923
1924         TEST_HEXDUMP(stdout, "key:", key, key_len);
1925
1926         /* Create Crypto session*/
1927         ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
1928                                 &ut_params->cipher_xform);
1929
1930         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1931         return 0;
1932 }
1933
1934 static int
1935 create_wireless_algo_auth_cipher_session(uint8_t dev_id,
1936                 enum rte_crypto_cipher_operation cipher_op,
1937                 enum rte_crypto_auth_operation auth_op,
1938                 enum rte_crypto_auth_algorithm auth_algo,
1939                 enum rte_crypto_cipher_algorithm cipher_algo,
1940                 const uint8_t *key, const uint8_t key_len,
1941                 const uint8_t aad_len, const uint8_t auth_len)
1942 {
1943         uint8_t auth_cipher_key[key_len];
1944
1945         struct crypto_unittest_params *ut_params = &unittest_params;
1946
1947         memcpy(auth_cipher_key, key, key_len);
1948
1949         /* Setup Authentication Parameters */
1950         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1951         ut_params->auth_xform.auth.op = auth_op;
1952         ut_params->auth_xform.next = &ut_params->cipher_xform;
1953         ut_params->auth_xform.auth.algo = auth_algo;
1954         ut_params->auth_xform.auth.key.length = key_len;
1955         ut_params->auth_xform.auth.key.data = auth_cipher_key;
1956         ut_params->auth_xform.auth.digest_length = auth_len;
1957         ut_params->auth_xform.auth.add_auth_data_length = aad_len;
1958
1959         /* Setup Cipher Parameters */
1960         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1961         ut_params->cipher_xform.next = NULL;
1962         ut_params->cipher_xform.cipher.algo = cipher_algo;
1963         ut_params->cipher_xform.cipher.op = cipher_op;
1964         ut_params->cipher_xform.cipher.key.data = auth_cipher_key;
1965         ut_params->cipher_xform.cipher.key.length = key_len;
1966
1967         TEST_HEXDUMP(stdout, "key:", key, key_len);
1968
1969         /* Create Crypto session*/
1970         ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
1971                                 &ut_params->auth_xform);
1972
1973         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1974
1975         return 0;
1976 }
1977
1978 static int
1979 create_wireless_algo_hash_operation(const uint8_t *auth_tag,
1980                 const unsigned auth_tag_len,
1981                 const uint8_t *aad, const unsigned aad_len,
1982                 unsigned data_pad_len,
1983                 enum rte_crypto_auth_operation op,
1984                 enum rte_crypto_auth_algorithm algo,
1985                 const unsigned auth_len, const unsigned auth_offset)
1986 {
1987         struct crypto_testsuite_params *ts_params = &testsuite_params;
1988
1989         struct crypto_unittest_params *ut_params = &unittest_params;
1990
1991         unsigned aad_buffer_len;
1992
1993         /* Generate Crypto op data structure */
1994         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1995                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1996         TEST_ASSERT_NOT_NULL(ut_params->op,
1997                 "Failed to allocate pktmbuf offload");
1998
1999         /* Set crypto operation data parameters */
2000         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2001
2002         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2003
2004         /* set crypto operation source mbuf */
2005         sym_op->m_src = ut_params->ibuf;
2006
2007         /* aad */
2008         /*
2009         * Always allocate the aad up to the block size.
2010         * The cryptodev API calls out -
2011         *  - the array must be big enough to hold the AAD, plus any
2012         *   space to round this up to the nearest multiple of the
2013         *   block size (8 bytes for KASUMI and 16 bytes for SNOW 3G).
2014         */
2015         if (algo == RTE_CRYPTO_AUTH_KASUMI_F9)
2016                 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 8);
2017         else
2018                 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
2019         sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend(
2020                         ut_params->ibuf, aad_buffer_len);
2021         TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
2022                                         "no room to prepend aad");
2023         sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
2024                         ut_params->ibuf);
2025         sym_op->auth.aad.length = aad_len;
2026
2027         memset(sym_op->auth.aad.data, 0, aad_buffer_len);
2028         rte_memcpy(sym_op->auth.aad.data, aad, aad_len);
2029
2030         TEST_HEXDUMP(stdout, "aad:",
2031                         sym_op->auth.aad.data, aad_len);
2032
2033         /* digest */
2034         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2035                                         ut_params->ibuf, auth_tag_len);
2036
2037         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2038                                 "no room to append auth tag");
2039         ut_params->digest = sym_op->auth.digest.data;
2040         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
2041                         ut_params->ibuf, data_pad_len + aad_len);
2042         sym_op->auth.digest.length = auth_tag_len;
2043         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2044                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2045         else
2046                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2047
2048         TEST_HEXDUMP(stdout, "digest:",
2049                 sym_op->auth.digest.data,
2050                 sym_op->auth.digest.length);
2051
2052         sym_op->auth.data.length = auth_len;
2053         sym_op->auth.data.offset = auth_offset;
2054
2055         return 0;
2056 }
2057
2058 static int
2059 create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
2060                 const unsigned auth_tag_len,
2061                 const uint8_t *aad, const uint8_t aad_len,
2062                 unsigned data_pad_len,
2063                 enum rte_crypto_auth_operation op,
2064                 enum rte_crypto_auth_algorithm auth_algo,
2065                 enum rte_crypto_cipher_algorithm cipher_algo,
2066                 const uint8_t *iv, const uint8_t iv_len,
2067                 const unsigned cipher_len, const unsigned cipher_offset,
2068                 const unsigned auth_len, const unsigned auth_offset)
2069 {
2070         struct crypto_testsuite_params *ts_params = &testsuite_params;
2071         struct crypto_unittest_params *ut_params = &unittest_params;
2072
2073         unsigned iv_pad_len = 0;
2074         unsigned aad_buffer_len;
2075
2076         /* Generate Crypto op data structure */
2077         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2078                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2079         TEST_ASSERT_NOT_NULL(ut_params->op,
2080                         "Failed to allocate pktmbuf offload");
2081         /* Set crypto operation data parameters */
2082         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2083
2084         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2085
2086         /* set crypto operation source mbuf */
2087         sym_op->m_src = ut_params->ibuf;
2088
2089         /* digest */
2090         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2091                         ut_params->ibuf, auth_tag_len);
2092
2093         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2094                         "no room to append auth tag");
2095         ut_params->digest = sym_op->auth.digest.data;
2096         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
2097                         ut_params->ibuf, data_pad_len);
2098         sym_op->auth.digest.length = auth_tag_len;
2099         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2100                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2101         else
2102                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2103
2104         TEST_HEXDUMP(stdout, "digest:",
2105                 sym_op->auth.digest.data,
2106                 sym_op->auth.digest.length);
2107
2108         /* aad */
2109         /*
2110         * Always allocate the aad up to the block size.
2111         * The cryptodev API calls out -
2112         *  - the array must be big enough to hold the AAD, plus any
2113         *   space to round this up to the nearest multiple of the
2114         *   block size (8 bytes for KASUMI and 16 bytes for SNOW 3G).
2115         */
2116         if (auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9)
2117                 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 8);
2118         else
2119                 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
2120         sym_op->auth.aad.data =
2121                 (uint8_t *)rte_pktmbuf_prepend(
2122                         ut_params->ibuf, aad_buffer_len);
2123         TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
2124                         "no room to prepend aad");
2125         sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
2126                         ut_params->ibuf);
2127         sym_op->auth.aad.length = aad_len;
2128         memset(sym_op->auth.aad.data, 0, aad_buffer_len);
2129         rte_memcpy(sym_op->auth.aad.data, aad, aad_len);
2130         TEST_HEXDUMP(stdout, "aad:", sym_op->auth.aad.data, aad_len);
2131
2132         /* iv */
2133         if (cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
2134                 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
2135         else
2136                 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
2137         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
2138                 ut_params->ibuf, iv_pad_len);
2139
2140         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
2141         memset(sym_op->cipher.iv.data, 0, iv_pad_len);
2142         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
2143         sym_op->cipher.iv.length = iv_pad_len;
2144         rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
2145         sym_op->cipher.data.length = cipher_len;
2146         sym_op->cipher.data.offset = cipher_offset + auth_offset;
2147         sym_op->auth.data.length = auth_len;
2148         sym_op->auth.data.offset = auth_offset + cipher_offset;
2149
2150         return 0;
2151 }
2152
2153 static int
2154 create_wireless_algo_auth_cipher_operation(const unsigned auth_tag_len,
2155                 const uint8_t *iv, const uint8_t iv_len,
2156                 const uint8_t *aad, const uint8_t aad_len,
2157                 unsigned data_pad_len,
2158                 const unsigned cipher_len, const unsigned cipher_offset,
2159                 const unsigned auth_len, const unsigned auth_offset,
2160                 enum rte_crypto_auth_algorithm auth_algo,
2161                 enum rte_crypto_cipher_algorithm cipher_algo)
2162 {
2163         struct crypto_testsuite_params *ts_params = &testsuite_params;
2164         struct crypto_unittest_params *ut_params = &unittest_params;
2165
2166         unsigned iv_pad_len = 0;
2167         unsigned aad_buffer_len = 0;
2168
2169         /* Generate Crypto op data structure */
2170         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2171                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2172         TEST_ASSERT_NOT_NULL(ut_params->op,
2173                         "Failed to allocate pktmbuf offload");
2174
2175         /* Set crypto operation data parameters */
2176         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2177
2178         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2179
2180         /* set crypto operation source mbuf */
2181         sym_op->m_src = ut_params->ibuf;
2182
2183         /* digest */
2184         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2185                         ut_params->ibuf, auth_tag_len);
2186
2187         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2188                         "no room to append auth tag");
2189
2190         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
2191                         ut_params->ibuf, data_pad_len);
2192         sym_op->auth.digest.length = auth_tag_len;
2193
2194         memset(sym_op->auth.digest.data, 0, auth_tag_len);
2195
2196         TEST_HEXDUMP(stdout, "digest:",
2197                         sym_op->auth.digest.data,
2198                         sym_op->auth.digest.length);
2199
2200         /* aad */
2201         /*
2202         * Always allocate the aad up to the block size.
2203         * The cryptodev API calls out -
2204         *  - the array must be big enough to hold the AAD, plus any
2205         *   space to round this up to the nearest multiple of the
2206         *   block size (8 bytes for KASUMI 16 bytes).
2207         */
2208         if (auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9)
2209                 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 8);
2210         else
2211                 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16);
2212         sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend(
2213         ut_params->ibuf, aad_buffer_len);
2214         TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
2215                                 "no room to prepend aad");
2216         sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
2217                                 ut_params->ibuf);
2218         sym_op->auth.aad.length = aad_len;
2219         memset(sym_op->auth.aad.data, 0, aad_buffer_len);
2220         rte_memcpy(sym_op->auth.aad.data, aad, aad_len);
2221         TEST_HEXDUMP(stdout, "aad:",
2222                         sym_op->auth.aad.data, aad_len);
2223
2224         /* iv */
2225         if (cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8)
2226                 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8);
2227         else
2228                 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
2229
2230         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
2231                 ut_params->ibuf, iv_pad_len);
2232         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
2233
2234         memset(sym_op->cipher.iv.data, 0, iv_pad_len);
2235         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
2236         sym_op->cipher.iv.length = iv_pad_len;
2237
2238         rte_memcpy(sym_op->cipher.iv.data, iv, iv_len);
2239
2240         sym_op->cipher.data.length = cipher_len;
2241         sym_op->cipher.data.offset = auth_offset + cipher_offset;
2242
2243         sym_op->auth.data.length = auth_len;
2244         sym_op->auth.data.offset = auth_offset + cipher_offset;
2245
2246         return 0;
2247 }
2248
2249 static int
2250 test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
2251 {
2252         struct crypto_testsuite_params *ts_params = &testsuite_params;
2253         struct crypto_unittest_params *ut_params = &unittest_params;
2254
2255         int retval;
2256         unsigned plaintext_pad_len;
2257         unsigned plaintext_len;
2258         uint8_t *plaintext;
2259
2260         /* Create SNOW 3G session */
2261         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2262                         tdata->key.data, tdata->key.len,
2263                         tdata->aad.len, tdata->digest.len,
2264                         RTE_CRYPTO_AUTH_OP_GENERATE,
2265                         RTE_CRYPTO_AUTH_SNOW3G_UIA2);
2266         if (retval < 0)
2267                 return retval;
2268
2269         /* alloc mbuf and set payload */
2270         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2271
2272         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2273         rte_pktmbuf_tailroom(ut_params->ibuf));
2274
2275         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2276         /* Append data which is padded to a multiple of */
2277         /* the algorithms block size */
2278         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2279         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2280                                 plaintext_pad_len);
2281         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2282
2283         /* Create SNOW 3G operation */
2284         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
2285                         tdata->aad.data, tdata->aad.len,
2286                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
2287                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
2288                         tdata->validAuthLenInBits.len,
2289                         tdata->validAuthOffsetLenInBits.len);
2290         if (retval < 0)
2291                 return retval;
2292
2293         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2294                                 ut_params->op);
2295         ut_params->obuf = ut_params->op->sym->m_src;
2296         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2297         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2298                         + plaintext_pad_len + tdata->aad.len;
2299
2300         /* Validate obuf */
2301         TEST_ASSERT_BUFFERS_ARE_EQUAL(
2302         ut_params->digest,
2303         tdata->digest.data,
2304         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
2305         "SNOW 3G Generated auth tag not as expected");
2306
2307         return 0;
2308 }
2309
2310 static int
2311 test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
2312 {
2313         struct crypto_testsuite_params *ts_params = &testsuite_params;
2314         struct crypto_unittest_params *ut_params = &unittest_params;
2315
2316         int retval;
2317         unsigned plaintext_pad_len;
2318         unsigned plaintext_len;
2319         uint8_t *plaintext;
2320
2321         /* Create SNOW 3G session */
2322         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2323                                 tdata->key.data, tdata->key.len,
2324                                 tdata->aad.len, tdata->digest.len,
2325                                 RTE_CRYPTO_AUTH_OP_VERIFY,
2326                                 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
2327         if (retval < 0)
2328                 return retval;
2329         /* alloc mbuf and set payload */
2330         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2331
2332         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2333         rte_pktmbuf_tailroom(ut_params->ibuf));
2334
2335         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2336         /* Append data which is padded to a multiple of */
2337         /* the algorithms block size */
2338         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2339         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2340                                 plaintext_pad_len);
2341         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2342
2343         /* Create SNOW 3G operation */
2344         retval = create_wireless_algo_hash_operation(tdata->digest.data,
2345                         tdata->digest.len,
2346                         tdata->aad.data, tdata->aad.len,
2347                         plaintext_pad_len,
2348                         RTE_CRYPTO_AUTH_OP_VERIFY,
2349                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
2350                         tdata->validAuthLenInBits.len,
2351                         tdata->validAuthOffsetLenInBits.len);
2352         if (retval < 0)
2353                 return retval;
2354
2355         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2356                                 ut_params->op);
2357         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2358         ut_params->obuf = ut_params->op->sym->m_src;
2359         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2360                                 + plaintext_pad_len + tdata->aad.len;
2361
2362         /* Validate obuf */
2363         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
2364                 return 0;
2365         else
2366                 return -1;
2367
2368         return 0;
2369 }
2370
2371 static int
2372 test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
2373 {
2374         struct crypto_testsuite_params *ts_params = &testsuite_params;
2375         struct crypto_unittest_params *ut_params = &unittest_params;
2376
2377         int retval;
2378         unsigned plaintext_pad_len;
2379         unsigned plaintext_len;
2380         uint8_t *plaintext;
2381
2382         /* Create KASUMI session */
2383         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2384                         tdata->key.data, tdata->key.len,
2385                         tdata->aad.len, tdata->digest.len,
2386                         RTE_CRYPTO_AUTH_OP_GENERATE,
2387                         RTE_CRYPTO_AUTH_KASUMI_F9);
2388         if (retval < 0)
2389                 return retval;
2390
2391         /* alloc mbuf and set payload */
2392         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2393
2394         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2395         rte_pktmbuf_tailroom(ut_params->ibuf));
2396
2397         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2398         /* Append data which is padded to a multiple of */
2399         /* the algorithms block size */
2400         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2401         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2402                                 plaintext_pad_len);
2403         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2404
2405         /* Create KASUMI operation */
2406         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
2407                         tdata->aad.data, tdata->aad.len,
2408                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
2409                         RTE_CRYPTO_AUTH_KASUMI_F9,
2410                         tdata->validAuthLenInBits.len,
2411                         tdata->validAuthOffsetLenInBits.len);
2412         if (retval < 0)
2413                 return retval;
2414
2415         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2416                                 ut_params->op);
2417         ut_params->obuf = ut_params->op->sym->m_src;
2418         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2419         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2420                         + plaintext_pad_len + ALIGN_POW2_ROUNDUP(tdata->aad.len, 8);
2421
2422         /* Validate obuf */
2423         TEST_ASSERT_BUFFERS_ARE_EQUAL(
2424         ut_params->digest,
2425         tdata->digest.data,
2426         DIGEST_BYTE_LENGTH_KASUMI_F9,
2427         "KASUMI Generated auth tag not as expected");
2428
2429         return 0;
2430 }
2431
2432 static int
2433 test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
2434 {
2435         struct crypto_testsuite_params *ts_params = &testsuite_params;
2436         struct crypto_unittest_params *ut_params = &unittest_params;
2437
2438         int retval;
2439         unsigned plaintext_pad_len;
2440         unsigned plaintext_len;
2441         uint8_t *plaintext;
2442
2443         /* Create KASUMI session */
2444         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2445                                 tdata->key.data, tdata->key.len,
2446                                 tdata->aad.len, tdata->digest.len,
2447                                 RTE_CRYPTO_AUTH_OP_VERIFY,
2448                                 RTE_CRYPTO_AUTH_KASUMI_F9);
2449         if (retval < 0)
2450                 return retval;
2451         /* alloc mbuf and set payload */
2452         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2453
2454         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2455         rte_pktmbuf_tailroom(ut_params->ibuf));
2456
2457         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2458         /* Append data which is padded to a multiple */
2459         /* of the algorithms block size */
2460         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2461         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2462                                 plaintext_pad_len);
2463         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2464
2465         /* Create KASUMI operation */
2466         retval = create_wireless_algo_hash_operation(tdata->digest.data,
2467                         tdata->digest.len,
2468                         tdata->aad.data, tdata->aad.len,
2469                         plaintext_pad_len,
2470                         RTE_CRYPTO_AUTH_OP_VERIFY,
2471                         RTE_CRYPTO_AUTH_KASUMI_F9,
2472                         tdata->validAuthLenInBits.len,
2473                         tdata->validAuthOffsetLenInBits.len);
2474         if (retval < 0)
2475                 return retval;
2476
2477         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2478                                 ut_params->op);
2479         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2480         ut_params->obuf = ut_params->op->sym->m_src;
2481         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2482                                 + plaintext_pad_len + tdata->aad.len;
2483
2484         /* Validate obuf */
2485         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
2486                 return 0;
2487         else
2488                 return -1;
2489
2490         return 0;
2491 }
2492
2493 static int
2494 test_snow3g_hash_generate_test_case_1(void)
2495 {
2496         return test_snow3g_authentication(&snow3g_hash_test_case_1);
2497 }
2498
2499 static int
2500 test_snow3g_hash_generate_test_case_2(void)
2501 {
2502         return test_snow3g_authentication(&snow3g_hash_test_case_2);
2503 }
2504
2505 static int
2506 test_snow3g_hash_generate_test_case_3(void)
2507 {
2508         return test_snow3g_authentication(&snow3g_hash_test_case_3);
2509 }
2510
2511 static int
2512 test_snow3g_hash_generate_test_case_4(void)
2513 {
2514         return test_snow3g_authentication(&snow3g_hash_test_case_4);
2515 }
2516
2517 static int
2518 test_snow3g_hash_generate_test_case_5(void)
2519 {
2520         return test_snow3g_authentication(&snow3g_hash_test_case_5);
2521 }
2522
2523 static int
2524 test_snow3g_hash_generate_test_case_6(void)
2525 {
2526         return test_snow3g_authentication(&snow3g_hash_test_case_6);
2527 }
2528
2529 static int
2530 test_snow3g_hash_verify_test_case_1(void)
2531 {
2532         return test_snow3g_authentication_verify(&snow3g_hash_test_case_1);
2533
2534 }
2535
2536 static int
2537 test_snow3g_hash_verify_test_case_2(void)
2538 {
2539         return test_snow3g_authentication_verify(&snow3g_hash_test_case_2);
2540 }
2541
2542 static int
2543 test_snow3g_hash_verify_test_case_3(void)
2544 {
2545         return test_snow3g_authentication_verify(&snow3g_hash_test_case_3);
2546 }
2547
2548 static int
2549 test_snow3g_hash_verify_test_case_4(void)
2550 {
2551         return test_snow3g_authentication_verify(&snow3g_hash_test_case_4);
2552 }
2553
2554 static int
2555 test_snow3g_hash_verify_test_case_5(void)
2556 {
2557         return test_snow3g_authentication_verify(&snow3g_hash_test_case_5);
2558 }
2559
2560 static int
2561 test_snow3g_hash_verify_test_case_6(void)
2562 {
2563         return test_snow3g_authentication_verify(&snow3g_hash_test_case_6);
2564 }
2565
2566 static int
2567 test_kasumi_hash_generate_test_case_1(void)
2568 {
2569         return test_kasumi_authentication(&kasumi_hash_test_case_1);
2570 }
2571
2572 static int
2573 test_kasumi_hash_generate_test_case_2(void)
2574 {
2575         return test_kasumi_authentication(&kasumi_hash_test_case_2);
2576 }
2577
2578 static int
2579 test_kasumi_hash_generate_test_case_3(void)
2580 {
2581         return test_kasumi_authentication(&kasumi_hash_test_case_3);
2582 }
2583
2584 static int
2585 test_kasumi_hash_generate_test_case_4(void)
2586 {
2587         return test_kasumi_authentication(&kasumi_hash_test_case_4);
2588 }
2589
2590 static int
2591 test_kasumi_hash_generate_test_case_5(void)
2592 {
2593         return test_kasumi_authentication(&kasumi_hash_test_case_5);
2594 }
2595
2596 static int
2597 test_kasumi_hash_generate_test_case_6(void)
2598 {
2599         return test_kasumi_authentication(&kasumi_hash_test_case_6);
2600 }
2601
2602 static int
2603 test_kasumi_hash_verify_test_case_1(void)
2604 {
2605         return test_kasumi_authentication_verify(&kasumi_hash_test_case_1);
2606 }
2607
2608 static int
2609 test_kasumi_hash_verify_test_case_2(void)
2610 {
2611         return test_kasumi_authentication_verify(&kasumi_hash_test_case_2);
2612 }
2613
2614 static int
2615 test_kasumi_hash_verify_test_case_3(void)
2616 {
2617         return test_kasumi_authentication_verify(&kasumi_hash_test_case_3);
2618 }
2619
2620 static int
2621 test_kasumi_hash_verify_test_case_4(void)
2622 {
2623         return test_kasumi_authentication_verify(&kasumi_hash_test_case_4);
2624 }
2625
2626 static int
2627 test_kasumi_hash_verify_test_case_5(void)
2628 {
2629         return test_kasumi_authentication_verify(&kasumi_hash_test_case_5);
2630 }
2631
2632 static int
2633 test_kasumi_encryption(const struct kasumi_test_data *tdata)
2634 {
2635         struct crypto_testsuite_params *ts_params = &testsuite_params;
2636         struct crypto_unittest_params *ut_params = &unittest_params;
2637
2638         int retval;
2639         uint8_t *plaintext, *ciphertext;
2640         unsigned plaintext_pad_len;
2641         unsigned plaintext_len;
2642
2643         /* Create KASUMI session */
2644         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
2645                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2646                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
2647                                         tdata->key.data, tdata->key.len);
2648         if (retval < 0)
2649                 return retval;
2650
2651         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2652
2653         /* Clear mbuf payload */
2654         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2655                rte_pktmbuf_tailroom(ut_params->ibuf));
2656
2657         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2658         /* Append data which is padded to a multiple */
2659         /* of the algorithms block size */
2660         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2661         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2662                                 plaintext_pad_len);
2663         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2664
2665         TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
2666
2667         /* Create KASUMI operation */
2668         retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
2669                                         tdata->plaintext.len,
2670                                         tdata->validCipherOffsetLenInBits.len,
2671                                         RTE_CRYPTO_CIPHER_KASUMI_F8);
2672         if (retval < 0)
2673                 return retval;
2674
2675         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2676                                                 ut_params->op);
2677         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2678
2679         ut_params->obuf = ut_params->op->sym->m_dst;
2680         if (ut_params->obuf)
2681                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2682                                 + tdata->iv.len;
2683         else
2684                 ciphertext = plaintext;
2685
2686         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
2687
2688         /* Validate obuf */
2689         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2690                 ciphertext,
2691                 tdata->ciphertext.data,
2692                 tdata->validCipherLenInBits.len,
2693                 "KASUMI Ciphertext data not as expected");
2694         return 0;
2695 }
2696
2697 static int
2698 test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
2699 {
2700         struct crypto_testsuite_params *ts_params = &testsuite_params;
2701         struct crypto_unittest_params *ut_params = &unittest_params;
2702
2703         int retval;
2704
2705         unsigned int plaintext_pad_len;
2706         unsigned int plaintext_len;
2707
2708         uint8_t buffer[10000];
2709         const uint8_t *ciphertext;
2710
2711         struct rte_cryptodev_info dev_info;
2712
2713         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
2714         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_MBUF_SCATTER_GATHER)) {
2715                 printf("Device doesn't support scatter-gather. "
2716                                 "Test Skipped.\n");
2717                 return 0;
2718         }
2719
2720         /* Create KASUMI session */
2721         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
2722                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2723                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
2724                                         tdata->key.data, tdata->key.len);
2725         if (retval < 0)
2726                 return retval;
2727
2728         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2729
2730
2731         /* Append data which is padded to a multiple */
2732         /* of the algorithms block size */
2733         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2734
2735         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
2736                         plaintext_pad_len, 10, 0);
2737
2738         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
2739
2740         /* Create KASUMI operation */
2741         retval = create_wireless_algo_cipher_operation(tdata->iv.data,
2742                                         tdata->iv.len,
2743                                         tdata->plaintext.len,
2744                                         tdata->validCipherOffsetLenInBits.len,
2745                                         RTE_CRYPTO_CIPHER_KASUMI_F8);
2746         if (retval < 0)
2747                 return retval;
2748
2749         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2750                                                 ut_params->op);
2751         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2752
2753         ut_params->obuf = ut_params->op->sym->m_dst;
2754
2755         if (ut_params->obuf)
2756                 ciphertext = rte_pktmbuf_read(ut_params->obuf, tdata->iv.len,
2757                                 plaintext_len, buffer);
2758         else
2759                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, tdata->iv.len,
2760                                 plaintext_len, buffer);
2761
2762         /* Validate obuf */
2763         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
2764
2765                 /* Validate obuf */
2766                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2767                         ciphertext,
2768                         tdata->ciphertext.data,
2769                         tdata->validCipherLenInBits.len,
2770                         "KASUMI Ciphertext data not as expected");
2771                 return 0;
2772 }
2773
2774 static int
2775 test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
2776 {
2777         struct crypto_testsuite_params *ts_params = &testsuite_params;
2778         struct crypto_unittest_params *ut_params = &unittest_params;
2779
2780         int retval;
2781         uint8_t *plaintext, *ciphertext;
2782         unsigned plaintext_pad_len;
2783         unsigned plaintext_len;
2784
2785         /* Create KASUMI session */
2786         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
2787                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2788                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
2789                                         tdata->key.data, tdata->key.len);
2790         if (retval < 0)
2791                 return retval;
2792
2793         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2794         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2795
2796         /* Clear mbuf payload */
2797         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2798                rte_pktmbuf_tailroom(ut_params->ibuf));
2799
2800         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2801         /* Append data which is padded to a multiple */
2802         /* of the algorithms block size */
2803         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2804         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2805                                 plaintext_pad_len);
2806         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
2807         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2808
2809         TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
2810
2811         /* Create KASUMI operation */
2812         retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
2813                                         tdata->iv.len,
2814                                         tdata->plaintext.len,
2815                                         tdata->validCipherOffsetLenInBits.len,
2816                                         RTE_CRYPTO_CIPHER_KASUMI_F8);
2817         if (retval < 0)
2818                 return retval;
2819
2820         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2821                                                 ut_params->op);
2822         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2823
2824         ut_params->obuf = ut_params->op->sym->m_dst;
2825         if (ut_params->obuf)
2826                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2827                                 + tdata->iv.len;
2828         else
2829                 ciphertext = plaintext;
2830
2831         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
2832
2833         /* Validate obuf */
2834         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2835                 ciphertext,
2836                 tdata->ciphertext.data,
2837                 tdata->validCipherLenInBits.len,
2838                 "KASUMI Ciphertext data not as expected");
2839         return 0;
2840 }
2841
2842 static int
2843 test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
2844 {
2845         struct crypto_testsuite_params *ts_params = &testsuite_params;
2846         struct crypto_unittest_params *ut_params = &unittest_params;
2847
2848         int retval;
2849         unsigned int plaintext_pad_len;
2850         unsigned int plaintext_len;
2851
2852         const uint8_t *ciphertext;
2853         uint8_t buffer[2048];
2854
2855         struct rte_cryptodev_info dev_info;
2856
2857         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
2858         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_MBUF_SCATTER_GATHER)) {
2859                 printf("Device doesn't support scatter-gather. "
2860                                 "Test Skipped.\n");
2861                 return 0;
2862         }
2863
2864         /* Create KASUMI session */
2865         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
2866                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2867                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
2868                                         tdata->key.data, tdata->key.len);
2869         if (retval < 0)
2870                 return retval;
2871
2872         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2873         /* Append data which is padded to a multiple */
2874         /* of the algorithms block size */
2875         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2876
2877         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
2878                         plaintext_pad_len, 10, 0);
2879         ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
2880                         plaintext_pad_len, 3, 0);
2881
2882         /* Append data which is padded to a multiple */
2883         /* of the algorithms block size */
2884         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
2885
2886         /* Create KASUMI operation */
2887         retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
2888                                         tdata->iv.len,
2889                                         tdata->plaintext.len,
2890                                         tdata->validCipherOffsetLenInBits.len,
2891                                         RTE_CRYPTO_CIPHER_KASUMI_F8);
2892         if (retval < 0)
2893                 return retval;
2894
2895         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2896                                                 ut_params->op);
2897         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2898
2899         ut_params->obuf = ut_params->op->sym->m_dst;
2900         if (ut_params->obuf)
2901                 ciphertext = rte_pktmbuf_read(ut_params->obuf, tdata->iv.len,
2902                                 plaintext_pad_len, buffer);
2903         else
2904                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, tdata->iv.len,
2905                                 plaintext_pad_len, buffer);
2906
2907         /* Validate obuf */
2908         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2909                 ciphertext,
2910                 tdata->ciphertext.data,
2911                 tdata->validCipherLenInBits.len,
2912                 "KASUMI Ciphertext data not as expected");
2913         return 0;
2914 }
2915
2916
2917 static int
2918 test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
2919 {
2920         struct crypto_testsuite_params *ts_params = &testsuite_params;
2921         struct crypto_unittest_params *ut_params = &unittest_params;
2922
2923         int retval;
2924         uint8_t *ciphertext, *plaintext;
2925         unsigned ciphertext_pad_len;
2926         unsigned ciphertext_len;
2927
2928         /* Create KASUMI session */
2929         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
2930                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
2931                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
2932                                         tdata->key.data, tdata->key.len);
2933         if (retval < 0)
2934                 return retval;
2935
2936         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2937         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2938
2939         /* Clear mbuf payload */
2940         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2941                rte_pktmbuf_tailroom(ut_params->ibuf));
2942
2943         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
2944         /* Append data which is padded to a multiple */
2945         /* of the algorithms block size */
2946         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
2947         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2948                                 ciphertext_pad_len);
2949         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
2950         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
2951
2952         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
2953
2954         /* Create KASUMI operation */
2955         retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
2956                                         tdata->iv.len,
2957                                         tdata->ciphertext.len,
2958                                         tdata->validCipherOffsetLenInBits.len,
2959                                         RTE_CRYPTO_CIPHER_KASUMI_F8);
2960         if (retval < 0)
2961                 return retval;
2962
2963         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2964                                                 ut_params->op);
2965         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2966
2967         ut_params->obuf = ut_params->op->sym->m_dst;
2968         if (ut_params->obuf)
2969                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2970                                 + tdata->iv.len;
2971         else
2972                 plaintext = ciphertext;
2973
2974         TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
2975
2976         /* Validate obuf */
2977         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
2978                 plaintext,
2979                 tdata->plaintext.data,
2980                 tdata->validCipherLenInBits.len,
2981                 "KASUMI Plaintext data not as expected");
2982         return 0;
2983 }
2984
2985 static int
2986 test_kasumi_decryption(const struct kasumi_test_data *tdata)
2987 {
2988         struct crypto_testsuite_params *ts_params = &testsuite_params;
2989         struct crypto_unittest_params *ut_params = &unittest_params;
2990
2991         int retval;
2992         uint8_t *ciphertext, *plaintext;
2993         unsigned ciphertext_pad_len;
2994         unsigned ciphertext_len;
2995
2996         /* Create KASUMI session */
2997         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
2998                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
2999                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3000                                         tdata->key.data, tdata->key.len);
3001         if (retval < 0)
3002                 return retval;
3003
3004         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3005
3006         /* Clear mbuf payload */
3007         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3008                rte_pktmbuf_tailroom(ut_params->ibuf));
3009
3010         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3011         /* Append data which is padded to a multiple */
3012         /* of the algorithms block size */
3013         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
3014         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3015                                 ciphertext_pad_len);
3016         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3017
3018         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
3019
3020         /* Create KASUMI operation */
3021         retval = create_wireless_algo_cipher_operation(tdata->iv.data,
3022                                         tdata->iv.len,
3023                                         tdata->ciphertext.len,
3024                                         tdata->validCipherOffsetLenInBits.len,
3025                                         RTE_CRYPTO_CIPHER_KASUMI_F8);
3026         if (retval < 0)
3027                 return retval;
3028
3029         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3030                                                 ut_params->op);
3031         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3032
3033         ut_params->obuf = ut_params->op->sym->m_dst;
3034         if (ut_params->obuf)
3035                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3036                                 + tdata->iv.len;
3037         else
3038                 plaintext = ciphertext;
3039
3040         TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
3041
3042         /* Validate obuf */
3043         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3044                 plaintext,
3045                 tdata->plaintext.data,
3046                 tdata->validCipherLenInBits.len,
3047                 "KASUMI Plaintext data not as expected");
3048         return 0;
3049 }
3050
3051 static int
3052 test_snow3g_encryption(const struct snow3g_test_data *tdata)
3053 {
3054         struct crypto_testsuite_params *ts_params = &testsuite_params;
3055         struct crypto_unittest_params *ut_params = &unittest_params;
3056
3057         int retval;
3058         uint8_t *plaintext, *ciphertext;
3059         unsigned plaintext_pad_len;
3060         unsigned plaintext_len;
3061
3062         /* Create SNOW 3G session */
3063         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3064                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3065                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3066                                         tdata->key.data, tdata->key.len);
3067         if (retval < 0)
3068                 return retval;
3069
3070         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3071
3072         /* Clear mbuf payload */
3073         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3074                rte_pktmbuf_tailroom(ut_params->ibuf));
3075
3076         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3077         /* Append data which is padded to a multiple of */
3078         /* the algorithms block size */
3079         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3080         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3081                                 plaintext_pad_len);
3082         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3083
3084         TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3085
3086         /* Create SNOW 3G operation */
3087         retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
3088                                         tdata->validCipherLenInBits.len,
3089                                         tdata->validCipherOffsetLenInBits.len,
3090                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
3091         if (retval < 0)
3092                 return retval;
3093
3094         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3095                                                 ut_params->op);
3096         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3097
3098         ut_params->obuf = ut_params->op->sym->m_dst;
3099         if (ut_params->obuf)
3100                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3101                                 + tdata->iv.len;
3102         else
3103                 ciphertext = plaintext;
3104
3105         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3106
3107         /* Validate obuf */
3108         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3109                 ciphertext,
3110                 tdata->ciphertext.data,
3111                 tdata->validDataLenInBits.len,
3112                 "SNOW 3G Ciphertext data not as expected");
3113         return 0;
3114 }
3115
3116
3117 static int
3118 test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
3119 {
3120         struct crypto_testsuite_params *ts_params = &testsuite_params;
3121         struct crypto_unittest_params *ut_params = &unittest_params;
3122         uint8_t *plaintext, *ciphertext;
3123
3124         int retval;
3125         unsigned plaintext_pad_len;
3126         unsigned plaintext_len;
3127
3128         /* Create SNOW 3G session */
3129         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3130                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3131                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3132                                         tdata->key.data, tdata->key.len);
3133         if (retval < 0)
3134                 return retval;
3135
3136         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3137         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3138
3139         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3140                         "Failed to allocate input buffer in mempool");
3141         TEST_ASSERT_NOT_NULL(ut_params->obuf,
3142                         "Failed to allocate output buffer in mempool");
3143
3144         /* Clear mbuf payload */
3145         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3146                rte_pktmbuf_tailroom(ut_params->ibuf));
3147
3148         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3149         /* Append data which is padded to a multiple of */
3150         /* the algorithms block size */
3151         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3152         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3153                                 plaintext_pad_len);
3154         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3155         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3156
3157         TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3158
3159         /* Create SNOW 3G operation */
3160         retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
3161                                         tdata->iv.len,
3162                                         tdata->validCipherLenInBits.len,
3163                                         tdata->validCipherOffsetLenInBits.len,
3164                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
3165         if (retval < 0)
3166                 return retval;
3167
3168         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3169                                                 ut_params->op);
3170         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3171
3172         ut_params->obuf = ut_params->op->sym->m_dst;
3173         if (ut_params->obuf)
3174                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3175                                 + tdata->iv.len;
3176         else
3177                 ciphertext = plaintext;
3178
3179         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3180
3181         /* Validate obuf */
3182         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3183                 ciphertext,
3184                 tdata->ciphertext.data,
3185                 tdata->validDataLenInBits.len,
3186                 "SNOW 3G Ciphertext data not as expected");
3187         return 0;
3188 }
3189
3190 static int
3191 test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
3192 {
3193         struct crypto_testsuite_params *ts_params = &testsuite_params;
3194         struct crypto_unittest_params *ut_params = &unittest_params;
3195
3196         int retval;
3197         unsigned int plaintext_pad_len;
3198         unsigned int plaintext_len;
3199         uint8_t buffer[10000];
3200         const uint8_t *ciphertext;
3201
3202         struct rte_cryptodev_info dev_info;
3203
3204         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3205         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_MBUF_SCATTER_GATHER)) {
3206                 printf("Device doesn't support scatter-gather. "
3207                                 "Test Skipped.\n");
3208                 return 0;
3209         }
3210
3211         /* Create SNOW 3G session */
3212         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3213                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3214                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3215                                         tdata->key.data, tdata->key.len);
3216         if (retval < 0)
3217                 return retval;
3218
3219         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3220         /* Append data which is padded to a multiple of */
3221         /* the algorithms block size */
3222         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3223
3224         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3225                         plaintext_pad_len, 10, 0);
3226         ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
3227                         plaintext_pad_len, 3, 0);
3228
3229         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3230                         "Failed to allocate input buffer in mempool");
3231         TEST_ASSERT_NOT_NULL(ut_params->obuf,
3232                         "Failed to allocate output buffer in mempool");
3233
3234         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3235
3236         /* Create SNOW 3G operation */
3237         retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
3238                                         tdata->iv.len,
3239                                         tdata->validCipherLenInBits.len,
3240                                         tdata->validCipherOffsetLenInBits.len,
3241                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
3242         if (retval < 0)
3243                 return retval;
3244
3245         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3246                                                 ut_params->op);
3247         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3248
3249         ut_params->obuf = ut_params->op->sym->m_dst;
3250         if (ut_params->obuf)
3251                 ciphertext = rte_pktmbuf_read(ut_params->obuf, tdata->iv.len,
3252                                 plaintext_len, buffer);
3253         else
3254                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, tdata->iv.len,
3255                                 plaintext_len, buffer);
3256
3257         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3258
3259         /* Validate obuf */
3260         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3261                 ciphertext,
3262                 tdata->ciphertext.data,
3263                 tdata->validDataLenInBits.len,
3264                 "SNOW 3G Ciphertext data not as expected");
3265
3266         return 0;
3267 }
3268
3269 /* Shift right a buffer by "offset" bits, "offset" < 8 */
3270 static void
3271 buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset)
3272 {
3273         uint8_t curr_byte, prev_byte;
3274         uint32_t length_in_bytes = ceil_byte_length(length + offset);
3275         uint8_t lower_byte_mask = (1 << offset) - 1;
3276         unsigned i;
3277
3278         prev_byte = buffer[0];
3279         buffer[0] >>= offset;
3280
3281         for (i = 1; i < length_in_bytes; i++) {
3282                 curr_byte = buffer[i];
3283                 buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) |
3284                                 (curr_byte >> offset);
3285                 prev_byte = curr_byte;
3286         }
3287 }
3288
3289 static int
3290 test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
3291 {
3292         struct crypto_testsuite_params *ts_params = &testsuite_params;
3293         struct crypto_unittest_params *ut_params = &unittest_params;
3294         uint8_t *plaintext, *ciphertext;
3295         int retval;
3296         uint32_t plaintext_len;
3297         uint32_t plaintext_pad_len;
3298         uint8_t extra_offset = 4;
3299         uint8_t *expected_ciphertext_shifted;
3300
3301         /* Create SNOW 3G session */
3302         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3303                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3304                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3305                                         tdata->key.data, tdata->key.len);
3306         if (retval < 0)
3307                 return retval;
3308
3309         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3310         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3311
3312         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3313                         "Failed to allocate input buffer in mempool");
3314         TEST_ASSERT_NOT_NULL(ut_params->obuf,
3315                         "Failed to allocate output buffer in mempool");
3316
3317         /* Clear mbuf payload */
3318         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3319                rte_pktmbuf_tailroom(ut_params->ibuf));
3320
3321         plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset);
3322         /*
3323          * Append data which is padded to a
3324          * multiple of the algorithms block size
3325          */
3326         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3327
3328         plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf,
3329                                                 plaintext_pad_len);
3330
3331         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3332
3333         memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3));
3334         buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset);
3335
3336 #ifdef RTE_APP_TEST_DEBUG
3337         rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
3338 #endif
3339         /* Create SNOW 3G operation */
3340         retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
3341                                         tdata->iv.len,
3342                                         tdata->validCipherLenInBits.len,
3343                                         tdata->validCipherOffsetLenInBits.len +
3344                                         extra_offset,
3345                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
3346         if (retval < 0)
3347                 return retval;
3348
3349         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3350                                                 ut_params->op);
3351         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3352
3353         ut_params->obuf = ut_params->op->sym->m_dst;
3354         if (ut_params->obuf)
3355                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3356                                 + tdata->iv.len;
3357         else
3358                 ciphertext = plaintext;
3359
3360 #ifdef RTE_APP_TEST_DEBUG
3361         rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3362 #endif
3363
3364         expected_ciphertext_shifted = rte_malloc(NULL,
3365                         ceil_byte_length(plaintext_len + extra_offset), 0);
3366
3367         TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted,
3368                         "failed to reserve memory for ciphertext shifted\n");
3369
3370         memcpy(expected_ciphertext_shifted, tdata->ciphertext.data,
3371                         ceil_byte_length(tdata->ciphertext.len));
3372         buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len,
3373                         extra_offset);
3374         /* Validate obuf */
3375         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
3376                 ciphertext,
3377                 expected_ciphertext_shifted,
3378                 tdata->validDataLenInBits.len,
3379                 extra_offset,
3380                 "SNOW 3G Ciphertext data not as expected");
3381         return 0;
3382 }
3383
3384 static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
3385 {
3386         struct crypto_testsuite_params *ts_params = &testsuite_params;
3387         struct crypto_unittest_params *ut_params = &unittest_params;
3388
3389         int retval;
3390
3391         uint8_t *plaintext, *ciphertext;
3392         unsigned ciphertext_pad_len;
3393         unsigned ciphertext_len;
3394
3395         /* Create SNOW 3G session */
3396         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3397                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
3398                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3399                                         tdata->key.data, tdata->key.len);
3400         if (retval < 0)
3401                 return retval;
3402
3403         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3404
3405         /* Clear mbuf payload */
3406         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3407                rte_pktmbuf_tailroom(ut_params->ibuf));
3408
3409         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3410         /* Append data which is padded to a multiple of */
3411         /* the algorithms block size */
3412         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
3413         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3414                                 ciphertext_pad_len);
3415         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3416
3417         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
3418
3419         /* Create SNOW 3G operation */
3420         retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
3421                                         tdata->validCipherLenInBits.len,
3422                                         tdata->validCipherOffsetLenInBits.len,
3423                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
3424         if (retval < 0)
3425                 return retval;
3426
3427         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3428                                                 ut_params->op);
3429         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3430         ut_params->obuf = ut_params->op->sym->m_dst;
3431         if (ut_params->obuf)
3432                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3433                                 + tdata->iv.len;
3434         else
3435                 plaintext = ciphertext;
3436
3437         TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
3438
3439         /* Validate obuf */
3440         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
3441                                 tdata->plaintext.data,
3442                                 tdata->validDataLenInBits.len,
3443                                 "SNOW 3G Plaintext data not as expected");
3444         return 0;
3445 }
3446
3447 static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
3448 {
3449         struct crypto_testsuite_params *ts_params = &testsuite_params;
3450         struct crypto_unittest_params *ut_params = &unittest_params;
3451
3452         int retval;
3453
3454         uint8_t *plaintext, *ciphertext;
3455         unsigned ciphertext_pad_len;
3456         unsigned ciphertext_len;
3457
3458         /* Create SNOW 3G session */
3459         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3460                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
3461                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3462                                         tdata->key.data, tdata->key.len);
3463         if (retval < 0)
3464                 return retval;
3465
3466         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3467         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3468
3469         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3470                         "Failed to allocate input buffer");
3471         TEST_ASSERT_NOT_NULL(ut_params->obuf,
3472                         "Failed to allocate output buffer");
3473
3474         /* Clear mbuf payload */
3475         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3476                rte_pktmbuf_tailroom(ut_params->ibuf));
3477
3478         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
3479                        rte_pktmbuf_tailroom(ut_params->obuf));
3480
3481         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3482         /* Append data which is padded to a multiple of */
3483         /* the algorithms block size */
3484         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
3485         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3486                                 ciphertext_pad_len);
3487         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
3488         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3489
3490         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
3491
3492         /* Create SNOW 3G operation */
3493         retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
3494                                         tdata->iv.len,
3495                                         tdata->validCipherLenInBits.len,
3496                                         tdata->validCipherOffsetLenInBits.len,
3497                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
3498         if (retval < 0)
3499                 return retval;
3500
3501         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3502                                                 ut_params->op);
3503         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3504         ut_params->obuf = ut_params->op->sym->m_dst;
3505         if (ut_params->obuf)
3506                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3507                                 + tdata->iv.len;
3508         else
3509                 plaintext = ciphertext;
3510
3511         TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
3512
3513         /* Validate obuf */
3514         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
3515                                 tdata->plaintext.data,
3516                                 tdata->validDataLenInBits.len,
3517                                 "SNOW 3G Plaintext data not as expected");
3518         return 0;
3519 }
3520
3521 static int
3522 test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
3523 {
3524         struct crypto_testsuite_params *ts_params = &testsuite_params;
3525         struct crypto_unittest_params *ut_params = &unittest_params;
3526
3527         int retval;
3528
3529         uint8_t *plaintext, *ciphertext;
3530         unsigned plaintext_pad_len;
3531         unsigned plaintext_len;
3532
3533         /* Create SNOW 3G session */
3534         retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0],
3535                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3536                         RTE_CRYPTO_AUTH_OP_GENERATE,
3537                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3538                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3539                         tdata->key.data, tdata->key.len,
3540                         tdata->aad.len, tdata->digest.len);
3541         if (retval < 0)
3542                 return retval;
3543         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3544
3545         /* clear mbuf payload */
3546         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3547                         rte_pktmbuf_tailroom(ut_params->ibuf));
3548
3549         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3550         /* Append data which is padded to a multiple of */
3551         /* the algorithms block size */
3552         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3553         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3554                                 plaintext_pad_len);
3555         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3556
3557         TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3558
3559         /* Create SNOW 3G operation */
3560         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
3561                         tdata->digest.len, tdata->aad.data,
3562                         tdata->aad.len, /*tdata->plaintext.len,*/
3563                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3564                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3565                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3566                         tdata->iv.data, tdata->iv.len,
3567                         tdata->validCipherLenInBits.len,
3568                         tdata->validCipherOffsetLenInBits.len,
3569                         tdata->validAuthLenInBits.len,
3570                         tdata->validAuthOffsetLenInBits.len
3571                         );
3572         if (retval < 0)
3573                 return retval;
3574
3575         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3576                         ut_params->op);
3577         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3578         ut_params->obuf = ut_params->op->sym->m_src;
3579         if (ut_params->obuf)
3580                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3581                                 + tdata->iv.len + tdata->aad.len;
3582         else
3583                 ciphertext = plaintext;
3584
3585         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3586         /* Validate obuf */
3587         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3588                         ciphertext,
3589                         tdata->ciphertext.data,
3590                         tdata->validDataLenInBits.len,
3591                         "SNOW 3G Ciphertext data not as expected");
3592
3593         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3594             + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
3595
3596         /* Validate obuf */
3597         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3598                         ut_params->digest,
3599                         tdata->digest.data,
3600                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
3601                         "SNOW 3G Generated auth tag not as expected");
3602         return 0;
3603 }
3604 static int
3605 test_snow3g_auth_cipher(const struct snow3g_test_data *tdata)
3606 {
3607         struct crypto_testsuite_params *ts_params = &testsuite_params;
3608         struct crypto_unittest_params *ut_params = &unittest_params;
3609
3610         int retval;
3611
3612         uint8_t *plaintext, *ciphertext;
3613         unsigned plaintext_pad_len;
3614         unsigned plaintext_len;
3615
3616         /* Create SNOW 3G session */
3617         retval = create_wireless_algo_auth_cipher_session(ts_params->valid_devs[0],
3618                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3619                         RTE_CRYPTO_AUTH_OP_GENERATE,
3620                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3621                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3622                         tdata->key.data, tdata->key.len,
3623                         tdata->aad.len, tdata->digest.len);
3624         if (retval < 0)
3625                 return retval;
3626
3627         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3628
3629         /* clear mbuf payload */
3630         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3631                         rte_pktmbuf_tailroom(ut_params->ibuf));
3632
3633         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3634         /* Append data which is padded to a multiple of */
3635         /* the algorithms block size */
3636         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3637         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3638                                 plaintext_pad_len);
3639         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3640
3641         TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3642
3643         /* Create SNOW 3G operation */
3644         retval = create_wireless_algo_auth_cipher_operation(
3645                 tdata->digest.len,
3646                 tdata->iv.data, tdata->iv.len,
3647                 tdata->aad.data, tdata->aad.len,
3648                 plaintext_pad_len,
3649                 tdata->validCipherLenInBits.len,
3650                 tdata->validCipherOffsetLenInBits.len,
3651                 tdata->validAuthLenInBits.len,
3652                 tdata->validAuthOffsetLenInBits.len,
3653                 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3654                 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
3655         );
3656
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         ut_params->obuf = ut_params->op->sym->m_src;
3664         if (ut_params->obuf)
3665                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3666                                 + tdata->aad.len + tdata->iv.len;
3667         else
3668                 ciphertext = plaintext;
3669
3670         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3671                         + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
3672         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3673
3674         /* Validate obuf */
3675         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3676                 ciphertext,
3677                 tdata->ciphertext.data,
3678                 tdata->validDataLenInBits.len,
3679                 "SNOW 3G Ciphertext data not as expected");
3680
3681         /* Validate obuf */
3682         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3683                 ut_params->digest,
3684                 tdata->digest.data,
3685                 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
3686                 "SNOW 3G Generated auth tag not as expected");
3687         return 0;
3688 }
3689
3690 static int
3691 test_kasumi_auth_cipher(const struct kasumi_test_data *tdata)
3692 {
3693         struct crypto_testsuite_params *ts_params = &testsuite_params;
3694         struct crypto_unittest_params *ut_params = &unittest_params;
3695
3696         int retval;
3697
3698         uint8_t *plaintext, *ciphertext;
3699         unsigned plaintext_pad_len;
3700         unsigned plaintext_len;
3701
3702         /* Create KASUMI session */
3703         retval = create_wireless_algo_auth_cipher_session(
3704                         ts_params->valid_devs[0],
3705                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3706                         RTE_CRYPTO_AUTH_OP_GENERATE,
3707                         RTE_CRYPTO_AUTH_KASUMI_F9,
3708                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3709                         tdata->key.data, tdata->key.len,
3710                         tdata->aad.len, tdata->digest.len);
3711         if (retval < 0)
3712                 return retval;
3713         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3714
3715         /* clear mbuf payload */
3716         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3717                         rte_pktmbuf_tailroom(ut_params->ibuf));
3718
3719         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3720         /* Append data which is padded to a multiple of */
3721         /* the algorithms block size */
3722         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3723         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3724                                 plaintext_pad_len);
3725         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3726
3727         TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3728
3729         /* Create KASUMI operation */
3730         retval = create_wireless_algo_auth_cipher_operation(tdata->digest.len,
3731                                 tdata->iv.data, tdata->iv.len,
3732                                 tdata->aad.data, tdata->aad.len,
3733                                 plaintext_pad_len,
3734                                 tdata->validCipherLenInBits.len,
3735                                 tdata->validCipherOffsetLenInBits.len,
3736                                 tdata->validAuthLenInBits.len,
3737                                 tdata->validAuthOffsetLenInBits.len,
3738                                 RTE_CRYPTO_AUTH_KASUMI_F9,
3739                                 RTE_CRYPTO_CIPHER_KASUMI_F8
3740                                 );
3741
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_src;
3749         if (ut_params->obuf)
3750                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3751                                 + tdata->iv.len + tdata->aad.len;
3752         else
3753                 ciphertext = plaintext;
3754
3755         /* Validate obuf */
3756         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3757                         ciphertext,
3758                         tdata->ciphertext.data,
3759                         tdata->validCipherLenInBits.len,
3760                         "KASUMI Ciphertext data not as expected");
3761         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3762             + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
3763
3764         /* Validate obuf */
3765         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3766                         ut_params->digest,
3767                         tdata->digest.data,
3768                         DIGEST_BYTE_LENGTH_KASUMI_F9,
3769                         "KASUMI Generated auth tag not as expected");
3770         return 0;
3771 }
3772
3773 static int
3774 test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
3775 {
3776         struct crypto_testsuite_params *ts_params = &testsuite_params;
3777         struct crypto_unittest_params *ut_params = &unittest_params;
3778
3779         int retval;
3780
3781         uint8_t *plaintext, *ciphertext;
3782         unsigned plaintext_pad_len;
3783         unsigned plaintext_len;
3784
3785         /* Create KASUMI session */
3786         retval = create_wireless_algo_cipher_auth_session(
3787                         ts_params->valid_devs[0],
3788                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3789                         RTE_CRYPTO_AUTH_OP_GENERATE,
3790                         RTE_CRYPTO_AUTH_KASUMI_F9,
3791                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3792                         tdata->key.data, tdata->key.len,
3793                         tdata->aad.len, tdata->digest.len);
3794         if (retval < 0)
3795                 return retval;
3796
3797         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3798
3799         /* clear mbuf payload */
3800         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3801                         rte_pktmbuf_tailroom(ut_params->ibuf));
3802
3803         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3804         /* Append data which is padded to a multiple of */
3805         /* the algorithms block size */
3806         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3807         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3808                                 plaintext_pad_len);
3809         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3810
3811         TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3812
3813         /* Create KASUMI operation */
3814         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
3815                                 tdata->digest.len, tdata->aad.data,
3816                                 tdata->aad.len,
3817                                 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3818                                 RTE_CRYPTO_AUTH_KASUMI_F9,
3819                                 RTE_CRYPTO_CIPHER_KASUMI_F8,
3820                                 tdata->iv.data, tdata->iv.len,
3821                                 tdata->validCipherLenInBits.len,
3822                                 tdata->validCipherOffsetLenInBits.len,
3823                                 tdata->validAuthLenInBits.len,
3824                                 tdata->validAuthOffsetLenInBits.len
3825                                 );
3826         if (retval < 0)
3827                 return retval;
3828
3829         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3830                         ut_params->op);
3831         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3832         ut_params->obuf = ut_params->op->sym->m_src;
3833         if (ut_params->obuf)
3834                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3835                                 + tdata->aad.len + tdata->iv.len;
3836         else
3837                 ciphertext = plaintext;
3838
3839         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3840                         + plaintext_pad_len + tdata->aad.len + tdata->iv.len;
3841
3842         /* Validate obuf */
3843         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3844                 ciphertext,
3845                 tdata->ciphertext.data,
3846                 tdata->validCipherLenInBits.len,
3847                 "KASUMI Ciphertext data not as expected");
3848
3849         /* Validate obuf */
3850         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3851                 ut_params->digest,
3852                 tdata->digest.data,
3853                 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
3854                 "KASUMI Generated auth tag not as expected");
3855         return 0;
3856 }
3857
3858 static int
3859 test_zuc_encryption(const struct zuc_test_data *tdata)
3860 {
3861         struct crypto_testsuite_params *ts_params = &testsuite_params;
3862         struct crypto_unittest_params *ut_params = &unittest_params;
3863
3864         int retval;
3865         uint8_t *plaintext, *ciphertext;
3866         unsigned plaintext_pad_len;
3867         unsigned plaintext_len;
3868
3869         /* Create ZUC session */
3870         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3871                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3872                                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
3873                                         tdata->key.data, tdata->key.len);
3874         if (retval < 0)
3875                 return retval;
3876
3877         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3878
3879         /* Clear mbuf payload */
3880         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3881                rte_pktmbuf_tailroom(ut_params->ibuf));
3882
3883         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3884         /* Append data which is padded to a multiple */
3885         /* of the algorithms block size */
3886         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3887         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3888                                 plaintext_pad_len);
3889         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3890
3891         TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
3892
3893         /* Create ZUC operation */
3894         retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
3895                                         tdata->plaintext.len,
3896                                         tdata->validCipherOffsetLenInBits.len,
3897                                         RTE_CRYPTO_CIPHER_ZUC_EEA3);
3898         if (retval < 0)
3899                 return retval;
3900
3901         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3902                                                 ut_params->op);
3903         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3904
3905         ut_params->obuf = ut_params->op->sym->m_dst;
3906         if (ut_params->obuf)
3907                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3908                                 + tdata->iv.len;
3909         else
3910                 ciphertext = plaintext;
3911
3912         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3913
3914         /* Validate obuf */
3915         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3916                 ciphertext,
3917                 tdata->ciphertext.data,
3918                 tdata->validCipherLenInBits.len,
3919                 "ZUC Ciphertext data not as expected");
3920         return 0;
3921 }
3922
3923 static int
3924 test_zuc_encryption_sgl(const struct zuc_test_data *tdata)
3925 {
3926         struct crypto_testsuite_params *ts_params = &testsuite_params;
3927         struct crypto_unittest_params *ut_params = &unittest_params;
3928
3929         int retval;
3930
3931         unsigned int plaintext_pad_len;
3932         unsigned int plaintext_len;
3933         const uint8_t *ciphertext;
3934         uint8_t ciphertext_buffer[2048];
3935         struct rte_cryptodev_info dev_info;
3936
3937         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3938         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_MBUF_SCATTER_GATHER)) {
3939                 printf("Device doesn't support scatter-gather. "
3940                                 "Test Skipped.\n");
3941                 return 0;
3942         }
3943
3944         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3945
3946         /* Append data which is padded to a multiple */
3947         /* of the algorithms block size */
3948         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3949
3950         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3951                         plaintext_pad_len, 10, 0);
3952
3953         pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
3954                         tdata->plaintext.data);
3955
3956         /* Create ZUC session */
3957         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3958                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3959                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
3960                         tdata->key.data, tdata->key.len);
3961         if (retval < 0)
3962                 return retval;
3963
3964         /* Clear mbuf payload */
3965
3966         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3967
3968         /* Create ZUC operation */
3969         retval = create_wireless_algo_cipher_operation(tdata->iv.data,
3970                         tdata->iv.len, tdata->plaintext.len,
3971                         tdata->validCipherOffsetLenInBits.len,
3972                         RTE_CRYPTO_CIPHER_ZUC_EEA3);
3973         if (retval < 0)
3974                 return retval;
3975
3976         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3977                                                 ut_params->op);
3978         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3979
3980         ut_params->obuf = ut_params->op->sym->m_dst;
3981         if (ut_params->obuf)
3982                 ciphertext = rte_pktmbuf_read(ut_params->obuf,
3983                         tdata->iv.len, plaintext_len, ciphertext_buffer);
3984         else
3985                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3986                         tdata->iv.len, plaintext_len, ciphertext_buffer);
3987
3988         /* Validate obuf */
3989         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
3990
3991         /* Validate obuf */
3992         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3993                 ciphertext,
3994                 tdata->ciphertext.data,
3995                 tdata->validCipherLenInBits.len,
3996                 "ZUC Ciphertext data not as expected");
3997
3998         return 0;
3999 }
4000
4001 static int
4002 test_zuc_authentication(const struct zuc_hash_test_data *tdata)
4003 {
4004         struct crypto_testsuite_params *ts_params = &testsuite_params;
4005         struct crypto_unittest_params *ut_params = &unittest_params;
4006
4007         int retval;
4008         unsigned plaintext_pad_len;
4009         unsigned plaintext_len;
4010         uint8_t *plaintext;
4011
4012         /* Create ZUC session */
4013         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
4014                         tdata->key.data, tdata->key.len,
4015                         tdata->aad.len, tdata->digest.len,
4016                         RTE_CRYPTO_AUTH_OP_GENERATE,
4017                         RTE_CRYPTO_AUTH_ZUC_EIA3);
4018         if (retval < 0)
4019                 return retval;
4020
4021         /* alloc mbuf and set payload */
4022         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4023
4024         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4025         rte_pktmbuf_tailroom(ut_params->ibuf));
4026
4027         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4028         /* Append data which is padded to a multiple of */
4029         /* the algorithms block size */
4030         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
4031         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4032                                 plaintext_pad_len);
4033         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4034
4035         /* Create ZUC operation */
4036         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
4037                         tdata->aad.data, tdata->aad.len,
4038                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
4039                         RTE_CRYPTO_AUTH_ZUC_EIA3,
4040                         tdata->validAuthLenInBits.len,
4041                         tdata->validAuthOffsetLenInBits.len);
4042         if (retval < 0)
4043                 return retval;
4044
4045         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4046                                 ut_params->op);
4047         ut_params->obuf = ut_params->op->sym->m_src;
4048         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4049         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4050                         + plaintext_pad_len + ALIGN_POW2_ROUNDUP(tdata->aad.len, 8);
4051
4052         /* Validate obuf */
4053         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4054         ut_params->digest,
4055         tdata->digest.data,
4056         DIGEST_BYTE_LENGTH_KASUMI_F9,
4057         "ZUC Generated auth tag not as expected");
4058
4059         return 0;
4060 }
4061
4062 static int
4063 test_kasumi_encryption_test_case_1(void)
4064 {
4065         return test_kasumi_encryption(&kasumi_test_case_1);
4066 }
4067
4068 static int
4069 test_kasumi_encryption_test_case_1_sgl(void)
4070 {
4071         return test_kasumi_encryption_sgl(&kasumi_test_case_1);
4072 }
4073
4074 static int
4075 test_kasumi_encryption_test_case_1_oop(void)
4076 {
4077         return test_kasumi_encryption_oop(&kasumi_test_case_1);
4078 }
4079
4080 static int
4081 test_kasumi_encryption_test_case_1_oop_sgl(void)
4082 {
4083         return test_kasumi_encryption_oop_sgl(&kasumi_test_case_1);
4084 }
4085
4086 static int
4087 test_kasumi_encryption_test_case_2(void)
4088 {
4089         return test_kasumi_encryption(&kasumi_test_case_2);
4090 }
4091
4092 static int
4093 test_kasumi_encryption_test_case_3(void)
4094 {
4095         return test_kasumi_encryption(&kasumi_test_case_3);
4096 }
4097
4098 static int
4099 test_kasumi_encryption_test_case_4(void)
4100 {
4101         return test_kasumi_encryption(&kasumi_test_case_4);
4102 }
4103
4104 static int
4105 test_kasumi_encryption_test_case_5(void)
4106 {
4107         return test_kasumi_encryption(&kasumi_test_case_5);
4108 }
4109
4110 static int
4111 test_kasumi_decryption_test_case_1(void)
4112 {
4113         return test_kasumi_decryption(&kasumi_test_case_1);
4114 }
4115
4116 static int
4117 test_kasumi_decryption_test_case_1_oop(void)
4118 {
4119         return test_kasumi_decryption_oop(&kasumi_test_case_1);
4120 }
4121
4122 static int
4123 test_kasumi_decryption_test_case_2(void)
4124 {
4125         return test_kasumi_decryption(&kasumi_test_case_2);
4126 }
4127
4128 static int
4129 test_kasumi_decryption_test_case_3(void)
4130 {
4131         return test_kasumi_decryption(&kasumi_test_case_3);
4132 }
4133
4134 static int
4135 test_kasumi_decryption_test_case_4(void)
4136 {
4137         return test_kasumi_decryption(&kasumi_test_case_4);
4138 }
4139
4140 static int
4141 test_kasumi_decryption_test_case_5(void)
4142 {
4143         return test_kasumi_decryption(&kasumi_test_case_5);
4144 }
4145 static int
4146 test_snow3g_encryption_test_case_1(void)
4147 {
4148         return test_snow3g_encryption(&snow3g_test_case_1);
4149 }
4150
4151 static int
4152 test_snow3g_encryption_test_case_1_oop(void)
4153 {
4154         return test_snow3g_encryption_oop(&snow3g_test_case_1);
4155 }
4156
4157 static int
4158 test_snow3g_encryption_test_case_1_oop_sgl(void)
4159 {
4160         return test_snow3g_encryption_oop_sgl(&snow3g_test_case_1);
4161 }
4162
4163
4164 static int
4165 test_snow3g_encryption_test_case_1_offset_oop(void)
4166 {
4167         return test_snow3g_encryption_offset_oop(&snow3g_test_case_1);
4168 }
4169
4170 static int
4171 test_snow3g_encryption_test_case_2(void)
4172 {
4173         return test_snow3g_encryption(&snow3g_test_case_2);
4174 }
4175
4176 static int
4177 test_snow3g_encryption_test_case_3(void)
4178 {
4179         return test_snow3g_encryption(&snow3g_test_case_3);
4180 }
4181
4182 static int
4183 test_snow3g_encryption_test_case_4(void)
4184 {
4185         return test_snow3g_encryption(&snow3g_test_case_4);
4186 }
4187
4188 static int
4189 test_snow3g_encryption_test_case_5(void)
4190 {
4191         return test_snow3g_encryption(&snow3g_test_case_5);
4192 }
4193
4194 static int
4195 test_snow3g_decryption_test_case_1(void)
4196 {
4197         return test_snow3g_decryption(&snow3g_test_case_1);
4198 }
4199
4200 static int
4201 test_snow3g_decryption_test_case_1_oop(void)
4202 {
4203         return test_snow3g_decryption_oop(&snow3g_test_case_1);
4204 }
4205
4206 static int
4207 test_snow3g_decryption_test_case_2(void)
4208 {
4209         return test_snow3g_decryption(&snow3g_test_case_2);
4210 }
4211
4212 static int
4213 test_snow3g_decryption_test_case_3(void)
4214 {
4215         return test_snow3g_decryption(&snow3g_test_case_3);
4216 }
4217
4218 static int
4219 test_snow3g_decryption_test_case_4(void)
4220 {
4221         return test_snow3g_decryption(&snow3g_test_case_4);
4222 }
4223
4224 static int
4225 test_snow3g_decryption_test_case_5(void)
4226 {
4227         return test_snow3g_decryption(&snow3g_test_case_5);
4228 }
4229 static int
4230 test_snow3g_cipher_auth_test_case_1(void)
4231 {
4232         return test_snow3g_cipher_auth(&snow3g_test_case_3);
4233 }
4234
4235 static int
4236 test_snow3g_auth_cipher_test_case_1(void)
4237 {
4238         return test_snow3g_auth_cipher(&snow3g_test_case_6);
4239 }
4240
4241 static int
4242 test_kasumi_auth_cipher_test_case_1(void)
4243 {
4244         return test_kasumi_auth_cipher(&kasumi_test_case_3);
4245 }
4246
4247 static int
4248 test_kasumi_cipher_auth_test_case_1(void)
4249 {
4250         return test_kasumi_cipher_auth(&kasumi_test_case_6);
4251 }
4252
4253 static int
4254 test_zuc_encryption_test_case_1(void)
4255 {
4256         return test_zuc_encryption(&zuc_test_case_1);
4257 }
4258
4259 static int
4260 test_zuc_encryption_test_case_2(void)
4261 {
4262         return test_zuc_encryption(&zuc_test_case_2);
4263 }
4264
4265 static int
4266 test_zuc_encryption_test_case_3(void)
4267 {
4268         return test_zuc_encryption(&zuc_test_case_3);
4269 }
4270
4271 static int
4272 test_zuc_encryption_test_case_4(void)
4273 {
4274         return test_zuc_encryption(&zuc_test_case_4);
4275 }
4276
4277 static int
4278 test_zuc_encryption_test_case_5(void)
4279 {
4280         return test_zuc_encryption(&zuc_test_case_5);
4281 }
4282
4283 static int
4284 test_zuc_encryption_test_case_6_sgl(void)
4285 {
4286         return test_zuc_encryption_sgl(&zuc_test_case_1);
4287 }
4288
4289 static int
4290 test_zuc_hash_generate_test_case_1(void)
4291 {
4292         return test_zuc_authentication(&zuc_hash_test_case_1);
4293 }
4294
4295 static int
4296 test_zuc_hash_generate_test_case_2(void)
4297 {
4298         return test_zuc_authentication(&zuc_hash_test_case_2);
4299 }
4300
4301 static int
4302 test_zuc_hash_generate_test_case_3(void)
4303 {
4304         return test_zuc_authentication(&zuc_hash_test_case_3);
4305 }
4306
4307 static int
4308 test_zuc_hash_generate_test_case_4(void)
4309 {
4310         return test_zuc_authentication(&zuc_hash_test_case_4);
4311 }
4312
4313 static int
4314 test_zuc_hash_generate_test_case_5(void)
4315 {
4316         return test_zuc_authentication(&zuc_hash_test_case_5);
4317 }
4318
4319 static int
4320 test_3DES_chain_qat_all(void)
4321 {
4322         struct crypto_testsuite_params *ts_params = &testsuite_params;
4323         int status;
4324
4325         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
4326                 ts_params->op_mpool, ts_params->valid_devs[0],
4327                 RTE_CRYPTODEV_QAT_SYM_PMD,
4328                 BLKCIPHER_3DES_CHAIN_TYPE);
4329
4330         TEST_ASSERT_EQUAL(status, 0, "Test failed");
4331
4332         return TEST_SUCCESS;
4333 }
4334
4335 static int
4336 test_DES_cipheronly_qat_all(void)
4337 {
4338         struct crypto_testsuite_params *ts_params = &testsuite_params;
4339         int status;
4340
4341         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
4342                 ts_params->op_mpool, ts_params->valid_devs[0],
4343                 RTE_CRYPTODEV_QAT_SYM_PMD,
4344                 BLKCIPHER_DES_CIPHERONLY_TYPE);
4345
4346         TEST_ASSERT_EQUAL(status, 0, "Test failed");
4347
4348         return TEST_SUCCESS;
4349 }
4350
4351 static int
4352 test_DES_docsis_openssl_all(void)
4353 {
4354         struct crypto_testsuite_params *ts_params = &testsuite_params;
4355         int status;
4356
4357         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
4358                 ts_params->op_mpool, ts_params->valid_devs[0],
4359                 RTE_CRYPTODEV_OPENSSL_PMD,
4360                 BLKCIPHER_DES_DOCSIS_TYPE);
4361
4362         TEST_ASSERT_EQUAL(status, 0, "Test failed");
4363
4364         return TEST_SUCCESS;
4365 }
4366
4367 static int
4368 test_3DES_cipheronly_qat_all(void)
4369 {
4370         struct crypto_testsuite_params *ts_params = &testsuite_params;
4371         int status;
4372
4373         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
4374                 ts_params->op_mpool, ts_params->valid_devs[0],
4375                 RTE_CRYPTODEV_QAT_SYM_PMD,
4376                 BLKCIPHER_3DES_CIPHERONLY_TYPE);
4377
4378         TEST_ASSERT_EQUAL(status, 0, "Test failed");
4379
4380         return TEST_SUCCESS;
4381 }
4382
4383 static int
4384 test_3DES_chain_openssl_all(void)
4385 {
4386         struct crypto_testsuite_params *ts_params = &testsuite_params;
4387         int status;
4388
4389         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
4390                 ts_params->op_mpool, ts_params->valid_devs[0],
4391                 RTE_CRYPTODEV_OPENSSL_PMD,
4392                 BLKCIPHER_3DES_CHAIN_TYPE);
4393
4394         TEST_ASSERT_EQUAL(status, 0, "Test failed");
4395
4396         return TEST_SUCCESS;
4397 }
4398
4399 static int
4400 test_3DES_cipheronly_openssl_all(void)
4401 {
4402         struct crypto_testsuite_params *ts_params = &testsuite_params;
4403         int status;
4404
4405         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
4406                 ts_params->op_mpool, ts_params->valid_devs[0],
4407                 RTE_CRYPTODEV_OPENSSL_PMD,
4408                 BLKCIPHER_3DES_CIPHERONLY_TYPE);
4409
4410         TEST_ASSERT_EQUAL(status, 0, "Test failed");
4411
4412         return TEST_SUCCESS;
4413 }
4414
4415 /* ***** AES-GCM Tests ***** */
4416
4417 static int
4418 create_gcm_session(uint8_t dev_id, enum rte_crypto_cipher_operation op,
4419                 const uint8_t *key, const uint8_t key_len,
4420                 const uint8_t aad_len, const uint8_t auth_len,
4421                 enum rte_crypto_auth_operation auth_op)
4422 {
4423         uint8_t cipher_key[key_len];
4424
4425         struct crypto_unittest_params *ut_params = &unittest_params;
4426
4427         memcpy(cipher_key, key, key_len);
4428
4429         /* Setup Cipher Parameters */
4430         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4431         ut_params->cipher_xform.next = NULL;
4432
4433         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_GCM;
4434         ut_params->auth_xform.auth.op = auth_op;
4435         ut_params->cipher_xform.cipher.op = op;
4436         ut_params->cipher_xform.cipher.key.data = cipher_key;
4437         ut_params->cipher_xform.cipher.key.length = key_len;
4438
4439         TEST_HEXDUMP(stdout, "key:", key, key_len);
4440
4441         /* Setup Authentication Parameters */
4442         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4443         ut_params->auth_xform.next = NULL;
4444
4445         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GCM;
4446
4447         ut_params->auth_xform.auth.digest_length = auth_len;
4448         ut_params->auth_xform.auth.add_auth_data_length = aad_len;
4449         ut_params->auth_xform.auth.key.length = 0;
4450         ut_params->auth_xform.auth.key.data = NULL;
4451
4452         if (op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
4453                 ut_params->cipher_xform.next = &ut_params->auth_xform;
4454
4455                 /* Create Crypto session*/
4456                 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
4457                                 &ut_params->cipher_xform);
4458         } else {/* Create Crypto session*/
4459                 ut_params->auth_xform.next = &ut_params->cipher_xform;
4460                 ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
4461                                 &ut_params->auth_xform);
4462         }
4463
4464         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
4465
4466         return 0;
4467 }
4468
4469 static int
4470 create_gcm_xforms(struct rte_crypto_op *op,
4471                 enum rte_crypto_cipher_operation cipher_op,
4472                 uint8_t *key, const uint8_t key_len,
4473                 const uint8_t aad_len, const uint8_t auth_len,
4474                 enum rte_crypto_auth_operation auth_op)
4475 {
4476         TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 2),
4477                         "failed to allocate space for crypto transforms");
4478
4479         struct rte_crypto_sym_op *sym_op = op->sym;
4480
4481         /* Setup Cipher Parameters */
4482         sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4483         sym_op->xform->cipher.algo = RTE_CRYPTO_CIPHER_AES_GCM;
4484         sym_op->xform->cipher.op = cipher_op;
4485         sym_op->xform->cipher.key.data = key;
4486         sym_op->xform->cipher.key.length = key_len;
4487
4488         TEST_HEXDUMP(stdout, "key:", key, key_len);
4489
4490         /* Setup Authentication Parameters */
4491         sym_op->xform->next->type = RTE_CRYPTO_SYM_XFORM_AUTH;
4492         sym_op->xform->next->auth.algo = RTE_CRYPTO_AUTH_AES_GCM;
4493         sym_op->xform->next->auth.op = auth_op;
4494         sym_op->xform->next->auth.digest_length = auth_len;
4495         sym_op->xform->next->auth.add_auth_data_length = aad_len;
4496         sym_op->xform->next->auth.key.length = 0;
4497         sym_op->xform->next->auth.key.data = NULL;
4498         sym_op->xform->next->next = NULL;
4499
4500         return 0;
4501 }
4502
4503 static int
4504 create_gcm_operation(enum rte_crypto_cipher_operation op,
4505                 const struct gcm_test_data *tdata)
4506 {
4507         struct crypto_testsuite_params *ts_params = &testsuite_params;
4508         struct crypto_unittest_params *ut_params = &unittest_params;
4509
4510         uint8_t *plaintext, *ciphertext;
4511         unsigned int iv_pad_len, aad_pad_len, plaintext_pad_len;
4512
4513         /* Generate Crypto op data structure */
4514         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
4515                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
4516         TEST_ASSERT_NOT_NULL(ut_params->op,
4517                         "Failed to allocate symmetric crypto operation struct");
4518
4519         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
4520
4521         /* Append aad data */
4522         aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
4523         sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4524                         aad_pad_len);
4525         TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
4526                         "no room to append aad");
4527
4528         sym_op->auth.aad.length = tdata->aad.len;
4529         sym_op->auth.aad.phys_addr =
4530                         rte_pktmbuf_mtophys(ut_params->ibuf);
4531         memcpy(sym_op->auth.aad.data, tdata->aad.data, tdata->aad.len);
4532         TEST_HEXDUMP(stdout, "aad:", sym_op->auth.aad.data,
4533                 sym_op->auth.aad.length);
4534
4535         /* Prepend iv */
4536         iv_pad_len = RTE_ALIGN_CEIL(tdata->iv.len, 16);
4537         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
4538                         ut_params->ibuf, iv_pad_len);
4539         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
4540
4541         memset(sym_op->cipher.iv.data, 0, iv_pad_len);
4542         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
4543         sym_op->cipher.iv.length = tdata->iv.len;
4544
4545         rte_memcpy(sym_op->cipher.iv.data, tdata->iv.data, tdata->iv.len);
4546         TEST_HEXDUMP(stdout, "iv:", sym_op->cipher.iv.data,
4547                 sym_op->cipher.iv.length);
4548
4549         /* Append plaintext/ciphertext */
4550         if (op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
4551                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
4552                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4553                                 plaintext_pad_len);
4554                 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
4555
4556                 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
4557                 TEST_HEXDUMP(stdout, "plaintext:", plaintext,
4558                                 tdata->plaintext.len);
4559
4560                 if (ut_params->obuf) {
4561                         ciphertext = (uint8_t *)rte_pktmbuf_append(
4562                                         ut_params->obuf,
4563                                         plaintext_pad_len + aad_pad_len +
4564                                         iv_pad_len);
4565                         TEST_ASSERT_NOT_NULL(ciphertext,
4566                                         "no room to append ciphertext");
4567
4568                         memset(ciphertext + aad_pad_len + iv_pad_len, 0,
4569                                         tdata->ciphertext.len);
4570                 }
4571         } else {
4572                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16);
4573                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4574                                 plaintext_pad_len);
4575                 TEST_ASSERT_NOT_NULL(ciphertext,
4576                                 "no room to append ciphertext");
4577
4578                 memcpy(ciphertext, tdata->ciphertext.data,
4579                                 tdata->ciphertext.len);
4580                 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext,
4581                                 tdata->ciphertext.len);
4582
4583                 if (ut_params->obuf) {
4584                         plaintext = (uint8_t *)rte_pktmbuf_append(
4585                                         ut_params->obuf,
4586                                         plaintext_pad_len + aad_pad_len +
4587                                         iv_pad_len);
4588                         TEST_ASSERT_NOT_NULL(plaintext,
4589                                         "no room to append plaintext");
4590
4591                         memset(plaintext + aad_pad_len + iv_pad_len, 0,
4592                                         tdata->plaintext.len);
4593                 }
4594         }
4595
4596         /* Append digest data */
4597         if (op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
4598                 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
4599                                 ut_params->obuf ? ut_params->obuf :
4600                                                 ut_params->ibuf,
4601                                                 tdata->auth_tag.len);
4602                 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
4603                                 "no room to append digest");
4604                 memset(sym_op->auth.digest.data, 0, tdata->auth_tag.len);
4605                 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
4606                                 ut_params->obuf ? ut_params->obuf :
4607                                                 ut_params->ibuf,
4608                                                 plaintext_pad_len +
4609                                                 aad_pad_len + iv_pad_len);
4610                 sym_op->auth.digest.length = tdata->auth_tag.len;
4611         } else {
4612                 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
4613                                 ut_params->ibuf, tdata->auth_tag.len);
4614                 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
4615                                 "no room to append digest");
4616                 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
4617                                 ut_params->ibuf,
4618                                 plaintext_pad_len + aad_pad_len + iv_pad_len);
4619                 sym_op->auth.digest.length = tdata->auth_tag.len;
4620
4621                 rte_memcpy(sym_op->auth.digest.data, tdata->auth_tag.data,
4622                         tdata->auth_tag.len);
4623                 TEST_HEXDUMP(stdout, "digest:",
4624                         sym_op->auth.digest.data,
4625                         sym_op->auth.digest.length);
4626         }
4627
4628         sym_op->cipher.data.length = tdata->plaintext.len;
4629         sym_op->cipher.data.offset = aad_pad_len + iv_pad_len;
4630
4631         sym_op->auth.data.length = tdata->plaintext.len;
4632         sym_op->auth.data.offset = aad_pad_len + iv_pad_len;
4633
4634         return 0;
4635 }
4636
4637 static int
4638 test_mb_AES_GCM_authenticated_encryption(const struct gcm_test_data *tdata)
4639 {
4640         struct crypto_testsuite_params *ts_params = &testsuite_params;
4641         struct crypto_unittest_params *ut_params = &unittest_params;
4642
4643         int retval;
4644         uint8_t *ciphertext, *auth_tag;
4645         uint16_t plaintext_pad_len;
4646         uint32_t i;
4647
4648         /* Create GCM session */
4649         retval = create_gcm_session(ts_params->valid_devs[0],
4650                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4651                         tdata->key.data, tdata->key.len,
4652                         tdata->aad.len, tdata->auth_tag.len,
4653                         RTE_CRYPTO_AUTH_OP_GENERATE);
4654         if (retval < 0)
4655                 return retval;
4656
4657         if (tdata->aad.len > MBUF_SIZE) {
4658                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
4659                 /* Populate full size of add data */
4660                 for (i = 32; i < GCM_MAX_AAD_LENGTH; i += 32)
4661                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
4662         } else
4663                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4664
4665         /* clear mbuf payload */
4666         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4667                         rte_pktmbuf_tailroom(ut_params->ibuf));
4668
4669         /* Create GCM operation */
4670         retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_ENCRYPT, tdata);
4671         if (retval < 0)
4672                 return retval;
4673
4674         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
4675
4676         ut_params->op->sym->m_src = ut_params->ibuf;
4677
4678         /* Process crypto operation */
4679         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
4680                         ut_params->op), "failed to process sym crypto op");
4681
4682         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
4683                         "crypto op processing failed");
4684
4685         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
4686
4687         if (ut_params->op->sym->m_dst) {
4688                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
4689                                 uint8_t *);
4690                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
4691                                 uint8_t *, plaintext_pad_len);
4692         } else {
4693                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
4694                                 uint8_t *,
4695                                 ut_params->op->sym->cipher.data.offset);
4696                 auth_tag = ciphertext + plaintext_pad_len;
4697         }
4698
4699         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
4700         TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
4701
4702         /* Validate obuf */
4703         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4704                         ciphertext,
4705                         tdata->ciphertext.data,
4706                         tdata->ciphertext.len,
4707                         "GCM Ciphertext data not as expected");
4708
4709         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4710                         auth_tag,
4711                         tdata->auth_tag.data,
4712                         tdata->auth_tag.len,
4713                         "GCM Generated auth tag not as expected");
4714
4715         return 0;
4716
4717 }
4718
4719 static int
4720 test_mb_AES_GCM_authenticated_encryption_test_case_1(void)
4721 {
4722         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_1);
4723 }
4724
4725 static int
4726 test_mb_AES_GCM_authenticated_encryption_test_case_2(void)
4727 {
4728         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_2);
4729 }
4730
4731 static int
4732 test_mb_AES_GCM_authenticated_encryption_test_case_3(void)
4733 {
4734         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_3);
4735 }
4736
4737 static int
4738 test_mb_AES_GCM_authenticated_encryption_test_case_4(void)
4739 {
4740         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_4);
4741 }
4742
4743 static int
4744 test_mb_AES_GCM_authenticated_encryption_test_case_5(void)
4745 {
4746         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_5);
4747 }
4748
4749 static int
4750 test_mb_AES_GCM_authenticated_encryption_test_case_6(void)
4751 {
4752         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_6);
4753 }
4754
4755 static int
4756 test_mb_AES_GCM_authenticated_encryption_test_case_7(void)
4757 {
4758         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_7);
4759 }
4760
4761 static int
4762 test_mb_AES_GCM_auth_encryption_test_case_256_1(void)
4763 {
4764         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_1);
4765 }
4766
4767 static int
4768 test_mb_AES_GCM_auth_encryption_test_case_256_2(void)
4769 {
4770         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_2);
4771 }
4772
4773 static int
4774 test_mb_AES_GCM_auth_encryption_test_case_256_3(void)
4775 {
4776         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_3);
4777 }
4778
4779 static int
4780 test_mb_AES_GCM_auth_encryption_test_case_256_4(void)
4781 {
4782         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_4);
4783 }
4784
4785 static int
4786 test_mb_AES_GCM_auth_encryption_test_case_256_5(void)
4787 {
4788         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_5);
4789 }
4790
4791 static int
4792 test_mb_AES_GCM_auth_encryption_test_case_256_6(void)
4793 {
4794         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_6);
4795 }
4796
4797 static int
4798 test_mb_AES_GCM_auth_encryption_test_case_256_7(void)
4799 {
4800         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_7);
4801 }
4802
4803 static int
4804 test_mb_AES_GCM_auth_encryption_test_case_aad_1(void)
4805 {
4806         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_aad_1);
4807 }
4808
4809 static int
4810 test_mb_AES_GCM_auth_encryption_test_case_aad_2(void)
4811 {
4812         return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_aad_2);
4813 }
4814
4815 static int
4816 test_mb_AES_GCM_authenticated_decryption(const struct gcm_test_data *tdata)
4817 {
4818         struct crypto_testsuite_params *ts_params = &testsuite_params;
4819         struct crypto_unittest_params *ut_params = &unittest_params;
4820
4821         int retval;
4822         uint8_t *plaintext;
4823         uint32_t i;
4824
4825         /* Create GCM session */
4826         retval = create_gcm_session(ts_params->valid_devs[0],
4827                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4828                         tdata->key.data, tdata->key.len,
4829                         tdata->aad.len, tdata->auth_tag.len,
4830                         RTE_CRYPTO_AUTH_OP_VERIFY);
4831         if (retval < 0)
4832                 return retval;
4833
4834         /* alloc mbuf and set payload */
4835         if (tdata->aad.len > MBUF_SIZE) {
4836                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
4837                 /* Populate full size of add data */
4838                 for (i = 32; i < GCM_MAX_AAD_LENGTH; i += 32)
4839                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
4840         } else
4841                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4842
4843         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4844                         rte_pktmbuf_tailroom(ut_params->ibuf));
4845
4846         /* Create GCM operation */
4847         retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_DECRYPT, tdata);
4848         if (retval < 0)
4849                 return retval;
4850
4851         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
4852
4853         ut_params->op->sym->m_src = ut_params->ibuf;
4854
4855         /* Process crypto operation */
4856         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
4857                         ut_params->op), "failed to process sym crypto op");
4858
4859         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
4860                         "crypto op processing failed");
4861
4862         if (ut_params->op->sym->m_dst)
4863                 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
4864                                 uint8_t *);
4865         else
4866                 plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
4867                                 uint8_t *,
4868                                 ut_params->op->sym->cipher.data.offset);
4869
4870         TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
4871
4872         /* Validate obuf */
4873         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4874                         plaintext,
4875                         tdata->plaintext.data,
4876                         tdata->plaintext.len,
4877                         "GCM plaintext data not as expected");
4878
4879         TEST_ASSERT_EQUAL(ut_params->op->status,
4880                         RTE_CRYPTO_OP_STATUS_SUCCESS,
4881                         "GCM authentication failed");
4882         return 0;
4883 }
4884
4885 static int
4886 test_mb_AES_GCM_authenticated_decryption_test_case_1(void)
4887 {
4888         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_1);
4889 }
4890
4891 static int
4892 test_mb_AES_GCM_authenticated_decryption_test_case_2(void)
4893 {
4894         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_2);
4895 }
4896
4897 static int
4898 test_mb_AES_GCM_authenticated_decryption_test_case_3(void)
4899 {
4900         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_3);
4901 }
4902
4903 static int
4904 test_mb_AES_GCM_authenticated_decryption_test_case_4(void)
4905 {
4906         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_4);
4907 }
4908
4909 static int
4910 test_mb_AES_GCM_authenticated_decryption_test_case_5(void)
4911 {
4912         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_5);
4913 }
4914
4915 static int
4916 test_mb_AES_GCM_authenticated_decryption_test_case_6(void)
4917 {
4918         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_6);
4919 }
4920
4921 static int
4922 test_mb_AES_GCM_authenticated_decryption_test_case_7(void)
4923 {
4924         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_7);
4925 }
4926
4927 static int
4928 test_mb_AES_GCM_auth_decryption_test_case_256_1(void)
4929 {
4930         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_1);
4931 }
4932
4933 static int
4934 test_mb_AES_GCM_auth_decryption_test_case_256_2(void)
4935 {
4936         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_2);
4937 }
4938
4939 static int
4940 test_mb_AES_GCM_auth_decryption_test_case_256_3(void)
4941 {
4942         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_3);
4943 }
4944
4945 static int
4946 test_mb_AES_GCM_auth_decryption_test_case_256_4(void)
4947 {
4948         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_4);
4949 }
4950
4951 static int
4952 test_mb_AES_GCM_auth_decryption_test_case_256_5(void)
4953 {
4954         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_5);
4955 }
4956
4957 static int
4958 test_mb_AES_GCM_auth_decryption_test_case_256_6(void)
4959 {
4960         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_6);
4961 }
4962
4963 static int
4964 test_mb_AES_GCM_auth_decryption_test_case_256_7(void)
4965 {
4966         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_7);
4967 }
4968
4969 static int
4970 test_mb_AES_GCM_auth_decryption_test_case_aad_1(void)
4971 {
4972         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_aad_1);
4973 }
4974
4975 static int
4976 test_mb_AES_GCM_auth_decryption_test_case_aad_2(void)
4977 {
4978         return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_aad_2);
4979 }
4980
4981 static int
4982 test_AES_GCM_authenticated_encryption_oop(const struct gcm_test_data *tdata)
4983 {
4984         struct crypto_testsuite_params *ts_params = &testsuite_params;
4985         struct crypto_unittest_params *ut_params = &unittest_params;
4986
4987         int retval;
4988         uint8_t *ciphertext, *auth_tag;
4989         uint16_t plaintext_pad_len;
4990
4991         /* Create GCM session */
4992         retval = create_gcm_session(ts_params->valid_devs[0],
4993                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4994                         tdata->key.data, tdata->key.len,
4995                         tdata->aad.len, tdata->auth_tag.len,
4996                         RTE_CRYPTO_AUTH_OP_GENERATE);
4997         if (retval < 0)
4998                 return retval;
4999
5000         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5001         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5002
5003         /* clear mbuf payload */
5004         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5005                         rte_pktmbuf_tailroom(ut_params->ibuf));
5006         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5007                         rte_pktmbuf_tailroom(ut_params->obuf));
5008
5009         /* Create GCM operation */
5010         retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_ENCRYPT, tdata);
5011         if (retval < 0)
5012                 return retval;
5013
5014         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5015
5016         ut_params->op->sym->m_src = ut_params->ibuf;
5017         ut_params->op->sym->m_dst = ut_params->obuf;
5018
5019         /* Process crypto operation */
5020         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5021                         ut_params->op), "failed to process sym crypto op");
5022
5023         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5024                         "crypto op processing failed");
5025
5026         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
5027
5028         ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
5029                         ut_params->op->sym->cipher.data.offset);
5030         auth_tag = ciphertext + plaintext_pad_len;
5031
5032         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
5033         TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
5034
5035         /* Validate obuf */
5036         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5037                         ciphertext,
5038                         tdata->ciphertext.data,
5039                         tdata->ciphertext.len,
5040                         "GCM Ciphertext data not as expected");
5041
5042         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5043                         auth_tag,
5044                         tdata->auth_tag.data,
5045                         tdata->auth_tag.len,
5046                         "GCM Generated auth tag not as expected");
5047
5048         return 0;
5049
5050 }
5051
5052 static int
5053 test_mb_AES_GCM_authenticated_encryption_oop(void)
5054 {
5055         return test_AES_GCM_authenticated_encryption_oop(&gcm_test_case_5);
5056 }
5057
5058 static int
5059 test_AES_GCM_authenticated_decryption_oop(const struct gcm_test_data *tdata)
5060 {
5061         struct crypto_testsuite_params *ts_params = &testsuite_params;
5062         struct crypto_unittest_params *ut_params = &unittest_params;
5063
5064         int retval;
5065         uint8_t *plaintext;
5066
5067         /* Create GCM session */
5068         retval = create_gcm_session(ts_params->valid_devs[0],
5069                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
5070                         tdata->key.data, tdata->key.len,
5071                         tdata->aad.len, tdata->auth_tag.len,
5072                         RTE_CRYPTO_AUTH_OP_VERIFY);
5073         if (retval < 0)
5074                 return retval;
5075
5076         /* alloc mbuf and set payload */
5077         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5078         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5079
5080         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5081                         rte_pktmbuf_tailroom(ut_params->ibuf));
5082         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5083                         rte_pktmbuf_tailroom(ut_params->obuf));
5084
5085         /* Create GCM operation */
5086         retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_DECRYPT, tdata);
5087         if (retval < 0)
5088                 return retval;
5089
5090         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5091
5092         ut_params->op->sym->m_src = ut_params->ibuf;
5093         ut_params->op->sym->m_dst = ut_params->obuf;
5094
5095         /* Process crypto operation */
5096         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5097                         ut_params->op), "failed to process sym crypto op");
5098
5099         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5100                         "crypto op processing failed");
5101
5102         plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
5103                         ut_params->op->sym->cipher.data.offset);
5104
5105         TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
5106
5107         /* Validate obuf */
5108         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5109                         plaintext,
5110                         tdata->plaintext.data,
5111                         tdata->plaintext.len,
5112                         "GCM plaintext data not as expected");
5113
5114         TEST_ASSERT_EQUAL(ut_params->op->status,
5115                         RTE_CRYPTO_OP_STATUS_SUCCESS,
5116                         "GCM authentication failed");
5117         return 0;
5118 }
5119
5120 static int
5121 test_mb_AES_GCM_authenticated_decryption_oop(void)
5122 {
5123         return test_AES_GCM_authenticated_decryption_oop(&gcm_test_case_5);
5124 }
5125
5126 static int
5127 test_AES_GCM_authenticated_encryption_sessionless(
5128                 const struct gcm_test_data *tdata)
5129 {
5130         struct crypto_testsuite_params *ts_params = &testsuite_params;
5131         struct crypto_unittest_params *ut_params = &unittest_params;
5132
5133         int retval;
5134         uint8_t *ciphertext, *auth_tag;
5135         uint16_t plaintext_pad_len;
5136         uint8_t key[tdata->key.len + 1];
5137
5138         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5139
5140         /* clear mbuf payload */
5141         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5142                         rte_pktmbuf_tailroom(ut_params->ibuf));
5143
5144         /* Create GCM operation */
5145         retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_ENCRYPT, tdata);
5146         if (retval < 0)
5147                 return retval;
5148
5149         /* Create GCM xforms */
5150         memcpy(key, tdata->key.data, tdata->key.len);
5151         retval = create_gcm_xforms(ut_params->op,
5152                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5153                         key, tdata->key.len,
5154                         tdata->aad.len, tdata->auth_tag.len,
5155                         RTE_CRYPTO_AUTH_OP_GENERATE);
5156         if (retval < 0)
5157                 return retval;
5158
5159         ut_params->op->sym->m_src = ut_params->ibuf;
5160
5161         TEST_ASSERT_EQUAL(ut_params->op->sym->sess_type,
5162                         RTE_CRYPTO_SYM_OP_SESSIONLESS,
5163                         "crypto op session type not sessionless");
5164
5165         /* Process crypto operation */
5166         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5167                         ut_params->op), "failed to process sym crypto op");
5168
5169         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
5170
5171         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5172                         "crypto op status not success");
5173
5174         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
5175
5176         ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
5177                         ut_params->op->sym->cipher.data.offset);
5178         auth_tag = ciphertext + plaintext_pad_len;
5179
5180         TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
5181         TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
5182
5183         /* Validate obuf */
5184         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5185                         ciphertext,
5186                         tdata->ciphertext.data,
5187                         tdata->ciphertext.len,
5188                         "GCM Ciphertext data not as expected");
5189
5190         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5191                         auth_tag,
5192                         tdata->auth_tag.data,
5193                         tdata->auth_tag.len,
5194                         "GCM Generated auth tag not as expected");
5195
5196         return 0;
5197
5198 }
5199
5200 static int
5201 test_mb_AES_GCM_authenticated_encryption_sessionless(void)
5202 {
5203         return test_AES_GCM_authenticated_encryption_sessionless(
5204                         &gcm_test_case_5);
5205 }
5206
5207 static int
5208 test_AES_GCM_authenticated_decryption_sessionless(
5209                 const struct gcm_test_data *tdata)
5210 {
5211         struct crypto_testsuite_params *ts_params = &testsuite_params;
5212         struct crypto_unittest_params *ut_params = &unittest_params;
5213
5214         int retval;
5215         uint8_t *plaintext;
5216         uint8_t key[tdata->key.len + 1];
5217
5218         /* alloc mbuf and set payload */
5219         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5220
5221         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5222                         rte_pktmbuf_tailroom(ut_params->ibuf));
5223
5224         /* Create GCM operation */
5225         retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_DECRYPT, tdata);
5226         if (retval < 0)
5227                 return retval;
5228
5229         /* Create GCM xforms */
5230         memcpy(key, tdata->key.data, tdata->key.len);
5231         retval = create_gcm_xforms(ut_params->op,
5232                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
5233                         key, tdata->key.len,
5234                         tdata->aad.len, tdata->auth_tag.len,
5235                         RTE_CRYPTO_AUTH_OP_VERIFY);
5236         if (retval < 0)
5237                 return retval;
5238
5239         ut_params->op->sym->m_src = ut_params->ibuf;
5240
5241         TEST_ASSERT_EQUAL(ut_params->op->sym->sess_type,
5242                         RTE_CRYPTO_SYM_OP_SESSIONLESS,
5243                         "crypto op session type not sessionless");
5244
5245         /* Process crypto operation */
5246         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5247                         ut_params->op), "failed to process sym crypto op");
5248
5249         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
5250
5251         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5252                         "crypto op status not success");
5253
5254         plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
5255                         ut_params->op->sym->cipher.data.offset);
5256
5257         TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
5258
5259         /* Validate obuf */
5260         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5261                         plaintext,
5262                         tdata->plaintext.data,
5263                         tdata->plaintext.len,
5264                         "GCM plaintext data not as expected");
5265
5266         TEST_ASSERT_EQUAL(ut_params->op->status,
5267                         RTE_CRYPTO_OP_STATUS_SUCCESS,
5268                         "GCM authentication failed");
5269         return 0;
5270 }
5271
5272 static int
5273 test_mb_AES_GCM_authenticated_decryption_sessionless(void)
5274 {
5275         return test_AES_GCM_authenticated_decryption_sessionless(
5276                         &gcm_test_case_5);
5277 }
5278
5279 static int
5280 test_stats(void)
5281 {
5282         struct crypto_testsuite_params *ts_params = &testsuite_params;
5283         struct rte_cryptodev_stats stats;
5284         struct rte_cryptodev *dev;
5285         cryptodev_stats_get_t temp_pfn;
5286
5287         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
5288         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
5289                         &stats) == -ENODEV),
5290                 "rte_cryptodev_stats_get invalid dev failed");
5291         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
5292                 "rte_cryptodev_stats_get invalid Param failed");
5293         dev = &rte_cryptodevs[ts_params->valid_devs[0]];
5294         temp_pfn = dev->dev_ops->stats_get;
5295         dev->dev_ops->stats_get = (cryptodev_stats_get_t)0;
5296         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
5297                         == -ENOTSUP),
5298                 "rte_cryptodev_stats_get invalid Param failed");
5299         dev->dev_ops->stats_get = temp_pfn;
5300
5301         /* Test expected values */
5302         ut_setup();
5303         test_AES_CBC_HMAC_SHA1_encrypt_digest();
5304         ut_teardown();
5305         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
5306                         &stats),
5307                 "rte_cryptodev_stats_get failed");
5308         TEST_ASSERT((stats.enqueued_count == 1),
5309                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
5310         TEST_ASSERT((stats.dequeued_count == 1),
5311                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
5312         TEST_ASSERT((stats.enqueue_err_count == 0),
5313                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
5314         TEST_ASSERT((stats.dequeue_err_count == 0),
5315                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
5316
5317         /* invalid device but should ignore and not reset device stats*/
5318         rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
5319         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
5320                         &stats),
5321                 "rte_cryptodev_stats_get failed");
5322         TEST_ASSERT((stats.enqueued_count == 1),
5323                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
5324
5325         /* check that a valid reset clears stats */
5326         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
5327         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
5328                         &stats),
5329                                           "rte_cryptodev_stats_get failed");
5330         TEST_ASSERT((stats.enqueued_count == 0),
5331                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
5332         TEST_ASSERT((stats.dequeued_count == 0),
5333                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
5334
5335         return TEST_SUCCESS;
5336 }
5337
5338 static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
5339                                    struct crypto_unittest_params *ut_params,
5340                                    enum rte_crypto_auth_operation op,
5341                                    const struct HMAC_MD5_vector *test_case)
5342 {
5343         uint8_t key[64];
5344
5345         memcpy(key, test_case->key.data, test_case->key.len);
5346
5347         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5348         ut_params->auth_xform.next = NULL;
5349         ut_params->auth_xform.auth.op = op;
5350
5351         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC;
5352
5353         ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN;
5354         ut_params->auth_xform.auth.add_auth_data_length = 0;
5355         ut_params->auth_xform.auth.key.length = test_case->key.len;
5356         ut_params->auth_xform.auth.key.data = key;
5357
5358         ut_params->sess = rte_cryptodev_sym_session_create(
5359                 ts_params->valid_devs[0], &ut_params->auth_xform);
5360
5361         if (ut_params->sess == NULL)
5362                 return TEST_FAILED;
5363
5364         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5365
5366         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5367                         rte_pktmbuf_tailroom(ut_params->ibuf));
5368
5369         return 0;
5370 }
5371
5372 static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
5373                               const struct HMAC_MD5_vector *test_case,
5374                               uint8_t **plaintext)
5375 {
5376         uint16_t plaintext_pad_len;
5377
5378         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
5379
5380         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
5381                                 16);
5382
5383         *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5384                         plaintext_pad_len);
5385         memcpy(*plaintext, test_case->plaintext.data,
5386                         test_case->plaintext.len);
5387
5388         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
5389                         ut_params->ibuf, MD5_DIGEST_LEN);
5390         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
5391                         "no room to append digest");
5392         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
5393                         ut_params->ibuf, plaintext_pad_len);
5394         sym_op->auth.digest.length = MD5_DIGEST_LEN;
5395
5396         if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
5397                 rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data,
5398                            test_case->auth_tag.len);
5399         }
5400
5401         sym_op->auth.data.offset = 0;
5402         sym_op->auth.data.length = test_case->plaintext.len;
5403
5404         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5405         ut_params->op->sym->m_src = ut_params->ibuf;
5406
5407         return 0;
5408 }
5409
5410 static int
5411 test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
5412 {
5413         uint16_t plaintext_pad_len;
5414         uint8_t *plaintext, *auth_tag;
5415
5416         struct crypto_testsuite_params *ts_params = &testsuite_params;
5417         struct crypto_unittest_params *ut_params = &unittest_params;
5418
5419         if (MD5_HMAC_create_session(ts_params, ut_params,
5420                         RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
5421                 return TEST_FAILED;
5422
5423         /* Generate Crypto op data structure */
5424         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
5425                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
5426         TEST_ASSERT_NOT_NULL(ut_params->op,
5427                         "Failed to allocate symmetric crypto operation struct");
5428
5429         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
5430                                 16);
5431
5432         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
5433                 return TEST_FAILED;
5434
5435         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5436                         ut_params->op), "failed to process sym crypto op");
5437
5438         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5439                         "crypto op processing failed");
5440
5441         if (ut_params->op->sym->m_dst) {
5442                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
5443                                 uint8_t *, plaintext_pad_len);
5444         } else {
5445                 auth_tag = plaintext + plaintext_pad_len;
5446         }
5447
5448         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5449                         auth_tag,
5450                         test_case->auth_tag.data,
5451                         test_case->auth_tag.len,
5452                         "HMAC_MD5 generated tag not as expected");
5453
5454         return TEST_SUCCESS;
5455 }
5456
5457 static int
5458 test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
5459 {
5460         uint8_t *plaintext;
5461
5462         struct crypto_testsuite_params *ts_params = &testsuite_params;
5463         struct crypto_unittest_params *ut_params = &unittest_params;
5464
5465         if (MD5_HMAC_create_session(ts_params, ut_params,
5466                         RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
5467                 return TEST_FAILED;
5468         }
5469
5470         /* Generate Crypto op data structure */
5471         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
5472                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
5473         TEST_ASSERT_NOT_NULL(ut_params->op,
5474                         "Failed to allocate symmetric crypto operation struct");
5475
5476         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
5477                 return TEST_FAILED;
5478
5479         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
5480                         ut_params->op), "failed to process sym crypto op");
5481
5482         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5483                         "HMAC_MD5 crypto op processing failed");
5484
5485         return TEST_SUCCESS;
5486 }
5487
5488 static int
5489 test_MD5_HMAC_generate_case_1(void)
5490 {
5491         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1);
5492 }
5493
5494 static int
5495 test_MD5_HMAC_verify_case_1(void)
5496 {
5497         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1);
5498 }
5499
5500 static int
5501 test_MD5_HMAC_generate_case_2(void)
5502 {
5503         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2);
5504 }
5505
5506 static int
5507 test_MD5_HMAC_verify_case_2(void)
5508 {
5509         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2);
5510 }
5511
5512 static int
5513 test_multi_session(void)
5514 {
5515         struct crypto_testsuite_params *ts_params = &testsuite_params;
5516         struct crypto_unittest_params *ut_params = &unittest_params;
5517
5518         struct rte_cryptodev_info dev_info;
5519         struct rte_cryptodev_sym_session **sessions;
5520
5521         uint16_t i;
5522
5523         test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
5524                         aes_cbc_key, hmac_sha512_key);
5525
5526
5527         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5528
5529         sessions = rte_malloc(NULL,
5530                         (sizeof(struct rte_cryptodev_sym_session *) *
5531                         dev_info.sym.max_nb_sessions) + 1, 0);
5532
5533         /* Create multiple crypto sessions*/
5534         for (i = 0; i < dev_info.sym.max_nb_sessions; i++) {
5535                 sessions[i] = rte_cryptodev_sym_session_create(
5536                                 ts_params->valid_devs[0],
5537                         &ut_params->auth_xform);
5538                 TEST_ASSERT_NOT_NULL(sessions[i],
5539                                 "Session creation failed at session number %u",
5540                                 i);
5541
5542                 /* Attempt to send a request on each session */
5543                 TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform(
5544                         sessions[i],
5545                         ut_params,
5546                         ts_params,
5547                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
5548                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
5549                         aes_cbc_iv),
5550                         "Failed to perform decrypt on request number %u.", i);
5551                 /* free crypto operation structure */
5552                 if (ut_params->op)
5553                         rte_crypto_op_free(ut_params->op);
5554
5555                 /*
5556                  * free mbuf - both obuf and ibuf are usually the same,
5557                  * so check if they point at the same address is necessary,
5558                  * to avoid freeing the mbuf twice.
5559                  */
5560                 if (ut_params->obuf) {
5561                         rte_pktmbuf_free(ut_params->obuf);
5562                         if (ut_params->ibuf == ut_params->obuf)
5563                                 ut_params->ibuf = 0;
5564                         ut_params->obuf = 0;
5565                 }
5566                 if (ut_params->ibuf) {
5567                         rte_pktmbuf_free(ut_params->ibuf);
5568                         ut_params->ibuf = 0;
5569                 }
5570         }
5571
5572         /* Next session create should fail */
5573         sessions[i] = rte_cryptodev_sym_session_create(ts_params->valid_devs[0],
5574                         &ut_params->auth_xform);
5575         TEST_ASSERT_NULL(sessions[i],
5576                         "Session creation succeeded unexpectedly!");
5577
5578         for (i = 0; i < dev_info.sym.max_nb_sessions; i++)
5579                 rte_cryptodev_sym_session_free(ts_params->valid_devs[0],
5580                                 sessions[i]);
5581
5582         rte_free(sessions);
5583
5584         return TEST_SUCCESS;
5585 }
5586
5587 struct multi_session_params {
5588         struct crypto_unittest_params ut_params;
5589         uint8_t *cipher_key;
5590         uint8_t *hmac_key;
5591         const uint8_t *cipher;
5592         const uint8_t *digest;
5593         uint8_t *iv;
5594 };
5595
5596 #define MB_SESSION_NUMBER 3
5597
5598 static int
5599 test_multi_session_random_usage(void)
5600 {
5601         struct crypto_testsuite_params *ts_params = &testsuite_params;
5602         struct rte_cryptodev_info dev_info;
5603         struct rte_cryptodev_sym_session **sessions;
5604         uint32_t i, j;
5605         struct multi_session_params ut_paramz[] = {
5606
5607                 {
5608                         .cipher_key = ms_aes_cbc_key0,
5609                         .hmac_key = ms_hmac_key0,
5610                         .cipher = ms_aes_cbc_cipher0,
5611                         .digest = ms_hmac_digest0,
5612                         .iv = ms_aes_cbc_iv0
5613                 },
5614                 {
5615                         .cipher_key = ms_aes_cbc_key1,
5616                         .hmac_key = ms_hmac_key1,
5617                         .cipher = ms_aes_cbc_cipher1,
5618                         .digest = ms_hmac_digest1,
5619                         .iv = ms_aes_cbc_iv1
5620                 },
5621                 {
5622                         .cipher_key = ms_aes_cbc_key2,
5623                         .hmac_key = ms_hmac_key2,
5624                         .cipher = ms_aes_cbc_cipher2,
5625                         .digest = ms_hmac_digest2,
5626                         .iv = ms_aes_cbc_iv2
5627                 },
5628
5629         };
5630
5631         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5632
5633         sessions = rte_malloc(NULL,
5634                         (sizeof(struct rte_cryptodev_sym_session *)
5635                                         * dev_info.sym.max_nb_sessions) + 1, 0);
5636
5637         for (i = 0; i < MB_SESSION_NUMBER; i++) {
5638                 rte_memcpy(&ut_paramz[i].ut_params, &testsuite_params,
5639                                 sizeof(struct crypto_unittest_params));
5640
5641                 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
5642                                 &ut_paramz[i].ut_params,
5643                                 ut_paramz[i].cipher_key, ut_paramz[i].hmac_key);
5644
5645                 /* Create multiple crypto sessions*/
5646                 sessions[i] = rte_cryptodev_sym_session_create(
5647                                 ts_params->valid_devs[0],
5648                                 &ut_paramz[i].ut_params.auth_xform);
5649
5650                 TEST_ASSERT_NOT_NULL(sessions[i],
5651                                 "Session creation failed at session number %u",
5652                                 i);
5653
5654         }
5655
5656         srand(time(NULL));
5657         for (i = 0; i < 40000; i++) {
5658
5659                 j = rand() % MB_SESSION_NUMBER;
5660
5661                 TEST_ASSERT_SUCCESS(
5662                         test_AES_CBC_HMAC_SHA512_decrypt_perform(
5663                                         sessions[j],
5664                                         &ut_paramz[j].ut_params,
5665                                         ts_params, ut_paramz[j].cipher,
5666                                         ut_paramz[j].digest,
5667                                         ut_paramz[j].iv),
5668                         "Failed to perform decrypt on request number %u.", i);
5669
5670                 if (ut_paramz[j].ut_params.op)
5671                         rte_crypto_op_free(ut_paramz[j].ut_params.op);
5672
5673                 /*
5674                  * free mbuf - both obuf and ibuf are usually the same,
5675                  * so check if they point at the same address is necessary,
5676                  * to avoid freeing the mbuf twice.
5677                  */
5678                 if (ut_paramz[j].ut_params.obuf) {
5679                         rte_pktmbuf_free(ut_paramz[j].ut_params.obuf);
5680                         if (ut_paramz[j].ut_params.ibuf
5681                                         == ut_paramz[j].ut_params.obuf)
5682                                 ut_paramz[j].ut_params.ibuf = 0;
5683                         ut_paramz[j].ut_params.obuf = 0;
5684                 }
5685                 if (ut_paramz[j].ut_params.ibuf) {
5686                         rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf);
5687                         ut_paramz[j].ut_params.ibuf = 0;
5688                 }
5689         }
5690
5691         for (i = 0; i < MB_SESSION_NUMBER; i++)
5692                 rte_cryptodev_sym_session_free(ts_params->valid_devs[0],
5693                                 sessions[i]);
5694
5695         rte_free(sessions);
5696
5697         return TEST_SUCCESS;
5698 }
5699
5700 static int
5701 test_null_cipher_only_operation(void)
5702 {
5703         struct crypto_testsuite_params *ts_params = &testsuite_params;
5704         struct crypto_unittest_params *ut_params = &unittest_params;
5705
5706         /* Generate test mbuf data and space for digest */
5707         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
5708                         catch_22_quote, QUOTE_512_BYTES, 0);
5709
5710         /* Setup Cipher Parameters */
5711         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5712         ut_params->cipher_xform.next = NULL;
5713
5714         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
5715         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
5716
5717         /* Create Crypto session*/
5718         ut_params->sess = rte_cryptodev_sym_session_create(
5719                         ts_params->valid_devs[0], &ut_params->cipher_xform);
5720         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
5721
5722         /* Generate Crypto op data structure */
5723         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
5724                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
5725         TEST_ASSERT_NOT_NULL(ut_params->op,
5726                         "Failed to allocate symmetric crypto operation struct");
5727
5728         /* Set crypto operation data parameters */
5729         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5730
5731         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
5732
5733         /* set crypto operation source mbuf */
5734         sym_op->m_src = ut_params->ibuf;
5735
5736         sym_op->cipher.data.offset = 0;
5737         sym_op->cipher.data.length = QUOTE_512_BYTES;
5738
5739         /* Process crypto operation */
5740         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5741                         ut_params->op);
5742         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
5743
5744         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5745                         "crypto operation processing failed");
5746
5747         /* Validate obuf */
5748         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5749                         rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
5750                         catch_22_quote,
5751                         QUOTE_512_BYTES,
5752                         "Ciphertext data not as expected");
5753
5754         return TEST_SUCCESS;
5755 }
5756
5757 static int
5758 test_null_auth_only_operation(void)
5759 {
5760         struct crypto_testsuite_params *ts_params = &testsuite_params;
5761         struct crypto_unittest_params *ut_params = &unittest_params;
5762
5763         /* Generate test mbuf data and space for digest */
5764         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
5765                         catch_22_quote, QUOTE_512_BYTES, 0);
5766
5767         /* Setup HMAC Parameters */
5768         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5769         ut_params->auth_xform.next = NULL;
5770
5771         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
5772         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
5773
5774         /* Create Crypto session*/
5775         ut_params->sess = rte_cryptodev_sym_session_create(
5776                         ts_params->valid_devs[0], &ut_params->auth_xform);
5777         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
5778
5779         /* Generate Crypto op data structure */
5780         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
5781                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
5782         TEST_ASSERT_NOT_NULL(ut_params->op,
5783                         "Failed to allocate symmetric crypto operation struct");
5784
5785         /* Set crypto operation data parameters */
5786         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5787
5788         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
5789
5790         sym_op->m_src = ut_params->ibuf;
5791
5792         sym_op->auth.data.offset = 0;
5793         sym_op->auth.data.length = QUOTE_512_BYTES;
5794
5795         /* Process crypto operation */
5796         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5797                         ut_params->op);
5798         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
5799
5800         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5801                         "crypto operation processing failed");
5802
5803         return TEST_SUCCESS;
5804 }
5805
5806 static int
5807 test_null_cipher_auth_operation(void)
5808 {
5809         struct crypto_testsuite_params *ts_params = &testsuite_params;
5810         struct crypto_unittest_params *ut_params = &unittest_params;
5811
5812         /* Generate test mbuf data and space for digest */
5813         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
5814                         catch_22_quote, QUOTE_512_BYTES, 0);
5815
5816         /* Setup Cipher Parameters */
5817         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5818         ut_params->cipher_xform.next = &ut_params->auth_xform;
5819
5820         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
5821         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
5822
5823         /* Setup HMAC Parameters */
5824         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5825         ut_params->auth_xform.next = NULL;
5826
5827         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
5828         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
5829
5830         /* Create Crypto session*/
5831         ut_params->sess = rte_cryptodev_sym_session_create(
5832                         ts_params->valid_devs[0], &ut_params->cipher_xform);
5833         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
5834
5835         /* Generate Crypto op data structure */
5836         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
5837                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
5838         TEST_ASSERT_NOT_NULL(ut_params->op,
5839                         "Failed to allocate symmetric crypto operation struct");
5840
5841         /* Set crypto operation data parameters */
5842         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5843
5844         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
5845
5846         sym_op->m_src = ut_params->ibuf;
5847
5848         sym_op->cipher.data.offset = 0;
5849         sym_op->cipher.data.length = QUOTE_512_BYTES;
5850
5851         sym_op->auth.data.offset = 0;
5852         sym_op->auth.data.length = QUOTE_512_BYTES;
5853
5854         /* Process crypto operation */
5855         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5856                         ut_params->op);
5857         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
5858
5859         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5860                         "crypto operation processing failed");
5861
5862         /* Validate obuf */
5863         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5864                         rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
5865                         catch_22_quote,
5866                         QUOTE_512_BYTES,
5867                         "Ciphertext data not as expected");
5868
5869         return TEST_SUCCESS;
5870 }
5871
5872 static int
5873 test_null_auth_cipher_operation(void)
5874 {
5875         struct crypto_testsuite_params *ts_params = &testsuite_params;
5876         struct crypto_unittest_params *ut_params = &unittest_params;
5877
5878         /* Generate test mbuf data and space for digest */
5879         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
5880                         catch_22_quote, QUOTE_512_BYTES, 0);
5881
5882         /* Setup Cipher Parameters */
5883         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5884         ut_params->cipher_xform.next = NULL;
5885
5886         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
5887         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
5888
5889         /* Setup HMAC Parameters */
5890         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5891         ut_params->auth_xform.next = &ut_params->cipher_xform;
5892
5893         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
5894         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
5895
5896         /* Create Crypto session*/
5897         ut_params->sess = rte_cryptodev_sym_session_create(
5898                         ts_params->valid_devs[0], &ut_params->cipher_xform);
5899         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
5900
5901         /* Generate Crypto op data structure */
5902         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
5903                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
5904         TEST_ASSERT_NOT_NULL(ut_params->op,
5905                         "Failed to allocate symmetric crypto operation struct");
5906
5907         /* Set crypto operation data parameters */
5908         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
5909
5910         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
5911
5912         sym_op->m_src = ut_params->ibuf;
5913
5914         sym_op->cipher.data.offset = 0;
5915         sym_op->cipher.data.length = QUOTE_512_BYTES;
5916
5917         sym_op->auth.data.offset = 0;
5918         sym_op->auth.data.length = QUOTE_512_BYTES;
5919
5920         /* Process crypto operation */
5921         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5922                         ut_params->op);
5923         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
5924
5925         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
5926                         "crypto operation processing failed");
5927
5928         /* Validate obuf */
5929         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5930                         rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *),
5931                         catch_22_quote,
5932                         QUOTE_512_BYTES,
5933                         "Ciphertext data not as expected");
5934
5935         return TEST_SUCCESS;
5936 }
5937
5938
5939 static int
5940 test_null_invalid_operation(void)
5941 {
5942         struct crypto_testsuite_params *ts_params = &testsuite_params;
5943         struct crypto_unittest_params *ut_params = &unittest_params;
5944
5945         /* Setup Cipher Parameters */
5946         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5947         ut_params->cipher_xform.next = NULL;
5948
5949         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
5950         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
5951
5952         /* Create Crypto session*/
5953         ut_params->sess = rte_cryptodev_sym_session_create(
5954                         ts_params->valid_devs[0], &ut_params->cipher_xform);
5955         TEST_ASSERT_NULL(ut_params->sess,
5956                         "Session creation succeeded unexpectedly");
5957
5958
5959         /* Setup HMAC Parameters */
5960         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5961         ut_params->auth_xform.next = NULL;
5962
5963         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
5964         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
5965
5966         /* Create Crypto session*/
5967         ut_params->sess = rte_cryptodev_sym_session_create(
5968                         ts_params->valid_devs[0], &ut_params->auth_xform);
5969         TEST_ASSERT_NULL(ut_params->sess,
5970                         "Session creation succeeded unexpectedly");
5971
5972         return TEST_SUCCESS;
5973 }
5974
5975
5976 #define NULL_BURST_LENGTH (32)
5977
5978 static int
5979 test_null_burst_operation(void)
5980 {
5981         struct crypto_testsuite_params *ts_params = &testsuite_params;
5982         struct crypto_unittest_params *ut_params = &unittest_params;
5983
5984         unsigned i, burst_len = NULL_BURST_LENGTH;
5985
5986         struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
5987         struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
5988
5989         /* Setup Cipher Parameters */
5990         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5991         ut_params->cipher_xform.next = &ut_params->auth_xform;
5992
5993         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
5994         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
5995
5996         /* Setup HMAC Parameters */
5997         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5998         ut_params->auth_xform.next = NULL;
5999
6000         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
6001         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
6002
6003         /* Create Crypto session*/
6004         ut_params->sess = rte_cryptodev_sym_session_create(
6005                         ts_params->valid_devs[0], &ut_params->cipher_xform);
6006         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6007
6008         TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
6009                         RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
6010                         burst_len, "failed to generate burst of crypto ops");
6011
6012         /* Generate an operation for each mbuf in burst */
6013         for (i = 0; i < burst_len; i++) {
6014                 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6015
6016                 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
6017
6018                 unsigned *data = (unsigned *)rte_pktmbuf_append(m,
6019                                 sizeof(unsigned));
6020                 *data = i;
6021
6022                 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
6023
6024                 burst[i]->sym->m_src = m;
6025         }
6026
6027         /* Process crypto operation */
6028         TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
6029                         0, burst, burst_len),
6030                         burst_len,
6031                         "Error enqueuing burst");
6032
6033         TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
6034                         0, burst_dequeued, burst_len),
6035                         burst_len,
6036                         "Error dequeuing burst");
6037
6038
6039         for (i = 0; i < burst_len; i++) {
6040                 TEST_ASSERT_EQUAL(
6041                         *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
6042                         *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
6043                                         uint32_t *),
6044                         "data not as expected");
6045
6046                 rte_pktmbuf_free(burst[i]->sym->m_src);
6047                 rte_crypto_op_free(burst[i]);
6048         }
6049
6050         return TEST_SUCCESS;
6051 }
6052
6053 static void
6054 generate_gmac_large_plaintext(uint8_t *data)
6055 {
6056         uint16_t i;
6057
6058         for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32)
6059                 memcpy(&data[i], &data[0], 32);
6060 }
6061
6062 static int
6063 create_gmac_operation(enum rte_crypto_auth_operation op,
6064                 const struct gmac_test_data *tdata)
6065 {
6066         struct crypto_testsuite_params *ts_params = &testsuite_params;
6067         struct crypto_unittest_params *ut_params = &unittest_params;
6068         struct rte_crypto_sym_op *sym_op;
6069
6070         unsigned iv_pad_len;
6071         unsigned aad_pad_len;
6072
6073         iv_pad_len = RTE_ALIGN_CEIL(tdata->iv.len, 16);
6074         aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
6075
6076         /*
6077          * Runtime generate the large plain text instead of use hard code
6078          * plain text vector. It is done to avoid create huge source file
6079          * with the test vector.
6080          */
6081         if (tdata->aad.len == GMAC_LARGE_PLAINTEXT_LENGTH)
6082                 generate_gmac_large_plaintext(tdata->aad.data);
6083
6084         /* Generate Crypto op data structure */
6085         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
6086                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
6087         TEST_ASSERT_NOT_NULL(ut_params->op,
6088                         "Failed to allocate symmetric crypto operation struct");
6089
6090         sym_op = ut_params->op->sym;
6091         sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6092                         aad_pad_len);
6093         TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
6094                         "no room to append aad");
6095
6096         sym_op->auth.aad.length = tdata->aad.len;
6097         sym_op->auth.aad.phys_addr =
6098                         rte_pktmbuf_mtophys(ut_params->ibuf);
6099         memcpy(sym_op->auth.aad.data, tdata->aad.data, tdata->aad.len);
6100
6101         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
6102                         ut_params->ibuf, tdata->gmac_tag.len);
6103         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
6104                         "no room to append digest");
6105
6106         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
6107                         ut_params->ibuf, aad_pad_len);
6108         sym_op->auth.digest.length = tdata->gmac_tag.len;
6109
6110         if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
6111                 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
6112                                 tdata->gmac_tag.len);
6113                 TEST_HEXDUMP(stdout, "digest:",
6114                                 sym_op->auth.digest.data,
6115                                 sym_op->auth.digest.length);
6116         }
6117
6118         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
6119                         ut_params->ibuf, iv_pad_len);
6120         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
6121
6122         memset(sym_op->cipher.iv.data, 0, iv_pad_len);
6123         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
6124         sym_op->cipher.iv.length = tdata->iv.len;
6125
6126         rte_memcpy(sym_op->cipher.iv.data, tdata->iv.data, tdata->iv.len);
6127
6128         TEST_HEXDUMP(stdout, "iv:", sym_op->cipher.iv.data, iv_pad_len);
6129
6130         sym_op->cipher.data.length = 0;
6131         sym_op->cipher.data.offset = 0;
6132
6133         sym_op->auth.data.offset = 0;
6134         sym_op->auth.data.length = 0;
6135
6136         return 0;
6137 }
6138
6139 static int create_gmac_session(uint8_t dev_id,
6140                 enum rte_crypto_cipher_operation op,
6141                 const struct gmac_test_data *tdata,
6142                 enum rte_crypto_auth_operation auth_op)
6143 {
6144         uint8_t cipher_key[tdata->key.len];
6145
6146         struct crypto_unittest_params *ut_params = &unittest_params;
6147
6148         memcpy(cipher_key, tdata->key.data, tdata->key.len);
6149
6150         /* For GMAC we setup cipher parameters */
6151         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
6152         ut_params->cipher_xform.next = NULL;
6153         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_GCM;
6154         ut_params->cipher_xform.cipher.op = op;
6155         ut_params->cipher_xform.cipher.key.data = cipher_key;
6156         ut_params->cipher_xform.cipher.key.length = tdata->key.len;
6157
6158         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6159         ut_params->auth_xform.next = NULL;
6160
6161         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
6162         ut_params->auth_xform.auth.op = auth_op;
6163         ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
6164         ut_params->auth_xform.auth.add_auth_data_length = 0;
6165         ut_params->auth_xform.auth.key.length = 0;
6166         ut_params->auth_xform.auth.key.data = NULL;
6167
6168         ut_params->cipher_xform.next = &ut_params->auth_xform;
6169
6170         ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
6171                         &ut_params->cipher_xform);
6172
6173         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6174
6175         return 0;
6176 }
6177
6178 static int
6179 test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
6180 {
6181         struct crypto_testsuite_params *ts_params = &testsuite_params;
6182         struct crypto_unittest_params *ut_params = &unittest_params;
6183
6184         int retval;
6185
6186         uint8_t *auth_tag, *p;
6187         uint16_t aad_pad_len;
6188
6189         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
6190                               "No GMAC length in the source data");
6191
6192         retval = create_gmac_session(ts_params->valid_devs[0],
6193                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
6194                         tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
6195
6196         if (retval < 0)
6197                 return retval;
6198
6199         if (tdata->aad.len > MBUF_SIZE)
6200                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
6201         else
6202                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6203         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
6204                         "Failed to allocate input buffer in mempool");
6205
6206         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6207                         rte_pktmbuf_tailroom(ut_params->ibuf));
6208
6209         aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
6210
6211         p = rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *);
6212
6213         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
6214                         tdata);
6215
6216         if (retval < 0)
6217                 return retval;
6218
6219         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6220
6221         ut_params->op->sym->m_src = ut_params->ibuf;
6222
6223         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
6224                         ut_params->op), "failed to process sym crypto op");
6225
6226         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6227                         "crypto op processing failed");
6228
6229         if (ut_params->op->sym->m_dst) {
6230                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
6231                                 uint8_t *, aad_pad_len);
6232         } else {
6233                 auth_tag = p + aad_pad_len;
6234         }
6235
6236         TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
6237
6238         TEST_ASSERT_BUFFERS_ARE_EQUAL(
6239                         auth_tag,
6240                         tdata->gmac_tag.data,
6241                         tdata->gmac_tag.len,
6242                         "GMAC Generated auth tag not as expected");
6243
6244         return 0;
6245 }
6246
6247 static int
6248 test_AES_GMAC_authentication_test_case_1(void)
6249 {
6250         return test_AES_GMAC_authentication(&gmac_test_case_1);
6251 }
6252
6253 static int
6254 test_AES_GMAC_authentication_test_case_2(void)
6255 {
6256         return test_AES_GMAC_authentication(&gmac_test_case_2);
6257 }
6258
6259 static int
6260 test_AES_GMAC_authentication_test_case_3(void)
6261 {
6262         return test_AES_GMAC_authentication(&gmac_test_case_3);
6263 }
6264
6265 static int
6266 test_AES_GMAC_authentication_test_case_4(void)
6267 {
6268         return test_AES_GMAC_authentication(&gmac_test_case_4);
6269 }
6270
6271 static int
6272 test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
6273 {
6274         struct crypto_testsuite_params *ts_params = &testsuite_params;
6275         struct crypto_unittest_params *ut_params = &unittest_params;
6276         int retval;
6277
6278         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
6279                               "No GMAC length in the source data");
6280
6281         retval = create_gmac_session(ts_params->valid_devs[0],
6282                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
6283                         tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
6284
6285         if (retval < 0)
6286                 return retval;
6287
6288         if (tdata->aad.len > MBUF_SIZE)
6289                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
6290         else
6291                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6292         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
6293                         "Failed to allocate input buffer in mempool");
6294
6295         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6296                         rte_pktmbuf_tailroom(ut_params->ibuf));
6297
6298         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
6299                         tdata);
6300
6301         if (retval < 0)
6302                 return retval;
6303
6304         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6305
6306         ut_params->op->sym->m_src = ut_params->ibuf;
6307
6308         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
6309                         ut_params->op), "failed to process sym crypto op");
6310
6311         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6312                         "crypto op processing failed");
6313
6314         return 0;
6315
6316 }
6317
6318 static int
6319 test_AES_GMAC_authentication_verify_test_case_1(void)
6320 {
6321         return test_AES_GMAC_authentication_verify(&gmac_test_case_1);
6322 }
6323
6324 static int
6325 test_AES_GMAC_authentication_verify_test_case_2(void)
6326 {
6327         return test_AES_GMAC_authentication_verify(&gmac_test_case_2);
6328 }
6329
6330 static int
6331 test_AES_GMAC_authentication_verify_test_case_3(void)
6332 {
6333         return test_AES_GMAC_authentication_verify(&gmac_test_case_3);
6334 }
6335
6336 static int
6337 test_AES_GMAC_authentication_verify_test_case_4(void)
6338 {
6339         return test_AES_GMAC_authentication_verify(&gmac_test_case_4);
6340 }
6341
6342 struct test_crypto_vector {
6343         enum rte_crypto_cipher_algorithm crypto_algo;
6344
6345         struct {
6346                 uint8_t data[64];
6347                 unsigned int len;
6348         } cipher_key;
6349
6350         struct {
6351                 uint8_t data[64];
6352                 unsigned int len;
6353         } iv;
6354
6355         struct {
6356                 const uint8_t *data;
6357                 unsigned int len;
6358         } plaintext;
6359
6360         struct {
6361                 const uint8_t *data;
6362                 unsigned int len;
6363         } ciphertext;
6364
6365         enum rte_crypto_auth_algorithm auth_algo;
6366
6367         struct {
6368                 uint8_t data[128];
6369                 unsigned int len;
6370         } auth_key;
6371
6372         struct {
6373                 const uint8_t *data;
6374                 unsigned int len;
6375         } aad;
6376
6377         struct {
6378                 uint8_t data[128];
6379                 unsigned int len;
6380         } digest;
6381 };
6382
6383 static const struct test_crypto_vector
6384 hmac_sha1_test_crypto_vector = {
6385         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
6386         .plaintext = {
6387                 .data = plaintext_hash,
6388                 .len = 512
6389         },
6390         .auth_key = {
6391                 .data = {
6392                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
6393                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
6394                         0xDE, 0xF4, 0xDE, 0xAD
6395                 },
6396                 .len = 20
6397         },
6398         .digest = {
6399                 .data = {
6400                         0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
6401                         0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
6402                         0x3F, 0x91, 0x64, 0x59
6403                 },
6404                 .len = 20
6405         }
6406 };
6407
6408 static const struct test_crypto_vector
6409 aes128_gmac_test_vector = {
6410         .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
6411         .crypto_algo = RTE_CRYPTO_CIPHER_AES_GCM,
6412         .aad = {
6413                 .data = plaintext_hash,
6414                 .len = 512
6415         },
6416         .iv = {
6417                 .data = {
6418                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
6419                         0x08, 0x09, 0x0A, 0x0B
6420                 },
6421                 .len = 12
6422         },
6423         .cipher_key = {
6424                 .data = {
6425                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
6426                         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
6427                 },
6428                 .len = 16
6429         },
6430         .digest = {
6431                 .data = {
6432                         0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56,
6433                         0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A
6434                 },
6435                 .len = 16
6436         }
6437 };
6438
6439 static const struct test_crypto_vector
6440 aes128cbc_hmac_sha1_test_vector = {
6441         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
6442         .cipher_key = {
6443                 .data = {
6444                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
6445                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
6446                 },
6447                 .len = 16
6448         },
6449         .iv = {
6450                 .data = {
6451                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
6452                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
6453                 },
6454                 .len = 16
6455         },
6456         .plaintext = {
6457                 .data = plaintext_hash,
6458                 .len = 512
6459         },
6460         .ciphertext = {
6461                 .data = ciphertext512_aes128cbc,
6462                 .len = 512
6463         },
6464         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
6465         .auth_key = {
6466                 .data = {
6467                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
6468                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
6469                         0xDE, 0xF4, 0xDE, 0xAD
6470                 },
6471                 .len = 20
6472         },
6473         .digest = {
6474                 .data = {
6475                         0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
6476                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
6477                         0x18, 0x8C, 0x1D, 0x32
6478                 },
6479                 .len = 20
6480         }
6481 };
6482
6483 static void
6484 data_corruption(uint8_t *data)
6485 {
6486         data[0] += 1;
6487 }
6488
6489 static void
6490 tag_corruption(uint8_t *data, unsigned int tag_offset)
6491 {
6492         data[tag_offset] += 1;
6493 }
6494
6495 static int
6496 create_auth_session(struct crypto_unittest_params *ut_params,
6497                 uint8_t dev_id,
6498                 const struct test_crypto_vector *reference,
6499                 enum rte_crypto_auth_operation auth_op)
6500 {
6501         uint8_t auth_key[reference->auth_key.len + 1];
6502
6503         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
6504
6505         /* Setup Authentication Parameters */
6506         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6507         ut_params->auth_xform.auth.op = auth_op;
6508         ut_params->auth_xform.next = NULL;
6509         ut_params->auth_xform.auth.algo = reference->auth_algo;
6510         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
6511         ut_params->auth_xform.auth.key.data = auth_key;
6512         ut_params->auth_xform.auth.digest_length = reference->digest.len;
6513         ut_params->auth_xform.auth.add_auth_data_length = reference->aad.len;
6514
6515         /* Create Crypto session*/
6516         ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
6517                                 &ut_params->auth_xform);
6518
6519         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6520
6521         return 0;
6522 }
6523
6524 static int
6525 create_auth_cipher_session(struct crypto_unittest_params *ut_params,
6526                 uint8_t dev_id,
6527                 const struct test_crypto_vector *reference,
6528                 enum rte_crypto_auth_operation auth_op,
6529                 enum rte_crypto_cipher_operation cipher_op)
6530 {
6531         uint8_t cipher_key[reference->cipher_key.len + 1];
6532         uint8_t auth_key[reference->auth_key.len + 1];
6533
6534         memcpy(cipher_key, reference->cipher_key.data,
6535                         reference->cipher_key.len);
6536         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
6537
6538         /* Setup Authentication Parameters */
6539         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6540         ut_params->auth_xform.auth.op = auth_op;
6541         ut_params->auth_xform.next = &ut_params->cipher_xform;
6542         ut_params->auth_xform.auth.algo = reference->auth_algo;
6543         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
6544         ut_params->auth_xform.auth.key.data = auth_key;
6545         ut_params->auth_xform.auth.digest_length = reference->digest.len;
6546         ut_params->auth_xform.auth.add_auth_data_length = reference->aad.len;
6547
6548         /* Setup Cipher Parameters */
6549         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
6550         ut_params->cipher_xform.next = NULL;
6551         ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
6552         ut_params->cipher_xform.cipher.op = cipher_op;
6553         ut_params->cipher_xform.cipher.key.data = cipher_key;
6554         ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
6555
6556         /* Create Crypto session*/
6557         ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
6558                                 &ut_params->auth_xform);
6559
6560         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
6561
6562         return 0;
6563 }
6564
6565 static int
6566 create_auth_operation(struct crypto_testsuite_params *ts_params,
6567                 struct crypto_unittest_params *ut_params,
6568                 const struct test_crypto_vector *reference,
6569                 unsigned int auth_generate)
6570 {
6571         /* Generate Crypto op data structure */
6572         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
6573                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
6574         TEST_ASSERT_NOT_NULL(ut_params->op,
6575                         "Failed to allocate pktmbuf offload");
6576
6577         /* Set crypto operation data parameters */
6578         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6579
6580         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
6581
6582         /* set crypto operation source mbuf */
6583         sym_op->m_src = ut_params->ibuf;
6584
6585         /* digest */
6586         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
6587                         ut_params->ibuf, reference->digest.len);
6588
6589         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
6590                         "no room to append auth tag");
6591
6592         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
6593                         ut_params->ibuf, reference->plaintext.len);
6594         sym_op->auth.digest.length = reference->digest.len;
6595
6596         if (auth_generate)
6597                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
6598         else
6599                 memcpy(sym_op->auth.digest.data,
6600                                 reference->digest.data,
6601                                 reference->digest.len);
6602
6603         TEST_HEXDUMP(stdout, "digest:",
6604                         sym_op->auth.digest.data,
6605                         sym_op->auth.digest.length);
6606
6607         sym_op->auth.data.length = reference->plaintext.len;
6608         sym_op->auth.data.offset = 0;
6609
6610         return 0;
6611 }
6612
6613 static int
6614 create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
6615                 struct crypto_unittest_params *ut_params,
6616                 const struct test_crypto_vector *reference,
6617                 unsigned int auth_generate)
6618 {
6619         /* Generate Crypto op data structure */
6620         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
6621                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
6622         TEST_ASSERT_NOT_NULL(ut_params->op,
6623                         "Failed to allocate pktmbuf offload");
6624
6625         /* Set crypto operation data parameters */
6626         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6627
6628         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
6629
6630         /* set crypto operation source mbuf */
6631         sym_op->m_src = ut_params->ibuf;
6632
6633         /* aad */
6634         sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6635                         reference->aad.len);
6636         TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data, "no room to append AAD");
6637         memcpy(sym_op->auth.aad.data, reference->aad.data, reference->aad.len);
6638
6639         TEST_HEXDUMP(stdout, "AAD:", sym_op->auth.aad.data, reference->aad.len);
6640
6641         sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
6642         sym_op->auth.aad.length = reference->aad.len;
6643
6644         /* digest */
6645         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
6646                         ut_params->ibuf, reference->digest.len);
6647
6648         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
6649                         "no room to append auth tag");
6650
6651         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
6652                         ut_params->ibuf, reference->ciphertext.len);
6653         sym_op->auth.digest.length = reference->digest.len;
6654
6655         if (auth_generate)
6656                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
6657         else
6658                 memcpy(sym_op->auth.digest.data,
6659                                 reference->digest.data,
6660                                 reference->digest.len);
6661
6662         TEST_HEXDUMP(stdout, "digest:",
6663                         sym_op->auth.digest.data,
6664                         sym_op->auth.digest.length);
6665
6666         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
6667                 ut_params->ibuf, reference->iv.len);
6668         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
6669
6670         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
6671         sym_op->cipher.iv.length = reference->iv.len;
6672
6673         memcpy(sym_op->cipher.iv.data, reference->iv.data, reference->iv.len);
6674
6675         sym_op->cipher.data.length = 0;
6676         sym_op->cipher.data.offset = 0;
6677
6678         sym_op->auth.data.length = 0;
6679         sym_op->auth.data.offset = 0;
6680
6681         return 0;
6682 }
6683
6684 static int
6685 create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
6686                 struct crypto_unittest_params *ut_params,
6687                 const struct test_crypto_vector *reference,
6688                 unsigned int auth_generate)
6689 {
6690         /* Generate Crypto op data structure */
6691         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
6692                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
6693         TEST_ASSERT_NOT_NULL(ut_params->op,
6694                         "Failed to allocate pktmbuf offload");
6695
6696         /* Set crypto operation data parameters */
6697         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
6698
6699         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
6700
6701         /* set crypto operation source mbuf */
6702         sym_op->m_src = ut_params->ibuf;
6703
6704         /* digest */
6705         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
6706                         ut_params->ibuf, reference->digest.len);
6707
6708         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
6709                         "no room to append auth tag");
6710
6711         sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
6712                         ut_params->ibuf, reference->ciphertext.len);
6713         sym_op->auth.digest.length = reference->digest.len;
6714
6715         if (auth_generate)
6716                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
6717         else
6718                 memcpy(sym_op->auth.digest.data,
6719                                 reference->digest.data,
6720                                 reference->digest.len);
6721
6722         TEST_HEXDUMP(stdout, "digest:",
6723                         sym_op->auth.digest.data,
6724                         sym_op->auth.digest.length);
6725
6726         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
6727                 ut_params->ibuf, reference->iv.len);
6728         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv");
6729
6730         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
6731         sym_op->cipher.iv.length = reference->iv.len;
6732
6733         memcpy(sym_op->cipher.iv.data, reference->iv.data, reference->iv.len);
6734
6735         sym_op->cipher.data.length = reference->ciphertext.len;
6736         sym_op->cipher.data.offset = reference->iv.len;
6737
6738         sym_op->auth.data.length = reference->ciphertext.len;
6739         sym_op->auth.data.offset = reference->iv.len;
6740
6741         return 0;
6742 }
6743
6744 static int
6745 create_auth_verify_operation(struct crypto_testsuite_params *ts_params,
6746                 struct crypto_unittest_params *ut_params,
6747                 const struct test_crypto_vector *reference)
6748 {
6749         return create_auth_operation(ts_params, ut_params, reference, 0);
6750 }
6751
6752 static int
6753 create_auth_verify_GMAC_operation(
6754                 struct crypto_testsuite_params *ts_params,
6755                 struct crypto_unittest_params *ut_params,
6756                 const struct test_crypto_vector *reference)
6757 {
6758         return create_auth_GMAC_operation(ts_params, ut_params, reference, 0);
6759 }
6760
6761 static int
6762 create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params,
6763                 struct crypto_unittest_params *ut_params,
6764                 const struct test_crypto_vector *reference)
6765 {
6766         return create_cipher_auth_operation(ts_params, ut_params, reference, 0);
6767 }
6768
6769 static int
6770 test_authentication_verify_fail_when_data_corruption(
6771                 struct crypto_testsuite_params *ts_params,
6772                 struct crypto_unittest_params *ut_params,
6773                 const struct test_crypto_vector *reference,
6774                 unsigned int data_corrupted)
6775 {
6776         int retval;
6777
6778         uint8_t *plaintext;
6779
6780         /* Create session */
6781         retval = create_auth_session(ut_params,
6782                         ts_params->valid_devs[0],
6783                         reference,
6784                         RTE_CRYPTO_AUTH_OP_VERIFY);
6785         if (retval < 0)
6786                 return retval;
6787
6788         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6789         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
6790                         "Failed to allocate input buffer in mempool");
6791
6792         /* clear mbuf payload */
6793         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6794                         rte_pktmbuf_tailroom(ut_params->ibuf));
6795
6796         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6797                         reference->plaintext.len);
6798         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
6799         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
6800
6801         TEST_HEXDUMP(stdout, "plaintext:", plaintext, reference->plaintext.len);
6802
6803         /* Create operation */
6804         retval = create_auth_verify_operation(ts_params, ut_params, reference);
6805
6806         if (retval < 0)
6807                 return retval;
6808
6809         if (data_corrupted)
6810                 data_corruption(plaintext);
6811         else
6812                 tag_corruption(plaintext, reference->plaintext.len);
6813
6814         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6815                         ut_params->op);
6816         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
6817         TEST_ASSERT_EQUAL(ut_params->op->status,
6818                         RTE_CRYPTO_OP_STATUS_AUTH_FAILED,
6819                         "authentication not failed");
6820
6821         ut_params->obuf = ut_params->op->sym->m_src;
6822         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
6823
6824         return 0;
6825 }
6826
6827 static int
6828 test_authentication_verify_GMAC_fail_when_corruption(
6829                 struct crypto_testsuite_params *ts_params,
6830                 struct crypto_unittest_params *ut_params,
6831                 const struct test_crypto_vector *reference,
6832                 unsigned int data_corrupted)
6833 {
6834         int retval;
6835
6836         /* Create session */
6837         retval = create_auth_cipher_session(ut_params,
6838                         ts_params->valid_devs[0],
6839                         reference,
6840                         RTE_CRYPTO_AUTH_OP_VERIFY,
6841                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
6842         if (retval < 0)
6843                 return retval;
6844
6845         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6846         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
6847                         "Failed to allocate input buffer in mempool");
6848
6849         /* clear mbuf payload */
6850         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6851                         rte_pktmbuf_tailroom(ut_params->ibuf));
6852
6853         /* Create operation */
6854         retval = create_auth_verify_GMAC_operation(ts_params,
6855                         ut_params,
6856                         reference);
6857
6858         if (retval < 0)
6859                 return retval;
6860
6861         if (data_corrupted)
6862                 data_corruption(ut_params->op->sym->auth.aad.data);
6863         else
6864                 tag_corruption(ut_params->op->sym->auth.aad.data,
6865                                 reference->aad.len);
6866
6867         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6868                         ut_params->op);
6869         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
6870         TEST_ASSERT_EQUAL(ut_params->op->status,
6871                         RTE_CRYPTO_OP_STATUS_AUTH_FAILED,
6872                         "authentication not failed");
6873
6874         ut_params->obuf = ut_params->op->sym->m_src;
6875         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
6876
6877         return 0;
6878 }
6879
6880 static int
6881 test_authenticated_decryption_fail_when_corruption(
6882                 struct crypto_testsuite_params *ts_params,
6883                 struct crypto_unittest_params *ut_params,
6884                 const struct test_crypto_vector *reference,
6885                 unsigned int data_corrupted)
6886 {
6887         int retval;
6888
6889         uint8_t *ciphertext;
6890
6891         /* Create session */
6892         retval = create_auth_cipher_session(ut_params,
6893                         ts_params->valid_devs[0],
6894                         reference,
6895                         RTE_CRYPTO_AUTH_OP_VERIFY,
6896                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
6897         if (retval < 0)
6898                 return retval;
6899
6900         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6901         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
6902                         "Failed to allocate input buffer in mempool");
6903
6904         /* clear mbuf payload */
6905         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6906                         rte_pktmbuf_tailroom(ut_params->ibuf));
6907
6908         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6909                         reference->ciphertext.len);
6910         TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
6911         memcpy(ciphertext, reference->ciphertext.data,
6912                         reference->ciphertext.len);
6913
6914         /* Create operation */
6915         retval = create_cipher_auth_verify_operation(ts_params,
6916                         ut_params,
6917                         reference);
6918
6919         if (retval < 0)
6920                 return retval;
6921
6922         if (data_corrupted)
6923                 data_corruption(ciphertext);
6924         else
6925                 tag_corruption(ciphertext, reference->ciphertext.len);
6926
6927         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6928                         ut_params->op);
6929
6930         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
6931         TEST_ASSERT_EQUAL(ut_params->op->status,
6932                         RTE_CRYPTO_OP_STATUS_AUTH_FAILED,
6933                         "authentication not failed");
6934
6935         ut_params->obuf = ut_params->op->sym->m_src;
6936         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
6937
6938         return 0;
6939 }
6940
6941 static int
6942 create_gcm_operation_SGL(enum rte_crypto_cipher_operation op,
6943                 const struct gcm_test_data *tdata,
6944                 void *digest_mem, uint64_t digest_phys)
6945 {
6946         struct crypto_testsuite_params *ts_params = &testsuite_params;
6947         struct crypto_unittest_params *ut_params = &unittest_params;
6948
6949         const unsigned int auth_tag_len = tdata->auth_tag.len;
6950         const unsigned int iv_len = tdata->iv.len;
6951         const unsigned int aad_len = tdata->aad.len;
6952
6953         unsigned int iv_pad_len = 0;
6954
6955         /* Generate Crypto op data structure */
6956         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
6957                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
6958         TEST_ASSERT_NOT_NULL(ut_params->op,
6959                 "Failed to allocate symmetric crypto operation struct");
6960
6961         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
6962
6963         sym_op->auth.digest.data = digest_mem;
6964
6965         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
6966                         "no room to append digest");
6967
6968         sym_op->auth.digest.phys_addr = digest_phys;
6969         sym_op->auth.digest.length = auth_tag_len;
6970
6971         if (op == RTE_CRYPTO_CIPHER_OP_DECRYPT) {
6972                 rte_memcpy(sym_op->auth.digest.data, tdata->auth_tag.data,
6973                                 auth_tag_len);
6974                 TEST_HEXDUMP(stdout, "digest:",
6975                                 sym_op->auth.digest.data,
6976                                 sym_op->auth.digest.length);
6977         }
6978
6979         iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16);
6980
6981         sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(
6982                         ut_params->ibuf, iv_pad_len);
6983
6984         TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data,
6985                         "no room to prepend iv");
6986
6987         memset(sym_op->cipher.iv.data, 0, iv_pad_len);
6988         sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
6989         sym_op->cipher.iv.length = iv_len;
6990
6991         rte_memcpy(sym_op->cipher.iv.data, tdata->iv.data, iv_pad_len);
6992
6993         sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend(
6994                         ut_params->ibuf, aad_len);
6995         TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
6996                         "no room to prepend aad");
6997         sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
6998                         ut_params->ibuf);
6999         sym_op->auth.aad.length = aad_len;
7000
7001         memset(sym_op->auth.aad.data, 0, aad_len);
7002         rte_memcpy(sym_op->auth.aad.data, tdata->aad.data, aad_len);
7003
7004         TEST_HEXDUMP(stdout, "iv:", sym_op->cipher.iv.data, iv_pad_len);
7005         TEST_HEXDUMP(stdout, "aad:",
7006                         sym_op->auth.aad.data, aad_len);
7007
7008         sym_op->cipher.data.length = tdata->plaintext.len;
7009         sym_op->cipher.data.offset = aad_len + iv_pad_len;
7010
7011         sym_op->auth.data.offset = aad_len + iv_pad_len;
7012         sym_op->auth.data.length = tdata->plaintext.len;
7013
7014         return 0;
7015 }
7016
7017 #define SGL_MAX_NO      16
7018
7019 static int
7020 test_AES_GCM_authenticated_encryption_SGL(const struct gcm_test_data *tdata,
7021                 const int oop, uint32_t fragsz, uint32_t fragsz_oop)
7022 {
7023         struct crypto_testsuite_params *ts_params = &testsuite_params;
7024         struct crypto_unittest_params *ut_params = &unittest_params;
7025         struct rte_mbuf *buf, *buf_oop = NULL, *buf_last_oop = NULL;
7026         int retval;
7027         int to_trn = 0;
7028         int to_trn_tbl[SGL_MAX_NO];
7029         int segs = 1;
7030         unsigned int trn_data = 0;
7031         uint8_t *plaintext, *ciphertext, *auth_tag;
7032
7033         if (fragsz > tdata->plaintext.len)
7034                 fragsz = tdata->plaintext.len;
7035
7036         uint16_t plaintext_len = fragsz;
7037         uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
7038
7039         if (fragsz_oop > tdata->plaintext.len)
7040                 frag_size_oop = tdata->plaintext.len;
7041
7042         int ecx = 0;
7043         void *digest_mem = NULL;
7044
7045         uint32_t prepend_len = ALIGN_POW2_ROUNDUP(tdata->iv.len, 16)
7046                         + tdata->aad.len;
7047
7048         if (tdata->plaintext.len % fragsz != 0) {
7049                 if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO)
7050                         return 1;
7051         }       else {
7052                 if (tdata->plaintext.len / fragsz > SGL_MAX_NO)
7053                         return 1;
7054         }
7055
7056         /*
7057          * For out-op-place we need to alloc another mbuf
7058          */
7059         if (oop) {
7060                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7061                 rte_pktmbuf_append(ut_params->obuf,
7062                                 frag_size_oop + prepend_len);
7063                 buf_oop = ut_params->obuf;
7064         }
7065
7066         /* Create GCM session */
7067         retval = create_gcm_session(ts_params->valid_devs[0],
7068                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7069                         tdata->key.data, tdata->key.len,
7070                         tdata->aad.len, tdata->auth_tag.len,
7071                         RTE_CRYPTO_AUTH_OP_GENERATE);
7072         if (retval < 0)
7073                 return retval;
7074
7075         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7076
7077         /* clear mbuf payload */
7078         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7079                         rte_pktmbuf_tailroom(ut_params->ibuf));
7080
7081         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7082                         plaintext_len);
7083
7084         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
7085
7086         trn_data += plaintext_len;
7087
7088         buf = ut_params->ibuf;
7089
7090         /*
7091          * Loop until no more fragments
7092          */
7093
7094         while (trn_data < tdata->plaintext.len) {
7095                 ++segs;
7096                 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
7097                                 (tdata->plaintext.len - trn_data) : fragsz;
7098
7099                 to_trn_tbl[ecx++] = to_trn;
7100
7101                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7102                 buf = buf->next;
7103
7104                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
7105                                 rte_pktmbuf_tailroom(buf));
7106
7107                 /* OOP */
7108                 if (oop && !fragsz_oop) {
7109                         buf_last_oop = buf_oop->next =
7110                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
7111                         buf_oop = buf_oop->next;
7112                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
7113                                         0, rte_pktmbuf_tailroom(buf_oop));
7114                         rte_pktmbuf_append(buf_oop, to_trn);
7115                 }
7116
7117                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
7118                                 to_trn);
7119
7120                 memcpy(plaintext, tdata->plaintext.data + trn_data,
7121                                 to_trn);
7122                 trn_data += to_trn;
7123                 if (trn_data  == tdata->plaintext.len) {
7124                         if (oop) {
7125                                 if (!fragsz_oop)
7126                                         digest_mem = rte_pktmbuf_append(buf_oop,
7127                                                 tdata->auth_tag.len);
7128                         } else
7129                                 digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
7130                                         tdata->auth_tag.len);
7131                 }
7132         }
7133
7134         uint64_t digest_phys = 0;
7135
7136         ut_params->ibuf->nb_segs = segs;
7137
7138         segs = 1;
7139         if (fragsz_oop && oop) {
7140                 to_trn = 0;
7141                 ecx = 0;
7142
7143                 if (frag_size_oop == tdata->plaintext.len) {
7144                         digest_mem = rte_pktmbuf_append(ut_params->obuf,
7145                                 tdata->auth_tag.len);
7146
7147                         digest_phys = rte_pktmbuf_mtophys_offset(
7148                                         ut_params->obuf,
7149                                         tdata->plaintext.len + prepend_len);
7150                 }
7151
7152                 trn_data = frag_size_oop;
7153                 while (trn_data < tdata->plaintext.len) {
7154                         ++segs;
7155                         to_trn =
7156                                 (tdata->plaintext.len - trn_data <
7157                                                 frag_size_oop) ?
7158                                 (tdata->plaintext.len - trn_data) :
7159                                                 frag_size_oop;
7160
7161                         to_trn_tbl[ecx++] = to_trn;
7162
7163                         buf_last_oop = buf_oop->next =
7164                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
7165                         buf_oop = buf_oop->next;
7166                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
7167                                         0, rte_pktmbuf_tailroom(buf_oop));
7168                         rte_pktmbuf_append(buf_oop, to_trn);
7169
7170                         trn_data += to_trn;
7171
7172                         if (trn_data  == tdata->plaintext.len) {
7173                                 digest_mem = rte_pktmbuf_append(buf_oop,
7174                                         tdata->auth_tag.len);
7175                         }
7176                 }
7177
7178                 ut_params->obuf->nb_segs = segs;
7179         }
7180
7181         /*
7182          * Place digest at the end of the last buffer
7183          */
7184         if (!digest_phys)
7185                 digest_phys = rte_pktmbuf_mtophys(buf) + to_trn;
7186         if (oop && buf_last_oop)
7187                 digest_phys = rte_pktmbuf_mtophys(buf_last_oop) + to_trn;
7188
7189         if (!digest_mem && !oop) {
7190                 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7191                                 + tdata->auth_tag.len);
7192                 digest_phys = rte_pktmbuf_mtophys_offset(ut_params->ibuf,
7193                                 tdata->plaintext.len);
7194         }
7195
7196         /* Create GCM opertaion */
7197         retval = create_gcm_operation_SGL(RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7198                         tdata, digest_mem, digest_phys);
7199
7200         if (retval < 0)
7201                 return retval;
7202
7203         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
7204
7205         ut_params->op->sym->m_src = ut_params->ibuf;
7206         if (oop)
7207                 ut_params->op->sym->m_dst = ut_params->obuf;
7208
7209         /* Process crypto operation */
7210         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
7211                         ut_params->op), "failed to process sym crypto op");
7212
7213         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7214                         "crypto op processing failed");
7215
7216
7217         ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
7218                         uint8_t *, prepend_len);
7219         if (oop) {
7220                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
7221                                 uint8_t *, prepend_len);
7222         }
7223
7224         if (fragsz_oop)
7225                 fragsz = fragsz_oop;
7226
7227         TEST_ASSERT_BUFFERS_ARE_EQUAL(
7228                         ciphertext,
7229                         tdata->ciphertext.data,
7230                         fragsz,
7231                         "GCM Ciphertext data not as expected");
7232
7233         buf = ut_params->op->sym->m_src->next;
7234         if (oop)
7235                 buf = ut_params->op->sym->m_dst->next;
7236
7237         unsigned int off = fragsz;
7238
7239         ecx = 0;
7240         while (buf) {
7241                 ciphertext = rte_pktmbuf_mtod(buf,
7242                                 uint8_t *);
7243
7244                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7245                                 ciphertext,
7246                                 tdata->ciphertext.data + off,
7247                                 to_trn_tbl[ecx],
7248                                 "GCM Ciphertext data not as expected");
7249
7250                 off += to_trn_tbl[ecx++];
7251                 buf = buf->next;
7252         }
7253
7254         auth_tag = digest_mem;
7255         TEST_ASSERT_BUFFERS_ARE_EQUAL(
7256                         auth_tag,
7257                         tdata->auth_tag.data,
7258                         tdata->auth_tag.len,
7259                         "GCM Generated auth tag not as expected");
7260
7261         return 0;
7262 }
7263
7264 #define IN_PLACE        0
7265 #define OUT_OF_PLACE    1
7266
7267 static int
7268 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void)
7269 {
7270         return test_AES_GCM_authenticated_encryption_SGL(
7271                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 400, 400);
7272 }
7273
7274 static int
7275 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B(void)
7276 {
7277         return test_AES_GCM_authenticated_encryption_SGL(
7278                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 1500, 2000);
7279 }
7280
7281 static int
7282 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void)
7283 {
7284         return test_AES_GCM_authenticated_encryption_SGL(
7285                         &gcm_test_case_8, OUT_OF_PLACE, 400,
7286                         gcm_test_case_8.plaintext.len);
7287 }
7288
7289 static int
7290 test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void)
7291 {
7292
7293         return test_AES_GCM_authenticated_encryption_SGL(
7294                         &gcm_test_case_SGL_1, IN_PLACE, 1500, 0);
7295 }
7296
7297 static int
7298 test_authentication_verify_fail_when_data_corrupted(
7299                 struct crypto_testsuite_params *ts_params,
7300                 struct crypto_unittest_params *ut_params,
7301                 const struct test_crypto_vector *reference)
7302 {
7303         return test_authentication_verify_fail_when_data_corruption(
7304                         ts_params, ut_params, reference, 1);
7305 }
7306
7307 static int
7308 test_authentication_verify_fail_when_tag_corrupted(
7309                 struct crypto_testsuite_params *ts_params,
7310                 struct crypto_unittest_params *ut_params,
7311                 const struct test_crypto_vector *reference)
7312 {
7313         return test_authentication_verify_fail_when_data_corruption(
7314                         ts_params, ut_params, reference, 0);
7315 }
7316
7317 static int
7318 test_authentication_verify_GMAC_fail_when_data_corrupted(
7319                 struct crypto_testsuite_params *ts_params,
7320                 struct crypto_unittest_params *ut_params,
7321                 const struct test_crypto_vector *reference)
7322 {
7323         return test_authentication_verify_GMAC_fail_when_corruption(
7324                         ts_params, ut_params, reference, 1);
7325 }
7326
7327 static int
7328 test_authentication_verify_GMAC_fail_when_tag_corrupted(
7329                 struct crypto_testsuite_params *ts_params,
7330                 struct crypto_unittest_params *ut_params,
7331                 const struct test_crypto_vector *reference)
7332 {
7333         return test_authentication_verify_GMAC_fail_when_corruption(
7334                         ts_params, ut_params, reference, 0);
7335 }
7336
7337 static int
7338 test_authenticated_decryption_fail_when_data_corrupted(
7339                 struct crypto_testsuite_params *ts_params,
7340                 struct crypto_unittest_params *ut_params,
7341                 const struct test_crypto_vector *reference)
7342 {
7343         return test_authenticated_decryption_fail_when_corruption(
7344                         ts_params, ut_params, reference, 1);
7345 }
7346
7347 static int
7348 test_authenticated_decryption_fail_when_tag_corrupted(
7349                 struct crypto_testsuite_params *ts_params,
7350                 struct crypto_unittest_params *ut_params,
7351                 const struct test_crypto_vector *reference)
7352 {
7353         return test_authenticated_decryption_fail_when_corruption(
7354                         ts_params, ut_params, reference, 0);
7355 }
7356
7357 static int
7358 authentication_verify_HMAC_SHA1_fail_data_corrupt(void)
7359 {
7360         return test_authentication_verify_fail_when_data_corrupted(
7361                         &testsuite_params, &unittest_params,
7362                         &hmac_sha1_test_crypto_vector);
7363 }
7364
7365 static int
7366 authentication_verify_HMAC_SHA1_fail_tag_corrupt(void)
7367 {
7368         return test_authentication_verify_fail_when_tag_corrupted(
7369                         &testsuite_params, &unittest_params,
7370                         &hmac_sha1_test_crypto_vector);
7371 }
7372
7373 static int
7374 authentication_verify_AES128_GMAC_fail_data_corrupt(void)
7375 {
7376         return test_authentication_verify_GMAC_fail_when_data_corrupted(
7377                         &testsuite_params, &unittest_params,
7378                         &aes128_gmac_test_vector);
7379 }
7380
7381 static int
7382 authentication_verify_AES128_GMAC_fail_tag_corrupt(void)
7383 {
7384         return test_authentication_verify_GMAC_fail_when_tag_corrupted(
7385                         &testsuite_params, &unittest_params,
7386                         &aes128_gmac_test_vector);
7387 }
7388
7389 static int
7390 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void)
7391 {
7392         return test_authenticated_decryption_fail_when_data_corrupted(
7393                         &testsuite_params,
7394                         &unittest_params,
7395                         &aes128cbc_hmac_sha1_test_vector);
7396 }
7397
7398 static int
7399 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void)
7400 {
7401         return test_authenticated_decryption_fail_when_tag_corrupted(
7402                         &testsuite_params,
7403                         &unittest_params,
7404                         &aes128cbc_hmac_sha1_test_vector);
7405 }
7406
7407 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
7408
7409 /* global AESNI slave IDs for the scheduler test */
7410 uint8_t aesni_ids[2];
7411
7412 static int
7413 test_scheduler_attach_slave_op(void)
7414 {
7415         struct crypto_testsuite_params *ts_params = &testsuite_params;
7416         uint8_t sched_id = ts_params->valid_devs[0];
7417         uint32_t nb_devs, i, nb_devs_attached = 0;
7418         int ret;
7419
7420         /* create 2 AESNI_MB if necessary */
7421         nb_devs = rte_cryptodev_count_devtype(
7422                         RTE_CRYPTODEV_AESNI_MB_PMD);
7423         if (nb_devs < 2) {
7424                 for (i = nb_devs; i < 2; i++) {
7425                         ret = rte_eal_vdev_init(
7426                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL);
7427
7428                         TEST_ASSERT(ret == 0,
7429                                 "Failed to create instance %u of"
7430                                 " pmd : %s",
7431                                 i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
7432                 }
7433         }
7434
7435         /* attach 2 AESNI_MB cdevs */
7436         for (i = 0; i < rte_cryptodev_count() && nb_devs_attached < 2;
7437                         i++) {
7438                 struct rte_cryptodev_info info;
7439
7440                 rte_cryptodev_info_get(i, &info);
7441                 if (info.dev_type != RTE_CRYPTODEV_AESNI_MB_PMD)
7442                         continue;
7443
7444                 ret = rte_cryptodev_scheduler_slave_attach(sched_id,
7445                                 (uint8_t)i);
7446
7447                 TEST_ASSERT(ret == 0,
7448                         "Failed to attach device %u of pmd : %s", i,
7449                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
7450
7451                 aesni_ids[nb_devs_attached] = (uint8_t)i;
7452
7453                 nb_devs_attached++;
7454         }
7455
7456         return 0;
7457 }
7458
7459 static int
7460 test_scheduler_detach_slave_op(void)
7461 {
7462         struct crypto_testsuite_params *ts_params = &testsuite_params;
7463         uint8_t sched_id = ts_params->valid_devs[0];
7464         uint32_t i;
7465         int ret;
7466
7467         for (i = 0; i < 2; i++) {
7468                 ret = rte_cryptodev_scheduler_slave_detach(sched_id,
7469                                 aesni_ids[i]);
7470                 TEST_ASSERT(ret == 0,
7471                         "Failed to detach device %u", aesni_ids[i]);
7472         }
7473
7474         return 0;
7475 }
7476
7477 static int
7478 test_scheduler_mode_op(void)
7479 {
7480         struct crypto_testsuite_params *ts_params = &testsuite_params;
7481         uint8_t sched_id = ts_params->valid_devs[0];
7482         struct rte_cryptodev_scheduler_ops op = {0};
7483         struct rte_cryptodev_scheduler dummy_scheduler = {
7484                 .description = "dummy scheduler to test mode",
7485                 .name = "dummy scheduler",
7486                 .mode = CDEV_SCHED_MODE_USERDEFINED,
7487                 .ops = &op
7488         };
7489         int ret;
7490
7491         /* set user defined mode */
7492         ret = rte_cryptodev_scheduler_load_user_scheduler(sched_id,
7493                         &dummy_scheduler);
7494         TEST_ASSERT(ret == 0,
7495                 "Failed to set cdev %u to user defined mode", sched_id);
7496
7497         /* set round robin mode */
7498         ret = rte_crpytodev_scheduler_mode_set(sched_id,
7499                         CDEV_SCHED_MODE_ROUNDROBIN);
7500         TEST_ASSERT(ret == 0,
7501                 "Failed to set cdev %u to round-robin mode", sched_id);
7502         TEST_ASSERT(rte_crpytodev_scheduler_mode_get(sched_id) ==
7503                         CDEV_SCHED_MODE_ROUNDROBIN, "Scheduling Mode "
7504                                         "not match");
7505
7506         return 0;
7507 }
7508
7509 static struct unit_test_suite cryptodev_scheduler_testsuite  = {
7510         .suite_name = "Crypto Device Scheduler Unit Test Suite",
7511         .setup = testsuite_setup,
7512         .teardown = testsuite_teardown,
7513         .unit_test_cases = {
7514                 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
7515                 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_op),
7516                 TEST_CASE_ST(ut_setup, ut_teardown,
7517                                 test_AES_chain_scheduler_all),
7518                 TEST_CASE_ST(ut_setup, ut_teardown,
7519                                 test_AES_cipheronly_scheduler_all),
7520                 TEST_CASE_ST(ut_setup, ut_teardown,
7521                                 test_authonly_scheduler_all),
7522                 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
7523                 TEST_CASES_END() /**< NULL terminate unit test array */
7524         }
7525 };
7526
7527 #endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
7528
7529 static struct unit_test_suite cryptodev_qat_testsuite  = {
7530         .suite_name = "Crypto QAT Unit Test Suite",
7531         .setup = testsuite_setup,
7532         .teardown = testsuite_teardown,
7533         .unit_test_cases = {
7534                 TEST_CASE_ST(ut_setup, ut_teardown,
7535                                 test_device_configure_invalid_dev_id),
7536                 TEST_CASE_ST(ut_setup, ut_teardown,
7537                                 test_device_configure_invalid_queue_pair_ids),
7538                 TEST_CASE_ST(ut_setup, ut_teardown,
7539                                 test_queue_pair_descriptor_setup),
7540                 TEST_CASE_ST(ut_setup, ut_teardown,
7541                                 test_multi_session),
7542
7543                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_qat_all),
7544                 TEST_CASE_ST(ut_setup, ut_teardown,
7545                                                 test_AES_cipheronly_qat_all),
7546                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_qat_all),
7547                 TEST_CASE_ST(ut_setup, ut_teardown,
7548                                                 test_3DES_cipheronly_qat_all),
7549                 TEST_CASE_ST(ut_setup, ut_teardown,
7550                                                 test_DES_cipheronly_qat_all),
7551                 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
7552
7553                 /** AES GCM Authenticated Encryption */
7554                 TEST_CASE_ST(ut_setup, ut_teardown,
7555                         test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
7556                 TEST_CASE_ST(ut_setup, ut_teardown,
7557                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
7558                 TEST_CASE_ST(ut_setup, ut_teardown,
7559                         test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
7560                 TEST_CASE_ST(ut_setup, ut_teardown,
7561                         test_mb_AES_GCM_authenticated_encryption_test_case_1),
7562                 TEST_CASE_ST(ut_setup, ut_teardown,
7563                         test_mb_AES_GCM_authenticated_encryption_test_case_2),
7564                 TEST_CASE_ST(ut_setup, ut_teardown,
7565                         test_mb_AES_GCM_authenticated_encryption_test_case_3),
7566                 TEST_CASE_ST(ut_setup, ut_teardown,
7567                         test_mb_AES_GCM_authenticated_encryption_test_case_4),
7568                 TEST_CASE_ST(ut_setup, ut_teardown,
7569                         test_mb_AES_GCM_authenticated_encryption_test_case_5),
7570                 TEST_CASE_ST(ut_setup, ut_teardown,
7571                         test_mb_AES_GCM_authenticated_encryption_test_case_6),
7572                 TEST_CASE_ST(ut_setup, ut_teardown,
7573                         test_mb_AES_GCM_authenticated_encryption_test_case_7),
7574
7575                 /** AES GCM Authenticated Decryption */
7576                 TEST_CASE_ST(ut_setup, ut_teardown,
7577                         test_mb_AES_GCM_authenticated_decryption_test_case_1),
7578                 TEST_CASE_ST(ut_setup, ut_teardown,
7579                         test_mb_AES_GCM_authenticated_decryption_test_case_2),
7580                 TEST_CASE_ST(ut_setup, ut_teardown,
7581                         test_mb_AES_GCM_authenticated_decryption_test_case_3),
7582                 TEST_CASE_ST(ut_setup, ut_teardown,
7583                         test_mb_AES_GCM_authenticated_decryption_test_case_4),
7584                 TEST_CASE_ST(ut_setup, ut_teardown,
7585                         test_mb_AES_GCM_authenticated_decryption_test_case_5),
7586                 TEST_CASE_ST(ut_setup, ut_teardown,
7587                         test_mb_AES_GCM_authenticated_decryption_test_case_6),
7588                 TEST_CASE_ST(ut_setup, ut_teardown,
7589                         test_mb_AES_GCM_authenticated_decryption_test_case_7),
7590
7591                 /** AES GMAC Authentication */
7592                 TEST_CASE_ST(ut_setup, ut_teardown,
7593                         test_AES_GMAC_authentication_test_case_1),
7594                 TEST_CASE_ST(ut_setup, ut_teardown,
7595                         test_AES_GMAC_authentication_verify_test_case_1),
7596                 TEST_CASE_ST(ut_setup, ut_teardown,
7597                         test_AES_GMAC_authentication_test_case_2),
7598                 TEST_CASE_ST(ut_setup, ut_teardown,
7599                         test_AES_GMAC_authentication_verify_test_case_2),
7600                 TEST_CASE_ST(ut_setup, ut_teardown,
7601                         test_AES_GMAC_authentication_test_case_3),
7602                 TEST_CASE_ST(ut_setup, ut_teardown,
7603                         test_AES_GMAC_authentication_verify_test_case_3),
7604
7605                 /** SNOW 3G encrypt only (UEA2) */
7606                 TEST_CASE_ST(ut_setup, ut_teardown,
7607                         test_snow3g_encryption_test_case_1),
7608                 TEST_CASE_ST(ut_setup, ut_teardown,
7609                         test_snow3g_encryption_test_case_2),
7610                 TEST_CASE_ST(ut_setup, ut_teardown,
7611                         test_snow3g_encryption_test_case_3),
7612                 TEST_CASE_ST(ut_setup, ut_teardown,
7613                         test_snow3g_encryption_test_case_4),
7614                 TEST_CASE_ST(ut_setup, ut_teardown,
7615                         test_snow3g_encryption_test_case_5),
7616
7617                 TEST_CASE_ST(ut_setup, ut_teardown,
7618                         test_snow3g_encryption_test_case_1_oop),
7619                 TEST_CASE_ST(ut_setup, ut_teardown,
7620                         test_snow3g_decryption_test_case_1_oop),
7621
7622                 /** SNOW 3G decrypt only (UEA2) */
7623                 TEST_CASE_ST(ut_setup, ut_teardown,
7624                         test_snow3g_decryption_test_case_1),
7625                 TEST_CASE_ST(ut_setup, ut_teardown,
7626                         test_snow3g_decryption_test_case_2),
7627                 TEST_CASE_ST(ut_setup, ut_teardown,
7628                         test_snow3g_decryption_test_case_3),
7629                 TEST_CASE_ST(ut_setup, ut_teardown,
7630                         test_snow3g_decryption_test_case_4),
7631                 TEST_CASE_ST(ut_setup, ut_teardown,
7632                         test_snow3g_decryption_test_case_5),
7633                 TEST_CASE_ST(ut_setup, ut_teardown,
7634                         test_snow3g_hash_generate_test_case_1),
7635                 TEST_CASE_ST(ut_setup, ut_teardown,
7636                         test_snow3g_hash_generate_test_case_2),
7637                 TEST_CASE_ST(ut_setup, ut_teardown,
7638                         test_snow3g_hash_generate_test_case_3),
7639                 TEST_CASE_ST(ut_setup, ut_teardown,
7640                         test_snow3g_hash_verify_test_case_1),
7641                 TEST_CASE_ST(ut_setup, ut_teardown,
7642                         test_snow3g_hash_verify_test_case_2),
7643                 TEST_CASE_ST(ut_setup, ut_teardown,
7644                         test_snow3g_hash_verify_test_case_3),
7645                 TEST_CASE_ST(ut_setup, ut_teardown,
7646                         test_snow3g_cipher_auth_test_case_1),
7647                 TEST_CASE_ST(ut_setup, ut_teardown,
7648                         test_snow3g_auth_cipher_test_case_1),
7649
7650                 /** HMAC_MD5 Authentication */
7651                 TEST_CASE_ST(ut_setup, ut_teardown,
7652                         test_MD5_HMAC_generate_case_1),
7653                 TEST_CASE_ST(ut_setup, ut_teardown,
7654                         test_MD5_HMAC_verify_case_1),
7655                 TEST_CASE_ST(ut_setup, ut_teardown,
7656                         test_MD5_HMAC_generate_case_2),
7657                 TEST_CASE_ST(ut_setup, ut_teardown,
7658                         test_MD5_HMAC_verify_case_2),
7659
7660                 /** NULL tests */
7661                 TEST_CASE_ST(ut_setup, ut_teardown,
7662                         test_null_auth_only_operation),
7663                 TEST_CASE_ST(ut_setup, ut_teardown,
7664                         test_null_cipher_only_operation),
7665                 TEST_CASE_ST(ut_setup, ut_teardown,
7666                         test_null_cipher_auth_operation),
7667                 TEST_CASE_ST(ut_setup, ut_teardown,
7668                         test_null_auth_cipher_operation),
7669
7670                 TEST_CASE_ST(ut_setup, ut_teardown,
7671                         test_kasumi_hash_generate_test_case_6),
7672
7673                 /** KASUMI tests */
7674                 TEST_CASE_ST(ut_setup, ut_teardown,
7675                         test_kasumi_encryption_test_case_1),
7676                 TEST_CASE_ST(ut_setup, ut_teardown,
7677                         test_kasumi_encryption_test_case_3),
7678                 TEST_CASE_ST(ut_setup, ut_teardown,
7679                         test_kasumi_auth_cipher_test_case_1),
7680                 TEST_CASE_ST(ut_setup, ut_teardown,
7681                         test_kasumi_cipher_auth_test_case_1),
7682
7683                 /** Negative tests */
7684                 TEST_CASE_ST(ut_setup, ut_teardown,
7685                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
7686                 TEST_CASE_ST(ut_setup, ut_teardown,
7687                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
7688                 TEST_CASE_ST(ut_setup, ut_teardown,
7689                         authentication_verify_AES128_GMAC_fail_data_corrupt),
7690                 TEST_CASE_ST(ut_setup, ut_teardown,
7691                         authentication_verify_AES128_GMAC_fail_tag_corrupt),
7692                 TEST_CASE_ST(ut_setup, ut_teardown,
7693                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
7694                 TEST_CASE_ST(ut_setup, ut_teardown,
7695                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
7696
7697                 TEST_CASES_END() /**< NULL terminate unit test array */
7698         }
7699 };
7700
7701 static struct unit_test_suite cryptodev_aesni_mb_testsuite  = {
7702         .suite_name = "Crypto Device AESNI MB Unit Test Suite",
7703         .setup = testsuite_setup,
7704         .teardown = testsuite_teardown,
7705         .unit_test_cases = {
7706                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_mb_all),
7707                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_mb_all),
7708                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_docsis_mb_all),
7709                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_mb_all),
7710
7711                 TEST_CASES_END() /**< NULL terminate unit test array */
7712         }
7713 };
7714
7715 static struct unit_test_suite cryptodev_openssl_testsuite  = {
7716         .suite_name = "Crypto Device OPENSSL Unit Test Suite",
7717         .setup = testsuite_setup,
7718         .teardown = testsuite_teardown,
7719         .unit_test_cases = {
7720                 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
7721                 TEST_CASE_ST(ut_setup, ut_teardown,
7722                                 test_multi_session_random_usage),
7723                 TEST_CASE_ST(ut_setup, ut_teardown,
7724                                 test_AES_chain_openssl_all),
7725                 TEST_CASE_ST(ut_setup, ut_teardown,
7726                                 test_AES_cipheronly_openssl_all),
7727                 TEST_CASE_ST(ut_setup, ut_teardown,
7728                                 test_3DES_chain_openssl_all),
7729                 TEST_CASE_ST(ut_setup, ut_teardown,
7730                                 test_3DES_cipheronly_openssl_all),
7731                 TEST_CASE_ST(ut_setup, ut_teardown,
7732                                 test_DES_docsis_openssl_all),
7733                 TEST_CASE_ST(ut_setup, ut_teardown,
7734                                 test_authonly_openssl_all),
7735
7736                 /** AES GCM Authenticated Encryption */
7737                 TEST_CASE_ST(ut_setup, ut_teardown,
7738                         test_mb_AES_GCM_authenticated_encryption_test_case_1),
7739                 TEST_CASE_ST(ut_setup, ut_teardown,
7740                         test_mb_AES_GCM_authenticated_encryption_test_case_2),
7741                 TEST_CASE_ST(ut_setup, ut_teardown,
7742                         test_mb_AES_GCM_authenticated_encryption_test_case_3),
7743                 TEST_CASE_ST(ut_setup, ut_teardown,
7744                         test_mb_AES_GCM_authenticated_encryption_test_case_4),
7745                 TEST_CASE_ST(ut_setup, ut_teardown,
7746                         test_mb_AES_GCM_authenticated_encryption_test_case_5),
7747                 TEST_CASE_ST(ut_setup, ut_teardown,
7748                         test_mb_AES_GCM_authenticated_encryption_test_case_6),
7749                 TEST_CASE_ST(ut_setup, ut_teardown,
7750                         test_mb_AES_GCM_authenticated_encryption_test_case_7),
7751
7752                 /** AES GCM Authenticated Decryption */
7753                 TEST_CASE_ST(ut_setup, ut_teardown,
7754                         test_mb_AES_GCM_authenticated_decryption_test_case_1),
7755                 TEST_CASE_ST(ut_setup, ut_teardown,
7756                         test_mb_AES_GCM_authenticated_decryption_test_case_2),
7757                 TEST_CASE_ST(ut_setup, ut_teardown,
7758                         test_mb_AES_GCM_authenticated_decryption_test_case_3),
7759                 TEST_CASE_ST(ut_setup, ut_teardown,
7760                         test_mb_AES_GCM_authenticated_decryption_test_case_4),
7761                 TEST_CASE_ST(ut_setup, ut_teardown,
7762                         test_mb_AES_GCM_authenticated_decryption_test_case_5),
7763                 TEST_CASE_ST(ut_setup, ut_teardown,
7764                         test_mb_AES_GCM_authenticated_decryption_test_case_6),
7765                 TEST_CASE_ST(ut_setup, ut_teardown,
7766                         test_mb_AES_GCM_authenticated_decryption_test_case_7),
7767
7768                 /** AES GMAC Authentication */
7769                 TEST_CASE_ST(ut_setup, ut_teardown,
7770                         test_AES_GMAC_authentication_test_case_1),
7771                 TEST_CASE_ST(ut_setup, ut_teardown,
7772                         test_AES_GMAC_authentication_verify_test_case_1),
7773                 TEST_CASE_ST(ut_setup, ut_teardown,
7774                         test_AES_GMAC_authentication_test_case_2),
7775                 TEST_CASE_ST(ut_setup, ut_teardown,
7776                         test_AES_GMAC_authentication_verify_test_case_2),
7777                 TEST_CASE_ST(ut_setup, ut_teardown,
7778                         test_AES_GMAC_authentication_test_case_3),
7779                 TEST_CASE_ST(ut_setup, ut_teardown,
7780                         test_AES_GMAC_authentication_verify_test_case_3),
7781                 TEST_CASE_ST(ut_setup, ut_teardown,
7782                         test_AES_GMAC_authentication_test_case_4),
7783                 TEST_CASE_ST(ut_setup, ut_teardown,
7784                         test_AES_GMAC_authentication_verify_test_case_4),
7785
7786                 /** Scatter-Gather */
7787                 TEST_CASE_ST(ut_setup, ut_teardown,
7788                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
7789
7790                 /** Negative tests */
7791                 TEST_CASE_ST(ut_setup, ut_teardown,
7792                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
7793                 TEST_CASE_ST(ut_setup, ut_teardown,
7794                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
7795                 TEST_CASE_ST(ut_setup, ut_teardown,
7796                         authentication_verify_AES128_GMAC_fail_data_corrupt),
7797                 TEST_CASE_ST(ut_setup, ut_teardown,
7798                         authentication_verify_AES128_GMAC_fail_tag_corrupt),
7799                 TEST_CASE_ST(ut_setup, ut_teardown,
7800                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
7801                 TEST_CASE_ST(ut_setup, ut_teardown,
7802                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
7803
7804                 TEST_CASES_END() /**< NULL terminate unit test array */
7805         }
7806 };
7807
7808 static struct unit_test_suite cryptodev_aesni_gcm_testsuite  = {
7809         .suite_name = "Crypto Device AESNI GCM Unit Test Suite",
7810         .setup = testsuite_setup,
7811         .teardown = testsuite_teardown,
7812         .unit_test_cases = {
7813                 /** AES GCM Authenticated Encryption */
7814                 TEST_CASE_ST(ut_setup, ut_teardown,
7815                         test_mb_AES_GCM_authenticated_encryption_test_case_1),
7816                 TEST_CASE_ST(ut_setup, ut_teardown,
7817                         test_mb_AES_GCM_authenticated_encryption_test_case_2),
7818                 TEST_CASE_ST(ut_setup, ut_teardown,
7819                         test_mb_AES_GCM_authenticated_encryption_test_case_3),
7820                 TEST_CASE_ST(ut_setup, ut_teardown,
7821                         test_mb_AES_GCM_authenticated_encryption_test_case_4),
7822                 TEST_CASE_ST(ut_setup, ut_teardown,
7823                         test_mb_AES_GCM_authenticated_encryption_test_case_5),
7824                 TEST_CASE_ST(ut_setup, ut_teardown,
7825                         test_mb_AES_GCM_authenticated_encryption_test_case_6),
7826                 TEST_CASE_ST(ut_setup, ut_teardown,
7827                         test_mb_AES_GCM_authenticated_encryption_test_case_7),
7828
7829                 /** AES GCM Authenticated Decryption */
7830                 TEST_CASE_ST(ut_setup, ut_teardown,
7831                         test_mb_AES_GCM_authenticated_decryption_test_case_1),
7832                 TEST_CASE_ST(ut_setup, ut_teardown,
7833                         test_mb_AES_GCM_authenticated_decryption_test_case_2),
7834                 TEST_CASE_ST(ut_setup, ut_teardown,
7835                         test_mb_AES_GCM_authenticated_decryption_test_case_3),
7836                 TEST_CASE_ST(ut_setup, ut_teardown,
7837                         test_mb_AES_GCM_authenticated_decryption_test_case_4),
7838                 TEST_CASE_ST(ut_setup, ut_teardown,
7839                         test_mb_AES_GCM_authenticated_decryption_test_case_5),
7840                 TEST_CASE_ST(ut_setup, ut_teardown,
7841                         test_mb_AES_GCM_authenticated_decryption_test_case_6),
7842                 TEST_CASE_ST(ut_setup, ut_teardown,
7843                         test_mb_AES_GCM_authenticated_decryption_test_case_7),
7844
7845                 /** AES GCM Authenticated Encryption 256 bits key */
7846                 TEST_CASE_ST(ut_setup, ut_teardown,
7847                         test_mb_AES_GCM_auth_encryption_test_case_256_1),
7848                 TEST_CASE_ST(ut_setup, ut_teardown,
7849                         test_mb_AES_GCM_auth_encryption_test_case_256_2),
7850                 TEST_CASE_ST(ut_setup, ut_teardown,
7851                         test_mb_AES_GCM_auth_encryption_test_case_256_3),
7852                 TEST_CASE_ST(ut_setup, ut_teardown,
7853                         test_mb_AES_GCM_auth_encryption_test_case_256_4),
7854                 TEST_CASE_ST(ut_setup, ut_teardown,
7855                         test_mb_AES_GCM_auth_encryption_test_case_256_5),
7856                 TEST_CASE_ST(ut_setup, ut_teardown,
7857                         test_mb_AES_GCM_auth_encryption_test_case_256_6),
7858                 TEST_CASE_ST(ut_setup, ut_teardown,
7859                         test_mb_AES_GCM_auth_encryption_test_case_256_7),
7860
7861                 /** AES GCM Authenticated Decryption 256 bits key */
7862                 TEST_CASE_ST(ut_setup, ut_teardown,
7863                         test_mb_AES_GCM_auth_decryption_test_case_256_1),
7864                 TEST_CASE_ST(ut_setup, ut_teardown,
7865                         test_mb_AES_GCM_auth_decryption_test_case_256_2),
7866                 TEST_CASE_ST(ut_setup, ut_teardown,
7867                         test_mb_AES_GCM_auth_decryption_test_case_256_3),
7868                 TEST_CASE_ST(ut_setup, ut_teardown,
7869                         test_mb_AES_GCM_auth_decryption_test_case_256_4),
7870                 TEST_CASE_ST(ut_setup, ut_teardown,
7871                         test_mb_AES_GCM_auth_decryption_test_case_256_5),
7872                 TEST_CASE_ST(ut_setup, ut_teardown,
7873                         test_mb_AES_GCM_auth_decryption_test_case_256_6),
7874                 TEST_CASE_ST(ut_setup, ut_teardown,
7875                         test_mb_AES_GCM_auth_decryption_test_case_256_7),
7876
7877                 /** AES GCM Authenticated Encryption big aad size */
7878                 TEST_CASE_ST(ut_setup, ut_teardown,
7879                         test_mb_AES_GCM_auth_encryption_test_case_aad_1),
7880                 TEST_CASE_ST(ut_setup, ut_teardown,
7881                         test_mb_AES_GCM_auth_encryption_test_case_aad_2),
7882
7883                 /** AES GCM Authenticated Decryption big aad size */
7884                 TEST_CASE_ST(ut_setup, ut_teardown,
7885                         test_mb_AES_GCM_auth_decryption_test_case_aad_1),
7886                 TEST_CASE_ST(ut_setup, ut_teardown,
7887                         test_mb_AES_GCM_auth_decryption_test_case_aad_2),
7888
7889                 /** AES GMAC Authentication */
7890                 TEST_CASE_ST(ut_setup, ut_teardown,
7891                         test_AES_GMAC_authentication_test_case_1),
7892                 TEST_CASE_ST(ut_setup, ut_teardown,
7893                         test_AES_GMAC_authentication_verify_test_case_1),
7894                 TEST_CASE_ST(ut_setup, ut_teardown,
7895                         test_AES_GMAC_authentication_test_case_3),
7896                 TEST_CASE_ST(ut_setup, ut_teardown,
7897                         test_AES_GMAC_authentication_verify_test_case_3),
7898                 TEST_CASE_ST(ut_setup, ut_teardown,
7899                         test_AES_GMAC_authentication_test_case_4),
7900                 TEST_CASE_ST(ut_setup, ut_teardown,
7901                         test_AES_GMAC_authentication_verify_test_case_4),
7902
7903                 /** Negative tests */
7904                 TEST_CASE_ST(ut_setup, ut_teardown,
7905                         authentication_verify_AES128_GMAC_fail_data_corrupt),
7906                 TEST_CASE_ST(ut_setup, ut_teardown,
7907                         authentication_verify_AES128_GMAC_fail_tag_corrupt),
7908
7909                 /** Out of place tests */
7910                 TEST_CASE_ST(ut_setup, ut_teardown,
7911                         test_mb_AES_GCM_authenticated_encryption_oop),
7912                 TEST_CASE_ST(ut_setup, ut_teardown,
7913                         test_mb_AES_GCM_authenticated_decryption_oop),
7914
7915                 /** Session-less tests */
7916                 TEST_CASE_ST(ut_setup, ut_teardown,
7917                         test_mb_AES_GCM_authenticated_encryption_sessionless),
7918                 TEST_CASE_ST(ut_setup, ut_teardown,
7919                         test_mb_AES_GCM_authenticated_decryption_sessionless),
7920
7921                 /** Scatter-Gather */
7922                 TEST_CASE_ST(ut_setup, ut_teardown,
7923                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
7924
7925                 TEST_CASES_END() /**< NULL terminate unit test array */
7926         }
7927 };
7928
7929 static struct unit_test_suite cryptodev_sw_kasumi_testsuite  = {
7930         .suite_name = "Crypto Device SW KASUMI Unit Test Suite",
7931         .setup = testsuite_setup,
7932         .teardown = testsuite_teardown,
7933         .unit_test_cases = {
7934                 /** KASUMI encrypt only (UEA1) */
7935                 TEST_CASE_ST(ut_setup, ut_teardown,
7936                         test_kasumi_encryption_test_case_1),
7937                 TEST_CASE_ST(ut_setup, ut_teardown,
7938                         test_kasumi_encryption_test_case_1_sgl),
7939                 TEST_CASE_ST(ut_setup, ut_teardown,
7940                         test_kasumi_encryption_test_case_2),
7941                 TEST_CASE_ST(ut_setup, ut_teardown,
7942                         test_kasumi_encryption_test_case_3),
7943                 TEST_CASE_ST(ut_setup, ut_teardown,
7944                         test_kasumi_encryption_test_case_4),
7945                 TEST_CASE_ST(ut_setup, ut_teardown,
7946                         test_kasumi_encryption_test_case_5),
7947                 /** KASUMI decrypt only (UEA1) */
7948                 TEST_CASE_ST(ut_setup, ut_teardown,
7949                         test_kasumi_decryption_test_case_1),
7950                 TEST_CASE_ST(ut_setup, ut_teardown,
7951                         test_kasumi_decryption_test_case_2),
7952                 TEST_CASE_ST(ut_setup, ut_teardown,
7953                         test_kasumi_decryption_test_case_3),
7954                 TEST_CASE_ST(ut_setup, ut_teardown,
7955                         test_kasumi_decryption_test_case_4),
7956                 TEST_CASE_ST(ut_setup, ut_teardown,
7957                         test_kasumi_decryption_test_case_5),
7958
7959                 TEST_CASE_ST(ut_setup, ut_teardown,
7960                         test_kasumi_encryption_test_case_1_oop),
7961                 TEST_CASE_ST(ut_setup, ut_teardown,
7962                         test_kasumi_encryption_test_case_1_oop_sgl),
7963
7964
7965                 TEST_CASE_ST(ut_setup, ut_teardown,
7966                         test_kasumi_decryption_test_case_1_oop),
7967
7968                 /** KASUMI hash only (UIA1) */
7969                 TEST_CASE_ST(ut_setup, ut_teardown,
7970                         test_kasumi_hash_generate_test_case_1),
7971                 TEST_CASE_ST(ut_setup, ut_teardown,
7972                         test_kasumi_hash_generate_test_case_2),
7973                 TEST_CASE_ST(ut_setup, ut_teardown,
7974                         test_kasumi_hash_generate_test_case_3),
7975                 TEST_CASE_ST(ut_setup, ut_teardown,
7976                         test_kasumi_hash_generate_test_case_4),
7977                 TEST_CASE_ST(ut_setup, ut_teardown,
7978                         test_kasumi_hash_generate_test_case_5),
7979                 TEST_CASE_ST(ut_setup, ut_teardown,
7980                         test_kasumi_hash_generate_test_case_6),
7981                 TEST_CASE_ST(ut_setup, ut_teardown,
7982                         test_kasumi_hash_verify_test_case_1),
7983                 TEST_CASE_ST(ut_setup, ut_teardown,
7984                         test_kasumi_hash_verify_test_case_2),
7985                 TEST_CASE_ST(ut_setup, ut_teardown,
7986                         test_kasumi_hash_verify_test_case_3),
7987                 TEST_CASE_ST(ut_setup, ut_teardown,
7988                         test_kasumi_hash_verify_test_case_4),
7989                 TEST_CASE_ST(ut_setup, ut_teardown,
7990                         test_kasumi_hash_verify_test_case_5),
7991                 TEST_CASE_ST(ut_setup, ut_teardown,
7992                         test_kasumi_auth_cipher_test_case_1),
7993                 TEST_CASE_ST(ut_setup, ut_teardown,
7994                         test_kasumi_cipher_auth_test_case_1),
7995                 TEST_CASES_END() /**< NULL terminate unit test array */
7996         }
7997 };
7998 static struct unit_test_suite cryptodev_sw_snow3g_testsuite  = {
7999         .suite_name = "Crypto Device SW SNOW 3G Unit Test Suite",
8000         .setup = testsuite_setup,
8001         .teardown = testsuite_teardown,
8002         .unit_test_cases = {
8003                 /** SNOW 3G encrypt only (UEA2) */
8004                 TEST_CASE_ST(ut_setup, ut_teardown,
8005                         test_snow3g_encryption_test_case_1),
8006                 TEST_CASE_ST(ut_setup, ut_teardown,
8007                         test_snow3g_encryption_test_case_2),
8008                 TEST_CASE_ST(ut_setup, ut_teardown,
8009                         test_snow3g_encryption_test_case_3),
8010                 TEST_CASE_ST(ut_setup, ut_teardown,
8011                         test_snow3g_encryption_test_case_4),
8012                 TEST_CASE_ST(ut_setup, ut_teardown,
8013                         test_snow3g_encryption_test_case_5),
8014
8015                 TEST_CASE_ST(ut_setup, ut_teardown,
8016                         test_snow3g_encryption_test_case_1_oop),
8017                 TEST_CASE_ST(ut_setup, ut_teardown,
8018                                 test_snow3g_encryption_test_case_1_oop_sgl),
8019                 TEST_CASE_ST(ut_setup, ut_teardown,
8020                         test_snow3g_decryption_test_case_1_oop),
8021
8022                 TEST_CASE_ST(ut_setup, ut_teardown,
8023                         test_snow3g_encryption_test_case_1_offset_oop),
8024
8025                 /** SNOW 3G decrypt only (UEA2) */
8026                 TEST_CASE_ST(ut_setup, ut_teardown,
8027                         test_snow3g_decryption_test_case_1),
8028                 TEST_CASE_ST(ut_setup, ut_teardown,
8029                         test_snow3g_decryption_test_case_2),
8030                 TEST_CASE_ST(ut_setup, ut_teardown,
8031                         test_snow3g_decryption_test_case_3),
8032                 TEST_CASE_ST(ut_setup, ut_teardown,
8033                         test_snow3g_decryption_test_case_4),
8034                 TEST_CASE_ST(ut_setup, ut_teardown,
8035                         test_snow3g_decryption_test_case_5),
8036                 TEST_CASE_ST(ut_setup, ut_teardown,
8037                         test_snow3g_hash_generate_test_case_1),
8038                 TEST_CASE_ST(ut_setup, ut_teardown,
8039                         test_snow3g_hash_generate_test_case_2),
8040                 TEST_CASE_ST(ut_setup, ut_teardown,
8041                         test_snow3g_hash_generate_test_case_3),
8042                 /* Tests with buffers which length is not byte-aligned */
8043                 TEST_CASE_ST(ut_setup, ut_teardown,
8044                         test_snow3g_hash_generate_test_case_4),
8045                 TEST_CASE_ST(ut_setup, ut_teardown,
8046                         test_snow3g_hash_generate_test_case_5),
8047                 TEST_CASE_ST(ut_setup, ut_teardown,
8048                         test_snow3g_hash_generate_test_case_6),
8049                 TEST_CASE_ST(ut_setup, ut_teardown,
8050                         test_snow3g_hash_verify_test_case_1),
8051                 TEST_CASE_ST(ut_setup, ut_teardown,
8052                         test_snow3g_hash_verify_test_case_2),
8053                 TEST_CASE_ST(ut_setup, ut_teardown,
8054                         test_snow3g_hash_verify_test_case_3),
8055                 /* Tests with buffers which length is not byte-aligned */
8056                 TEST_CASE_ST(ut_setup, ut_teardown,
8057                         test_snow3g_hash_verify_test_case_4),
8058                 TEST_CASE_ST(ut_setup, ut_teardown,
8059                         test_snow3g_hash_verify_test_case_5),
8060                 TEST_CASE_ST(ut_setup, ut_teardown,
8061                         test_snow3g_hash_verify_test_case_6),
8062                 TEST_CASE_ST(ut_setup, ut_teardown,
8063                         test_snow3g_cipher_auth_test_case_1),
8064                 TEST_CASE_ST(ut_setup, ut_teardown,
8065                         test_snow3g_auth_cipher_test_case_1),
8066
8067                 TEST_CASES_END() /**< NULL terminate unit test array */
8068         }
8069 };
8070
8071 static struct unit_test_suite cryptodev_sw_zuc_testsuite  = {
8072         .suite_name = "Crypto Device SW ZUC Unit Test Suite",
8073         .setup = testsuite_setup,
8074         .teardown = testsuite_teardown,
8075         .unit_test_cases = {
8076                 /** ZUC encrypt only (EEA3) */
8077                 TEST_CASE_ST(ut_setup, ut_teardown,
8078                         test_zuc_encryption_test_case_1),
8079                 TEST_CASE_ST(ut_setup, ut_teardown,
8080                         test_zuc_encryption_test_case_2),
8081                 TEST_CASE_ST(ut_setup, ut_teardown,
8082                         test_zuc_encryption_test_case_3),
8083                 TEST_CASE_ST(ut_setup, ut_teardown,
8084                         test_zuc_encryption_test_case_4),
8085                 TEST_CASE_ST(ut_setup, ut_teardown,
8086                         test_zuc_encryption_test_case_5),
8087                 TEST_CASE_ST(ut_setup, ut_teardown,
8088                         test_zuc_hash_generate_test_case_1),
8089                 TEST_CASE_ST(ut_setup, ut_teardown,
8090                         test_zuc_hash_generate_test_case_2),
8091                 TEST_CASE_ST(ut_setup, ut_teardown,
8092                         test_zuc_hash_generate_test_case_3),
8093                 TEST_CASE_ST(ut_setup, ut_teardown,
8094                         test_zuc_hash_generate_test_case_4),
8095                 TEST_CASE_ST(ut_setup, ut_teardown,
8096                         test_zuc_hash_generate_test_case_5),
8097                 TEST_CASE_ST(ut_setup, ut_teardown,
8098                         test_zuc_encryption_test_case_6_sgl),
8099                 TEST_CASES_END() /**< NULL terminate unit test array */
8100         }
8101 };
8102
8103 static struct unit_test_suite cryptodev_null_testsuite  = {
8104         .suite_name = "Crypto Device NULL Unit Test Suite",
8105         .setup = testsuite_setup,
8106         .teardown = testsuite_teardown,
8107         .unit_test_cases = {
8108                 TEST_CASE_ST(ut_setup, ut_teardown,
8109                         test_null_auth_only_operation),
8110                 TEST_CASE_ST(ut_setup, ut_teardown,
8111                         test_null_cipher_only_operation),
8112                 TEST_CASE_ST(ut_setup, ut_teardown,
8113                         test_null_cipher_auth_operation),
8114                 TEST_CASE_ST(ut_setup, ut_teardown,
8115                         test_null_auth_cipher_operation),
8116                 TEST_CASE_ST(ut_setup, ut_teardown,
8117                         test_null_invalid_operation),
8118                 TEST_CASE_ST(ut_setup, ut_teardown,
8119                         test_null_burst_operation),
8120
8121                 TEST_CASES_END() /**< NULL terminate unit test array */
8122         }
8123 };
8124
8125 static struct unit_test_suite cryptodev_armv8_testsuite  = {
8126         .suite_name = "Crypto Device ARMv8 Unit Test Suite",
8127         .setup = testsuite_setup,
8128         .teardown = testsuite_teardown,
8129         .unit_test_cases = {
8130                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_armv8_all),
8131
8132                 /** Negative tests */
8133                 TEST_CASE_ST(ut_setup, ut_teardown,
8134                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
8135                 TEST_CASE_ST(ut_setup, ut_teardown,
8136                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
8137
8138                 TEST_CASES_END() /**< NULL terminate unit test array */
8139         }
8140 };
8141
8142 static int
8143 test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/)
8144 {
8145         gbl_cryptodev_type = RTE_CRYPTODEV_QAT_SYM_PMD;
8146         return unit_test_suite_runner(&cryptodev_qat_testsuite);
8147 }
8148
8149 static int
8150 test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/)
8151 {
8152         gbl_cryptodev_type = RTE_CRYPTODEV_AESNI_MB_PMD;
8153
8154         return unit_test_suite_runner(&cryptodev_aesni_mb_testsuite);
8155 }
8156
8157 static int
8158 test_cryptodev_openssl(void)
8159 {
8160         gbl_cryptodev_type = RTE_CRYPTODEV_OPENSSL_PMD;
8161
8162         return unit_test_suite_runner(&cryptodev_openssl_testsuite);
8163 }
8164
8165 static int
8166 test_cryptodev_aesni_gcm(void)
8167 {
8168         gbl_cryptodev_type = RTE_CRYPTODEV_AESNI_GCM_PMD;
8169
8170         return unit_test_suite_runner(&cryptodev_aesni_gcm_testsuite);
8171 }
8172
8173 static int
8174 test_cryptodev_null(void)
8175 {
8176         gbl_cryptodev_type = RTE_CRYPTODEV_NULL_PMD;
8177
8178         return unit_test_suite_runner(&cryptodev_null_testsuite);
8179 }
8180
8181 static int
8182 test_cryptodev_sw_snow3g(void /*argv __rte_unused, int argc __rte_unused*/)
8183 {
8184         gbl_cryptodev_type = RTE_CRYPTODEV_SNOW3G_PMD;
8185
8186         return unit_test_suite_runner(&cryptodev_sw_snow3g_testsuite);
8187 }
8188
8189 static int
8190 test_cryptodev_sw_kasumi(void /*argv __rte_unused, int argc __rte_unused*/)
8191 {
8192         gbl_cryptodev_type = RTE_CRYPTODEV_KASUMI_PMD;
8193
8194         return unit_test_suite_runner(&cryptodev_sw_kasumi_testsuite);
8195 }
8196
8197 static int
8198 test_cryptodev_sw_zuc(void /*argv __rte_unused, int argc __rte_unused*/)
8199 {
8200         gbl_cryptodev_type = RTE_CRYPTODEV_ZUC_PMD;
8201
8202         return unit_test_suite_runner(&cryptodev_sw_zuc_testsuite);
8203 }
8204
8205 static int
8206 test_cryptodev_armv8(void)
8207 {
8208         gbl_cryptodev_type = RTE_CRYPTODEV_ARMV8_PMD;
8209
8210         return unit_test_suite_runner(&cryptodev_armv8_testsuite);
8211 }
8212
8213 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
8214
8215 static int
8216 test_cryptodev_scheduler(void /*argv __rte_unused, int argc __rte_unused*/)
8217 {
8218         gbl_cryptodev_type = RTE_CRYPTODEV_SCHEDULER_PMD;
8219         return unit_test_suite_runner(&cryptodev_scheduler_testsuite);
8220 }
8221
8222 REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler);
8223
8224 #endif
8225
8226 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
8227 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
8228 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl);
8229 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm);
8230 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null);
8231 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
8232 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);
8233 REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc);
8234 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_autotest, test_cryptodev_armv8);