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