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