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