1 /*- 2 * BSD LICENSE 3 * 4 * Copyright(c) 2015 Intel Corporation. All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 10 * * Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * * Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in 14 * the documentation and/or other materials provided with the 15 * distribution. 16 * * Neither the name of Intel Corporation nor the names of its 17 * contributors may be used to endorse or promote products derived 18 * from this software without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 23 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 24 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 25 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 26 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 30 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 #include <rte_common.h> 34 #include <rte_hexdump.h> 35 #include <rte_mbuf.h> 36 #include <rte_malloc.h> 37 #include <rte_memcpy.h> 38 #include <rte_mbuf_offload.h> 39 40 #include <rte_crypto.h> 41 #include <rte_cryptodev.h> 42 #include <rte_cryptodev_pmd.h> 43 44 #include "test.h" 45 #include "test_cryptodev.h" 46 47 static enum rte_cryptodev_type gbl_cryptodev_type; 48 49 struct crypto_testsuite_params { 50 struct rte_mempool *mbuf_pool; 51 struct rte_mempool *mbuf_ol_pool; 52 struct rte_cryptodev_config conf; 53 struct rte_cryptodev_qp_conf qp_conf; 54 55 uint8_t valid_devs[RTE_CRYPTO_MAX_DEVS]; 56 uint8_t valid_dev_count; 57 }; 58 59 struct crypto_unittest_params { 60 struct rte_crypto_xform cipher_xform; 61 struct rte_crypto_xform auth_xform; 62 63 struct rte_cryptodev_session *sess; 64 65 struct rte_mbuf_offload *ol; 66 struct rte_crypto_op *op; 67 68 struct rte_mbuf *obuf, *ibuf; 69 70 uint8_t *digest; 71 }; 72 73 /* 74 * Forward declarations. 75 */ 76 static int 77 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params( 78 struct crypto_unittest_params *ut_params); 79 80 static int 81 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_session *sess, 82 struct crypto_unittest_params *ut_params, 83 struct crypto_testsuite_params *ts_param); 84 85 static struct rte_mbuf * 86 setup_test_string(struct rte_mempool *mpool, 87 const char *string, size_t len, uint8_t blocksize) 88 { 89 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool); 90 size_t t_len = len - (blocksize ? (len % blocksize) : 0); 91 92 memset(m->buf_addr, 0, m->buf_len); 93 if (m) { 94 char *dst = rte_pktmbuf_append(m, t_len); 95 96 if (!dst) { 97 rte_pktmbuf_free(m); 98 return NULL; 99 } 100 101 rte_memcpy(dst, string, t_len); 102 } 103 104 return m; 105 } 106 107 #if HEX_DUMP 108 static void 109 hexdump_mbuf_data(FILE *f, const char *title, struct rte_mbuf *m) 110 { 111 rte_hexdump(f, title, rte_pktmbuf_mtod(m, const void *), m->data_len); 112 } 113 #endif 114 115 static struct rte_mbuf * 116 process_crypto_request(uint8_t dev_id, struct rte_mbuf *ibuf) 117 { 118 struct rte_mbuf *obuf = NULL; 119 #if HEX_DUMP 120 hexdump_mbuf_data(stdout, "Enqueued Packet", ibuf); 121 #endif 122 123 if (rte_cryptodev_enqueue_burst(dev_id, 0, &ibuf, 1) != 1) { 124 printf("Error sending packet for encryption"); 125 return NULL; 126 } 127 while (rte_cryptodev_dequeue_burst(dev_id, 0, &obuf, 1) == 0) 128 rte_pause(); 129 130 #if HEX_DUMP 131 if (obuf) 132 hexdump_mbuf_data(stdout, "Dequeued Packet", obuf); 133 #endif 134 135 return obuf; 136 } 137 138 static struct crypto_testsuite_params testsuite_params = { NULL }; 139 static struct crypto_unittest_params unittest_params; 140 141 static int 142 testsuite_setup(void) 143 { 144 struct crypto_testsuite_params *ts_params = &testsuite_params; 145 struct rte_cryptodev_info info; 146 unsigned i, nb_devs, dev_id = 0; 147 uint16_t qp_id; 148 149 memset(ts_params, 0, sizeof(*ts_params)); 150 151 ts_params->mbuf_pool = rte_mempool_lookup("CRYPTO_MBUFPOOL"); 152 if (ts_params->mbuf_pool == NULL) { 153 /* Not already created so create */ 154 ts_params->mbuf_pool = rte_pktmbuf_pool_create( 155 "CRYPTO_MBUFPOOL", 156 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE, 157 rte_socket_id()); 158 if (ts_params->mbuf_pool == NULL) { 159 RTE_LOG(ERR, USER1, "Can't create CRYPTO_MBUFPOOL\n"); 160 return TEST_FAILED; 161 } 162 } 163 164 ts_params->mbuf_ol_pool = rte_pktmbuf_offload_pool_create( 165 "MBUF_OFFLOAD_POOL", 166 NUM_MBUFS, MBUF_CACHE_SIZE, 167 DEFAULT_NUM_XFORMS * sizeof(struct rte_crypto_xform), 168 rte_socket_id()); 169 if (ts_params->mbuf_ol_pool == NULL) { 170 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n"); 171 return TEST_FAILED; 172 } 173 174 /* Create 2 AESNI MB devices if required */ 175 if (gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD) { 176 nb_devs = rte_cryptodev_count_devtype( 177 RTE_CRYPTODEV_AESNI_MB_PMD); 178 if (nb_devs < 2) { 179 for (i = nb_devs; i < 2; i++) { 180 int dev_id = rte_eal_vdev_init( 181 CRYPTODEV_NAME_AESNI_MB_PMD, NULL); 182 183 TEST_ASSERT(dev_id >= 0, 184 "Failed to create instance %u of" 185 " pmd : %s", 186 i, CRYPTODEV_NAME_AESNI_MB_PMD); 187 } 188 } 189 } 190 191 nb_devs = rte_cryptodev_count(); 192 if (nb_devs < 1) { 193 RTE_LOG(ERR, USER1, "No crypto devices found?"); 194 return TEST_FAILED; 195 } 196 197 /* Create list of valid crypto devs */ 198 for (i = 0; i < nb_devs; i++) { 199 rte_cryptodev_info_get(i, &info); 200 if (info.dev_type == gbl_cryptodev_type) 201 ts_params->valid_devs[ts_params->valid_dev_count++] = i; 202 } 203 204 if (ts_params->valid_dev_count < 1) 205 return TEST_FAILED; 206 207 /* Set up all the qps on the first of the valid devices found */ 208 for (i = 0; i < 1; i++) { 209 dev_id = ts_params->valid_devs[i]; 210 211 rte_cryptodev_info_get(dev_id, &info); 212 213 /* 214 * Since we can't free and re-allocate queue memory always set 215 * the queues on this device up to max size first so enough 216 * memory is allocated for any later re-configures needed by 217 * other tests 218 */ 219 220 ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs; 221 ts_params->conf.socket_id = SOCKET_ID_ANY; 222 ts_params->conf.session_mp.nb_objs = info.max_nb_sessions; 223 224 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, 225 &ts_params->conf), 226 "Failed to configure cryptodev %u with %u qps", 227 dev_id, ts_params->conf.nb_queue_pairs); 228 229 ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; 230 231 for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) { 232 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( 233 dev_id, qp_id, &ts_params->qp_conf, 234 rte_cryptodev_socket_id(dev_id)), 235 "Failed to setup queue pair %u on " 236 "cryptodev %u", 237 qp_id, dev_id); 238 } 239 } 240 241 return TEST_SUCCESS; 242 } 243 244 static void 245 testsuite_teardown(void) 246 { 247 struct crypto_testsuite_params *ts_params = &testsuite_params; 248 249 if (ts_params->mbuf_pool != NULL) { 250 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n", 251 rte_mempool_count(ts_params->mbuf_pool)); 252 } 253 254 255 if (ts_params->mbuf_ol_pool != NULL) { 256 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n", 257 rte_mempool_count(ts_params->mbuf_ol_pool)); 258 } 259 260 } 261 262 static int 263 ut_setup(void) 264 { 265 struct crypto_testsuite_params *ts_params = &testsuite_params; 266 struct crypto_unittest_params *ut_params = &unittest_params; 267 268 uint16_t qp_id; 269 270 /* Clear unit test parameters before running test */ 271 memset(ut_params, 0, sizeof(*ut_params)); 272 273 /* Reconfigure device to default parameters */ 274 ts_params->conf.nb_queue_pairs = DEFAULT_NUM_QPS_PER_QAT_DEVICE; 275 ts_params->conf.socket_id = SOCKET_ID_ANY; 276 ts_params->conf.session_mp.nb_objs = 277 (gbl_cryptodev_type == RTE_CRYPTODEV_QAT_PMD) ? 278 DEFAULT_NUM_OPS_INFLIGHT : 279 DEFAULT_NUM_OPS_INFLIGHT; 280 281 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0], 282 &ts_params->conf), 283 "Failed to configure cryptodev %u", 284 ts_params->valid_devs[0]); 285 286 /* 287 * Now reconfigure queues to size we actually want to use in this 288 * test suite. 289 */ 290 ts_params->qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT; 291 292 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) { 293 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( 294 ts_params->valid_devs[0], qp_id, 295 &ts_params->qp_conf, 296 rte_cryptodev_socket_id(ts_params->valid_devs[0])), 297 "Failed to setup queue pair %u on cryptodev %u", 298 qp_id, ts_params->valid_devs[0]); 299 } 300 301 302 rte_cryptodev_stats_reset(ts_params->valid_devs[0]); 303 304 /* Start the device */ 305 TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]), 306 "Failed to start cryptodev %u", 307 ts_params->valid_devs[0]); 308 309 return TEST_SUCCESS; 310 } 311 312 static void 313 ut_teardown(void) 314 { 315 struct crypto_testsuite_params *ts_params = &testsuite_params; 316 struct crypto_unittest_params *ut_params = &unittest_params; 317 struct rte_cryptodev_stats stats; 318 319 /* free crypto session structure */ 320 if (ut_params->sess) { 321 rte_cryptodev_session_free(ts_params->valid_devs[0], 322 ut_params->sess); 323 ut_params->sess = NULL; 324 } 325 326 /* free crypto operation structure */ 327 if (ut_params->ol) 328 rte_pktmbuf_offload_free(ut_params->ol); 329 330 /* 331 * free mbuf - both obuf and ibuf are usually the same, 332 * but rte copes even if we call free twice 333 */ 334 if (ut_params->obuf) { 335 rte_pktmbuf_free(ut_params->obuf); 336 ut_params->obuf = 0; 337 } 338 if (ut_params->ibuf) { 339 rte_pktmbuf_free(ut_params->ibuf); 340 ut_params->ibuf = 0; 341 } 342 343 if (ts_params->mbuf_pool != NULL) 344 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n", 345 rte_mempool_count(ts_params->mbuf_pool)); 346 347 rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats); 348 349 /* Stop the device */ 350 rte_cryptodev_stop(ts_params->valid_devs[0]); 351 } 352 353 static int 354 test_device_configure_invalid_dev_id(void) 355 { 356 struct crypto_testsuite_params *ts_params = &testsuite_params; 357 uint16_t dev_id, num_devs = 0; 358 359 TEST_ASSERT((num_devs = rte_cryptodev_count()) >= 1, 360 "Need at least %d devices for test", 1); 361 362 /* valid dev_id values */ 363 dev_id = ts_params->valid_devs[ts_params->valid_dev_count - 1]; 364 365 /* Stop the device in case it's started so it can be configured */ 366 rte_cryptodev_stop(ts_params->valid_devs[dev_id]); 367 368 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf), 369 "Failed test for rte_cryptodev_configure: " 370 "invalid dev_num %u", dev_id); 371 372 /* invalid dev_id values */ 373 dev_id = num_devs; 374 375 TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf), 376 "Failed test for rte_cryptodev_configure: " 377 "invalid dev_num %u", dev_id); 378 379 dev_id = 0xff; 380 381 TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf), 382 "Failed test for rte_cryptodev_configure:" 383 "invalid dev_num %u", dev_id); 384 385 return TEST_SUCCESS; 386 } 387 388 static int 389 test_device_configure_invalid_queue_pair_ids(void) 390 { 391 struct crypto_testsuite_params *ts_params = &testsuite_params; 392 393 /* Stop the device in case it's started so it can be configured */ 394 rte_cryptodev_stop(ts_params->valid_devs[0]); 395 396 /* valid - one queue pairs */ 397 ts_params->conf.nb_queue_pairs = 1; 398 399 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0], 400 &ts_params->conf), 401 "Failed to configure cryptodev: dev_id %u, qp_id %u", 402 ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs); 403 404 405 /* valid - max value queue pairs */ 406 ts_params->conf.nb_queue_pairs = MAX_NUM_QPS_PER_QAT_DEVICE; 407 408 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0], 409 &ts_params->conf), 410 "Failed to configure cryptodev: dev_id %u, qp_id %u", 411 ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs); 412 413 414 /* invalid - zero queue pairs */ 415 ts_params->conf.nb_queue_pairs = 0; 416 417 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0], 418 &ts_params->conf), 419 "Failed test for rte_cryptodev_configure, dev_id %u," 420 " invalid qps: %u", 421 ts_params->valid_devs[0], 422 ts_params->conf.nb_queue_pairs); 423 424 425 /* invalid - max value supported by field queue pairs */ 426 ts_params->conf.nb_queue_pairs = UINT16_MAX; 427 428 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0], 429 &ts_params->conf), 430 "Failed test for rte_cryptodev_configure, dev_id %u," 431 " invalid qps: %u", 432 ts_params->valid_devs[0], 433 ts_params->conf.nb_queue_pairs); 434 435 436 /* invalid - max value + 1 queue pairs */ 437 ts_params->conf.nb_queue_pairs = MAX_NUM_QPS_PER_QAT_DEVICE + 1; 438 439 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0], 440 &ts_params->conf), 441 "Failed test for rte_cryptodev_configure, dev_id %u," 442 " invalid qps: %u", 443 ts_params->valid_devs[0], 444 ts_params->conf.nb_queue_pairs); 445 446 return TEST_SUCCESS; 447 } 448 449 static int 450 test_queue_pair_descriptor_setup(void) 451 { 452 struct crypto_testsuite_params *ts_params = &testsuite_params; 453 struct rte_cryptodev_info dev_info; 454 struct rte_cryptodev_qp_conf qp_conf = { 455 .nb_descriptors = MAX_NUM_OPS_INFLIGHT 456 }; 457 458 uint16_t qp_id; 459 460 /* Stop the device in case it's started so it can be configured */ 461 rte_cryptodev_stop(ts_params->valid_devs[0]); 462 463 464 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 465 466 ts_params->conf.session_mp.nb_objs = dev_info.max_nb_sessions; 467 468 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0], 469 &ts_params->conf), "Failed to configure cryptodev %u", 470 ts_params->valid_devs[0]); 471 472 473 /* 474 * Test various ring sizes on this device. memzones can't be 475 * freed so are re-used if ring is released and re-created. 476 */ 477 qp_conf.nb_descriptors = MIN_NUM_OPS_INFLIGHT; /* min size*/ 478 479 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) { 480 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( 481 ts_params->valid_devs[0], qp_id, &qp_conf, 482 rte_cryptodev_socket_id( 483 ts_params->valid_devs[0])), 484 "Failed test for " 485 "rte_cryptodev_queue_pair_setup: num_inflights " 486 "%u on qp %u on cryptodev %u", 487 qp_conf.nb_descriptors, qp_id, 488 ts_params->valid_devs[0]); 489 } 490 491 qp_conf.nb_descriptors = (uint32_t)(MAX_NUM_OPS_INFLIGHT / 2); 492 493 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) { 494 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( 495 ts_params->valid_devs[0], qp_id, &qp_conf, 496 rte_cryptodev_socket_id( 497 ts_params->valid_devs[0])), 498 "Failed test for" 499 " rte_cryptodev_queue_pair_setup: num_inflights" 500 " %u on qp %u on cryptodev %u", 501 qp_conf.nb_descriptors, qp_id, 502 ts_params->valid_devs[0]); 503 } 504 505 qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; /* valid */ 506 507 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) { 508 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( 509 ts_params->valid_devs[0], qp_id, &qp_conf, 510 rte_cryptodev_socket_id( 511 ts_params->valid_devs[0])), 512 "Failed test for " 513 "rte_cryptodev_queue_pair_setup: num_inflights" 514 " %u on qp %u on cryptodev %u", 515 qp_conf.nb_descriptors, qp_id, 516 ts_params->valid_devs[0]); 517 } 518 519 /* invalid number of descriptors - max supported + 2 */ 520 qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT + 2; 521 522 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) { 523 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup( 524 ts_params->valid_devs[0], qp_id, &qp_conf, 525 rte_cryptodev_socket_id( 526 ts_params->valid_devs[0])), 527 "Unexpectedly passed test for " 528 "rte_cryptodev_queue_pair_setup:" 529 "num_inflights %u on qp %u on cryptodev %u", 530 qp_conf.nb_descriptors, qp_id, 531 ts_params->valid_devs[0]); 532 } 533 534 /* invalid number of descriptors - max value of parameter */ 535 qp_conf.nb_descriptors = UINT32_MAX-1; 536 537 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) { 538 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup( 539 ts_params->valid_devs[0], qp_id, &qp_conf, 540 rte_cryptodev_socket_id( 541 ts_params->valid_devs[0])), 542 "Unexpectedly passed test for " 543 "rte_cryptodev_queue_pair_setup:" 544 "num_inflights %u on qp %u on cryptodev %u", 545 qp_conf.nb_descriptors, qp_id, 546 ts_params->valid_devs[0]); 547 } 548 549 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT; 550 551 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) { 552 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( 553 ts_params->valid_devs[0], qp_id, &qp_conf, 554 rte_cryptodev_socket_id( 555 ts_params->valid_devs[0])), 556 "Failed test for" 557 " rte_cryptodev_queue_pair_setup:" 558 "num_inflights %u on qp %u on cryptodev %u", 559 qp_conf.nb_descriptors, qp_id, 560 ts_params->valid_devs[0]); 561 } 562 563 /* invalid number of descriptors - max supported + 1 */ 564 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT + 1; 565 566 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) { 567 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup( 568 ts_params->valid_devs[0], qp_id, &qp_conf, 569 rte_cryptodev_socket_id( 570 ts_params->valid_devs[0])), 571 "Unexpectedly passed test for " 572 "rte_cryptodev_queue_pair_setup:" 573 "num_inflights %u on qp %u on cryptodev %u", 574 qp_conf.nb_descriptors, qp_id, 575 ts_params->valid_devs[0]); 576 } 577 578 /* test invalid queue pair id */ 579 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT; /*valid */ 580 581 qp_id = DEFAULT_NUM_QPS_PER_QAT_DEVICE; /*invalid */ 582 583 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup( 584 ts_params->valid_devs[0], 585 qp_id, &qp_conf, 586 rte_cryptodev_socket_id(ts_params->valid_devs[0])), 587 "Failed test for rte_cryptodev_queue_pair_setup:" 588 "invalid qp %u on cryptodev %u", 589 qp_id, ts_params->valid_devs[0]); 590 591 qp_id = 0xffff; /*invalid*/ 592 593 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup( 594 ts_params->valid_devs[0], 595 qp_id, &qp_conf, 596 rte_cryptodev_socket_id(ts_params->valid_devs[0])), 597 "Failed test for rte_cryptodev_queue_pair_setup:" 598 "invalid qp %u on cryptodev %u", 599 qp_id, ts_params->valid_devs[0]); 600 601 return TEST_SUCCESS; 602 } 603 604 /* ***** Plaintext data for tests ***** */ 605 606 const char catch_22_quote_1[] = 607 "There was only one catch and that was Catch-22, which " 608 "specified that a concern for one's safety in the face of " 609 "dangers that were real and immediate was the process of a " 610 "rational mind. Orr was crazy and could be grounded. All he " 611 "had to do was ask; and as soon as he did, he would no longer " 612 "be crazy and would have to fly more missions. Orr would be " 613 "crazy to fly more missions and sane if he didn't, but if he " 614 "was sane he had to fly them. If he flew them he was crazy " 615 "and didn't have to; but if he didn't want to he was sane and " 616 "had to. Yossarian was moved very deeply by the absolute " 617 "simplicity of this clause of Catch-22 and let out a " 618 "respectful whistle. \"That's some catch, that Catch-22\", he " 619 "observed. \"It's the best there is,\" Doc Daneeka agreed."; 620 621 const char catch_22_quote[] = 622 "What a lousy earth! He wondered how many people were " 623 "destitute that same night even in his own prosperous country, " 624 "how many homes were shanties, how many husbands were drunk " 625 "and wives socked, and how many children were bullied, abused, " 626 "or abandoned. How many families hungered for food they could " 627 "not afford to buy? How many hearts were broken? How many " 628 "suicides would take place that same night, how many people " 629 "would go insane? How many cockroaches and landlords would " 630 "triumph? How many winners were losers, successes failures, " 631 "and rich men poor men? How many wise guys were stupid? How " 632 "many happy endings were unhappy endings? How many honest men " 633 "were liars, brave men cowards, loyal men traitors, how many " 634 "sainted men were corrupt, how many people in positions of " 635 "trust had sold their souls to bodyguards, how many had never " 636 "had souls? How many straight-and-narrow paths were crooked " 637 "paths? How many best families were worst families and how " 638 "many good people were bad people? When you added them all up " 639 "and then subtracted, you might be left with only the children, " 640 "and perhaps with Albert Einstein and an old violinist or " 641 "sculptor somewhere."; 642 643 #define QUOTE_480_BYTES (480) 644 #define QUOTE_512_BYTES (512) 645 #define QUOTE_768_BYTES (768) 646 #define QUOTE_1024_BYTES (1024) 647 648 649 650 /* ***** SHA1 Hash Tests ***** */ 651 652 #define HMAC_KEY_LENGTH_SHA1 (DIGEST_BYTE_LENGTH_SHA1) 653 654 static uint8_t hmac_sha1_key[] = { 655 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA, 656 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD, 657 0xDE, 0xF4, 0xDE, 0xAD }; 658 659 /* ***** SHA224 Hash Tests ***** */ 660 661 #define HMAC_KEY_LENGTH_SHA224 (DIGEST_BYTE_LENGTH_SHA224) 662 663 664 /* ***** AES-CBC Cipher Tests ***** */ 665 666 #define CIPHER_KEY_LENGTH_AES_CBC (16) 667 #define CIPHER_IV_LENGTH_AES_CBC (CIPHER_KEY_LENGTH_AES_CBC) 668 669 static uint8_t aes_cbc_key[] = { 670 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2, 671 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A }; 672 673 static uint8_t aes_cbc_iv[] = { 674 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 675 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f }; 676 677 678 /* ***** AES-CBC / HMAC-SHA1 Hash Tests ***** */ 679 680 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_ciphertext[] = { 681 0x8B, 0X4D, 0XDA, 0X1B, 0XCF, 0X04, 0XA0, 0X31, 682 0XB4, 0XBF, 0XBD, 0X68, 0X43, 0X20, 0X7E, 0X76, 683 0XB1, 0X96, 0X8B, 0XA2, 0X7C, 0XA2, 0X83, 0X9E, 684 0X39, 0X5A, 0X2F, 0X7E, 0X92, 0XB4, 0X48, 0X1A, 685 0X3F, 0X6B, 0X5D, 0XDF, 0X52, 0X85, 0X5F, 0X8E, 686 0X42, 0X3C, 0XFB, 0XE9, 0X1A, 0X24, 0XD6, 0X08, 687 0XDD, 0XFD, 0X16, 0XFB, 0XE9, 0X55, 0XEF, 0XF0, 688 0XA0, 0X8D, 0X13, 0XAB, 0X81, 0XC6, 0X90, 0X01, 689 0XB5, 0X18, 0X84, 0XB3, 0XF6, 0XE6, 0X11, 0X57, 690 0XD6, 0X71, 0XC6, 0X3C, 0X3F, 0X2F, 0X33, 0XEE, 691 0X24, 0X42, 0X6E, 0XAC, 0X0B, 0XCA, 0XEC, 0XF9, 692 0X84, 0XF8, 0X22, 0XAA, 0X60, 0XF0, 0X32, 0XA9, 693 0X75, 0X75, 0X3B, 0XCB, 0X70, 0X21, 0X0A, 0X8D, 694 0X0F, 0XE0, 0XC4, 0X78, 0X2B, 0XF8, 0X97, 0XE3, 695 0XE4, 0X26, 0X4B, 0X29, 0XDA, 0X88, 0XCD, 0X46, 696 0XEC, 0XAA, 0XF9, 0X7F, 0XF1, 0X15, 0XEA, 0XC3, 697 0X87, 0XE6, 0X31, 0XF2, 0XCF, 0XDE, 0X4D, 0X80, 698 0X70, 0X91, 0X7E, 0X0C, 0XF7, 0X26, 0X3A, 0X92, 699 0X4F, 0X18, 0X83, 0XC0, 0X8F, 0X59, 0X01, 0XA5, 700 0X88, 0XD1, 0XDB, 0X26, 0X71, 0X27, 0X16, 0XF5, 701 0XEE, 0X10, 0X82, 0XAC, 0X68, 0X26, 0X9B, 0XE2, 702 0X6D, 0XD8, 0X9A, 0X80, 0XDF, 0X04, 0X31, 0XD5, 703 0XF1, 0X35, 0X5C, 0X3B, 0XDD, 0X9A, 0X65, 0XBA, 704 0X58, 0X34, 0X85, 0X61, 0X1C, 0X42, 0X10, 0X76, 705 0X73, 0X02, 0X42, 0XC9, 0X23, 0X18, 0X8E, 0XB4, 706 0X6F, 0XB4, 0XA3, 0X54, 0X6E, 0X88, 0X3B, 0X62, 707 0X7C, 0X02, 0X8D, 0X4C, 0X9F, 0XC8, 0X45, 0XF4, 708 0XC9, 0XDE, 0X4F, 0XEB, 0X22, 0X83, 0X1B, 0XE4, 709 0X49, 0X37, 0XE4, 0XAD, 0XE7, 0XCD, 0X21, 0X54, 710 0XBC, 0X1C, 0XC2, 0X04, 0X97, 0XB4, 0X10, 0X61, 711 0XF0, 0XE4, 0XEF, 0X27, 0X63, 0X3A, 0XDA, 0X91, 712 0X41, 0X25, 0X62, 0X1C, 0X5C, 0XB6, 0X38, 0X4A, 713 0X88, 0X71, 0X59, 0X5A, 0X8D, 0XA0, 0X09, 0XAF, 714 0X72, 0X94, 0XD7, 0X79, 0X5C, 0X60, 0X7C, 0X8F, 715 0X4C, 0XF5, 0XD9, 0XA1, 0X39, 0X6D, 0X81, 0X28, 716 0XEF, 0X13, 0X28, 0XDF, 0XF5, 0X3E, 0XF7, 0X8E, 717 0X09, 0X9C, 0X78, 0X18, 0X79, 0XB8, 0X68, 0XD7, 718 0XA8, 0X29, 0X62, 0XAD, 0XDE, 0XE1, 0X61, 0X76, 719 0X1B, 0X05, 0X16, 0XCD, 0XBF, 0X02, 0X8E, 0XA6, 720 0X43, 0X6E, 0X92, 0X55, 0X4F, 0X60, 0X9C, 0X03, 721 0XB8, 0X4F, 0XA3, 0X02, 0XAC, 0XA8, 0XA7, 0X0C, 722 0X1E, 0XB5, 0X6B, 0XF8, 0XC8, 0X4D, 0XDE, 0XD2, 723 0XB0, 0X29, 0X6E, 0X40, 0XE6, 0XD6, 0XC9, 0XE6, 724 0XB9, 0X0F, 0XB6, 0X63, 0XF5, 0XAA, 0X2B, 0X96, 725 0XA7, 0X16, 0XAC, 0X4E, 0X0A, 0X33, 0X1C, 0XA6, 726 0XE6, 0XBD, 0X8A, 0XCF, 0X40, 0XA9, 0XB2, 0XFA, 727 0X63, 0X27, 0XFD, 0X9B, 0XD9, 0XFC, 0XD5, 0X87, 728 0X8D, 0X4C, 0XB6, 0XA4, 0XCB, 0XE7, 0X74, 0X55, 729 0XF4, 0XFB, 0X41, 0X25, 0XB5, 0X4B, 0X0A, 0X1B, 730 0XB1, 0XD6, 0XB7, 0XD9, 0X47, 0X2A, 0XC3, 0X98, 731 0X6A, 0XC4, 0X03, 0X73, 0X1F, 0X93, 0X6E, 0X53, 732 0X19, 0X25, 0X64, 0X15, 0X83, 0XF9, 0X73, 0X2A, 733 0X74, 0XB4, 0X93, 0X69, 0XC4, 0X72, 0XFC, 0X26, 734 0XA2, 0X9F, 0X43, 0X45, 0XDD, 0XB9, 0XEF, 0X36, 735 0XC8, 0X3A, 0XCD, 0X99, 0X9B, 0X54, 0X1A, 0X36, 736 0XC1, 0X59, 0XF8, 0X98, 0XA8, 0XCC, 0X28, 0X0D, 737 0X73, 0X4C, 0XEE, 0X98, 0XCB, 0X7C, 0X58, 0X7E, 738 0X20, 0X75, 0X1E, 0XB7, 0XC9, 0XF8, 0XF2, 0X0E, 739 0X63, 0X9E, 0X05, 0X78, 0X1A, 0XB6, 0XA8, 0X7A, 740 0XF9, 0X98, 0X6A, 0XA6, 0X46, 0X84, 0X2E, 0XF6, 741 0X4B, 0XDC, 0X9B, 0X8F, 0X9B, 0X8F, 0XEE, 0XB4, 742 0XAA, 0X3F, 0XEE, 0XC0, 0X37, 0X27, 0X76, 0XC7, 743 0X95, 0XBB, 0X26, 0X74, 0X69, 0X12, 0X7F, 0XF1, 744 0XBB, 0XFF, 0XAE, 0XB5, 0X99, 0X6E, 0XCB, 0X0C 745 }; 746 747 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest[] = { 748 0x9a, 0X4f, 0X88, 0X1b, 0Xb6, 0X8f, 0Xd8, 0X60, 749 0X42, 0X1a, 0X7d, 0X3d, 0Xf5, 0X82, 0X80, 0Xf1, 750 0X18, 0X8c, 0X1d, 0X32 }; 751 752 753 static int 754 test_AES_CBC_HMAC_SHA1_encrypt_digest(void) 755 { 756 struct crypto_testsuite_params *ts_params = &testsuite_params; 757 struct crypto_unittest_params *ut_params = &unittest_params; 758 759 /* Generate test mbuf data and space for digest */ 760 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool, 761 catch_22_quote, QUOTE_512_BYTES, 0); 762 763 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 764 DIGEST_BYTE_LENGTH_SHA1); 765 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest"); 766 767 /* Setup Cipher Parameters */ 768 ut_params->cipher_xform.type = RTE_CRYPTO_XFORM_CIPHER; 769 ut_params->cipher_xform.next = &ut_params->auth_xform; 770 771 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC; 772 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; 773 ut_params->cipher_xform.cipher.key.data = aes_cbc_key; 774 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC; 775 776 /* Setup HMAC Parameters */ 777 778 ut_params->auth_xform.type = RTE_CRYPTO_XFORM_AUTH; 779 ut_params->auth_xform.next = NULL; 780 781 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; 782 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC; 783 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1; 784 ut_params->auth_xform.auth.key.data = hmac_sha1_key; 785 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1; 786 787 /* Create Crypto session*/ 788 ut_params->sess = rte_cryptodev_session_create(ts_params->valid_devs[0], 789 &ut_params->cipher_xform); 790 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 791 792 /* Generate Crypto op data structure */ 793 ut_params->ol = rte_pktmbuf_offload_alloc(ts_params->mbuf_ol_pool, 794 RTE_PKTMBUF_OL_CRYPTO); 795 TEST_ASSERT_NOT_NULL(ut_params->ol, 796 "Failed to allocate pktmbuf offload"); 797 798 ut_params->op = &ut_params->ol->op.crypto; 799 800 /* Set crypto operation data parameters */ 801 rte_crypto_op_attach_session(ut_params->op, ut_params->sess); 802 803 ut_params->op->digest.data = ut_params->digest; 804 ut_params->op->digest.phys_addr = rte_pktmbuf_mtophys_offset( 805 ut_params->ibuf, QUOTE_512_BYTES); 806 ut_params->op->digest.length = DIGEST_BYTE_LENGTH_SHA1; 807 808 ut_params->op->iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf, 809 CIPHER_IV_LENGTH_AES_CBC); 810 ut_params->op->iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); 811 ut_params->op->iv.length = CIPHER_IV_LENGTH_AES_CBC; 812 813 rte_memcpy(ut_params->op->iv.data, aes_cbc_iv, 814 CIPHER_IV_LENGTH_AES_CBC); 815 816 ut_params->op->data.to_cipher.offset = CIPHER_IV_LENGTH_AES_CBC; 817 ut_params->op->data.to_cipher.length = QUOTE_512_BYTES; 818 ut_params->op->data.to_hash.offset = CIPHER_IV_LENGTH_AES_CBC; 819 ut_params->op->data.to_hash.length = QUOTE_512_BYTES; 820 821 rte_pktmbuf_offload_attach(ut_params->ibuf, ut_params->ol); 822 823 /* Process crypto operation */ 824 ut_params->obuf = process_crypto_request(ts_params->valid_devs[0], 825 ut_params->ibuf); 826 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf"); 827 828 /* Validate obuf */ 829 TEST_ASSERT_BUFFERS_ARE_EQUAL( 830 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + 831 CIPHER_IV_LENGTH_AES_CBC, 832 catch_22_quote_2_512_bytes_AES_CBC_ciphertext, 833 QUOTE_512_BYTES, 834 "Ciphertext data not as expected"); 835 836 TEST_ASSERT_BUFFERS_ARE_EQUAL( 837 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + 838 CIPHER_IV_LENGTH_AES_CBC + QUOTE_512_BYTES, 839 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest, 840 gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD ? 841 TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 : 842 DIGEST_BYTE_LENGTH_SHA1, 843 "Generated digest data not as expected"); 844 845 return TEST_SUCCESS; 846 } 847 848 static int 849 test_AES_CBC_HMAC_SHA1_encrypt_digest_sessionless(void) 850 { 851 struct crypto_testsuite_params *ts_params = &testsuite_params; 852 struct crypto_unittest_params *ut_params = &unittest_params; 853 854 /* Generate test mbuf data and space for digest */ 855 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool, 856 catch_22_quote, QUOTE_512_BYTES, 0); 857 858 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 859 DIGEST_BYTE_LENGTH_SHA1); 860 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest"); 861 862 /* Generate Crypto op data structure */ 863 ut_params->ol = rte_pktmbuf_offload_alloc(ts_params->mbuf_ol_pool, 864 RTE_PKTMBUF_OL_CRYPTO); 865 TEST_ASSERT_NOT_NULL(ut_params->ol, 866 "Failed to allocate pktmbuf offload"); 867 868 ut_params->op = &ut_params->ol->op.crypto; 869 870 TEST_ASSERT_NOT_NULL(rte_pktmbuf_offload_alloc_crypto_xforms( 871 ut_params->ol, 2), 872 "failed to allocate space for crypto transforms"); 873 874 /* Set crypto operation data parameters */ 875 ut_params->op->xform->type = RTE_CRYPTO_XFORM_CIPHER; 876 877 /* cipher parameters */ 878 ut_params->op->xform->cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; 879 ut_params->op->xform->cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC; 880 ut_params->op->xform->cipher.key.data = aes_cbc_key; 881 ut_params->op->xform->cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC; 882 883 /* hash parameters */ 884 ut_params->op->xform->next->type = RTE_CRYPTO_XFORM_AUTH; 885 886 ut_params->op->xform->next->auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; 887 ut_params->op->xform->next->auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC; 888 ut_params->op->xform->next->auth.key.length = HMAC_KEY_LENGTH_SHA1; 889 ut_params->op->xform->next->auth.key.data = hmac_sha1_key; 890 ut_params->op->xform->next->auth.digest_length = 891 DIGEST_BYTE_LENGTH_SHA1; 892 893 ut_params->op->digest.data = ut_params->digest; 894 ut_params->op->digest.phys_addr = rte_pktmbuf_mtophys_offset( 895 ut_params->ibuf, QUOTE_512_BYTES); 896 ut_params->op->digest.length = DIGEST_BYTE_LENGTH_SHA1; 897 898 ut_params->op->iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf, 899 CIPHER_IV_LENGTH_AES_CBC); 900 ut_params->op->iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); 901 ut_params->op->iv.length = CIPHER_IV_LENGTH_AES_CBC; 902 903 rte_memcpy(ut_params->op->iv.data, aes_cbc_iv, 904 CIPHER_IV_LENGTH_AES_CBC); 905 906 ut_params->op->data.to_cipher.offset = CIPHER_IV_LENGTH_AES_CBC; 907 ut_params->op->data.to_cipher.length = QUOTE_512_BYTES; 908 ut_params->op->data.to_hash.offset = CIPHER_IV_LENGTH_AES_CBC; 909 ut_params->op->data.to_hash.length = QUOTE_512_BYTES; 910 911 rte_pktmbuf_offload_attach(ut_params->ibuf, ut_params->ol); 912 913 /* Process crypto operation */ 914 ut_params->obuf = process_crypto_request(ts_params->valid_devs[0], 915 ut_params->ibuf); 916 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf"); 917 918 /* Validate obuf */ 919 TEST_ASSERT_BUFFERS_ARE_EQUAL( 920 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + 921 CIPHER_IV_LENGTH_AES_CBC, 922 catch_22_quote_2_512_bytes_AES_CBC_ciphertext, 923 QUOTE_512_BYTES, 924 "Ciphertext data not as expected"); 925 926 TEST_ASSERT_BUFFERS_ARE_EQUAL( 927 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + 928 CIPHER_IV_LENGTH_AES_CBC + QUOTE_512_BYTES, 929 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest, 930 gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD ? 931 TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 : 932 DIGEST_BYTE_LENGTH_SHA1, 933 "Generated digest data not as expected"); 934 935 936 return TEST_SUCCESS; 937 } 938 939 static int 940 test_AES_CBC_HMAC_SHA1_decrypt_digest_verify(void) 941 { 942 struct crypto_testsuite_params *ts_params = &testsuite_params; 943 struct crypto_unittest_params *ut_params = &unittest_params; 944 945 /* Generate test mbuf data and digest */ 946 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool, 947 (const char *) 948 catch_22_quote_2_512_bytes_AES_CBC_ciphertext, 949 QUOTE_512_BYTES, 0); 950 951 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 952 DIGEST_BYTE_LENGTH_SHA1); 953 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest"); 954 955 rte_memcpy(ut_params->digest, 956 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest, 957 DIGEST_BYTE_LENGTH_SHA1); 958 959 /* Setup Cipher Parameters */ 960 ut_params->cipher_xform.type = RTE_CRYPTO_XFORM_CIPHER; 961 ut_params->cipher_xform.next = NULL; 962 963 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC; 964 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT; 965 ut_params->cipher_xform.cipher.key.data = aes_cbc_key; 966 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC; 967 968 /* Setup HMAC Parameters */ 969 ut_params->auth_xform.type = RTE_CRYPTO_XFORM_AUTH; 970 ut_params->auth_xform.next = &ut_params->cipher_xform; 971 972 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY; 973 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC; 974 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1; 975 ut_params->auth_xform.auth.key.data = hmac_sha1_key; 976 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1; 977 978 /* Create Crypto session*/ 979 ut_params->sess = rte_cryptodev_session_create(ts_params->valid_devs[0], 980 &ut_params->auth_xform); 981 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 982 983 /* Generate Crypto op data structure */ 984 ut_params->ol = rte_pktmbuf_offload_alloc(ts_params->mbuf_ol_pool, 985 RTE_PKTMBUF_OL_CRYPTO); 986 TEST_ASSERT_NOT_NULL(ut_params->ol, 987 "Failed to allocate pktmbuf offload"); 988 989 ut_params->op = &ut_params->ol->op.crypto; 990 991 992 /* Set crypto operation data parameters */ 993 rte_crypto_op_attach_session(ut_params->op, ut_params->sess); 994 995 ut_params->op->digest.data = ut_params->digest; 996 ut_params->op->digest.phys_addr = rte_pktmbuf_mtophys_offset( 997 ut_params->ibuf, QUOTE_512_BYTES); 998 ut_params->op->digest.length = DIGEST_BYTE_LENGTH_SHA1; 999 1000 ut_params->op->iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf, 1001 CIPHER_IV_LENGTH_AES_CBC); 1002 ut_params->op->iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); 1003 ut_params->op->iv.length = CIPHER_IV_LENGTH_AES_CBC; 1004 1005 rte_memcpy(ut_params->op->iv.data, aes_cbc_iv, 1006 CIPHER_IV_LENGTH_AES_CBC); 1007 1008 ut_params->op->data.to_cipher.offset = CIPHER_IV_LENGTH_AES_CBC; 1009 ut_params->op->data.to_cipher.length = QUOTE_512_BYTES; 1010 1011 ut_params->op->data.to_hash.offset = CIPHER_IV_LENGTH_AES_CBC; 1012 ut_params->op->data.to_hash.length = QUOTE_512_BYTES; 1013 1014 rte_pktmbuf_offload_attach(ut_params->ibuf, ut_params->ol); 1015 1016 /* Process crypto operation */ 1017 ut_params->obuf = process_crypto_request(ts_params->valid_devs[0], 1018 ut_params->ibuf); 1019 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf"); 1020 1021 /* Validate obuf */ 1022 TEST_ASSERT_BUFFERS_ARE_EQUAL( 1023 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + 1024 CIPHER_IV_LENGTH_AES_CBC, 1025 catch_22_quote, 1026 QUOTE_512_BYTES, 1027 "Ciphertext data not as expected"); 1028 1029 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 1030 "Digest verification failed"); 1031 1032 1033 return TEST_SUCCESS; 1034 } 1035 1036 1037 /* ***** AES-CBC / HMAC-SHA256 Hash Tests ***** */ 1038 1039 #define HMAC_KEY_LENGTH_SHA256 (DIGEST_BYTE_LENGTH_SHA256) 1040 1041 static uint8_t hmac_sha256_key[] = { 1042 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1, 1043 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA, 1044 0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76, 1045 0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60 }; 1046 1047 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA256_digest[] = { 1048 0xc8, 0x57, 0x57, 0x31, 0x03, 0xe0, 0x03, 0x55, 1049 0x07, 0xc8, 0x9e, 0x7f, 0x48, 0x9a, 0x61, 0x9a, 1050 0x68, 0xee, 0x03, 0x0e, 0x71, 0x75, 0xc7, 0xf4, 1051 0x2e, 0x45, 0x26, 0x32, 0x7c, 0x12, 0x15, 0x15 }; 1052 1053 static int 1054 test_AES_CBC_HMAC_SHA256_encrypt_digest(void) 1055 { 1056 struct crypto_testsuite_params *ts_params = &testsuite_params; 1057 struct crypto_unittest_params *ut_params = &unittest_params; 1058 1059 /* Generate test mbuf data and space for digest */ 1060 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool, 1061 catch_22_quote, QUOTE_512_BYTES, 0); 1062 1063 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 1064 DIGEST_BYTE_LENGTH_SHA256); 1065 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest"); 1066 1067 /* Setup Cipher Parameters */ 1068 ut_params->cipher_xform.type = RTE_CRYPTO_XFORM_CIPHER; 1069 ut_params->cipher_xform.next = &ut_params->auth_xform; 1070 1071 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC; 1072 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; 1073 ut_params->cipher_xform.cipher.key.data = aes_cbc_key; 1074 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC; 1075 1076 /* Setup HMAC Parameters */ 1077 ut_params->auth_xform.type = RTE_CRYPTO_XFORM_AUTH; 1078 ut_params->auth_xform.next = NULL; 1079 1080 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; 1081 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA256_HMAC; 1082 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA256; 1083 ut_params->auth_xform.auth.key.data = hmac_sha256_key; 1084 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA256; 1085 1086 /* Create Crypto session*/ 1087 ut_params->sess = rte_cryptodev_session_create(ts_params->valid_devs[0], 1088 &ut_params->cipher_xform); 1089 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 1090 1091 /* Generate Crypto op data structure */ 1092 ut_params->ol = rte_pktmbuf_offload_alloc(ts_params->mbuf_ol_pool, 1093 RTE_PKTMBUF_OL_CRYPTO); 1094 TEST_ASSERT_NOT_NULL(ut_params->ol, 1095 "Failed to allocate pktmbuf offload"); 1096 1097 ut_params->op = &ut_params->ol->op.crypto; 1098 1099 1100 /* Set crypto operation data parameters */ 1101 rte_crypto_op_attach_session(ut_params->op, ut_params->sess); 1102 1103 ut_params->op->digest.data = ut_params->digest; 1104 ut_params->op->digest.phys_addr = rte_pktmbuf_mtophys_offset( 1105 ut_params->ibuf, QUOTE_512_BYTES); 1106 ut_params->op->digest.length = DIGEST_BYTE_LENGTH_SHA256; 1107 1108 ut_params->op->iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf, 1109 CIPHER_IV_LENGTH_AES_CBC); 1110 ut_params->op->iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); 1111 ut_params->op->iv.length = CIPHER_IV_LENGTH_AES_CBC; 1112 1113 rte_memcpy(ut_params->op->iv.data, aes_cbc_iv, 1114 CIPHER_IV_LENGTH_AES_CBC); 1115 1116 ut_params->op->data.to_cipher.offset = CIPHER_IV_LENGTH_AES_CBC; 1117 ut_params->op->data.to_cipher.length = QUOTE_512_BYTES; 1118 ut_params->op->data.to_hash.offset = CIPHER_IV_LENGTH_AES_CBC; 1119 ut_params->op->data.to_hash.length = QUOTE_512_BYTES; 1120 1121 rte_pktmbuf_offload_attach(ut_params->ibuf, ut_params->ol); 1122 1123 /* Process crypto operation */ 1124 ut_params->obuf = process_crypto_request(ts_params->valid_devs[0], 1125 ut_params->ibuf); 1126 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf"); 1127 1128 /* Validate obuf */ 1129 TEST_ASSERT_BUFFERS_ARE_EQUAL( 1130 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + 1131 CIPHER_IV_LENGTH_AES_CBC, 1132 catch_22_quote_2_512_bytes_AES_CBC_ciphertext, 1133 QUOTE_512_BYTES, 1134 "Ciphertext data not as expected"); 1135 1136 TEST_ASSERT_BUFFERS_ARE_EQUAL( 1137 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + 1138 CIPHER_IV_LENGTH_AES_CBC + QUOTE_512_BYTES, 1139 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA256_digest, 1140 gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD ? 1141 TRUNCATED_DIGEST_BYTE_LENGTH_SHA256 : 1142 DIGEST_BYTE_LENGTH_SHA256, 1143 "Generated digest data not as expected"); 1144 1145 1146 return TEST_SUCCESS; 1147 } 1148 1149 static int 1150 test_AES_CBC_HMAC_SHA256_decrypt_digest_verify(void) 1151 { 1152 struct crypto_testsuite_params *ts_params = &testsuite_params; 1153 struct crypto_unittest_params *ut_params = &unittest_params; 1154 1155 /* Generate test mbuf data and digest */ 1156 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool, 1157 (const char *) 1158 catch_22_quote_2_512_bytes_AES_CBC_ciphertext, 1159 QUOTE_512_BYTES, 0); 1160 1161 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 1162 DIGEST_BYTE_LENGTH_SHA256); 1163 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest"); 1164 1165 rte_memcpy(ut_params->digest, 1166 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA256_digest, 1167 DIGEST_BYTE_LENGTH_SHA256); 1168 1169 /* Setup Cipher Parameters */ 1170 ut_params->cipher_xform.type = RTE_CRYPTO_XFORM_CIPHER; 1171 ut_params->cipher_xform.next = NULL; 1172 1173 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC; 1174 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT; 1175 ut_params->cipher_xform.cipher.key.data = aes_cbc_key; 1176 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC; 1177 1178 /* Setup HMAC Parameters */ 1179 ut_params->auth_xform.type = RTE_CRYPTO_XFORM_AUTH; 1180 ut_params->auth_xform.next = &ut_params->cipher_xform; 1181 1182 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY; 1183 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA256_HMAC; 1184 ut_params->auth_xform.auth.key.data = hmac_sha256_key; 1185 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA256; 1186 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA256; 1187 1188 /* Create Crypto session*/ 1189 ut_params->sess = rte_cryptodev_session_create(ts_params->valid_devs[0], 1190 &ut_params->auth_xform); 1191 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 1192 1193 /* Generate Crypto op data structure */ 1194 ut_params->ol = rte_pktmbuf_offload_alloc(ts_params->mbuf_ol_pool, 1195 RTE_PKTMBUF_OL_CRYPTO); 1196 TEST_ASSERT_NOT_NULL(ut_params->ol, 1197 "Failed to allocate pktmbuf offload"); 1198 1199 ut_params->op = &ut_params->ol->op.crypto; 1200 1201 1202 /* Set crypto operation data parameters */ 1203 rte_crypto_op_attach_session(ut_params->op, ut_params->sess); 1204 1205 ut_params->op->digest.data = ut_params->digest; 1206 ut_params->op->digest.phys_addr = rte_pktmbuf_mtophys_offset( 1207 ut_params->ibuf, QUOTE_512_BYTES); 1208 ut_params->op->digest.length = DIGEST_BYTE_LENGTH_SHA256; 1209 1210 ut_params->op->iv.data = (uint8_t *)rte_pktmbuf_prepend( 1211 ut_params->ibuf, CIPHER_IV_LENGTH_AES_CBC); 1212 ut_params->op->iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); 1213 ut_params->op->iv.length = CIPHER_IV_LENGTH_AES_CBC; 1214 1215 rte_memcpy(ut_params->op->iv.data, aes_cbc_iv, 1216 CIPHER_IV_LENGTH_AES_CBC); 1217 1218 ut_params->op->data.to_cipher.offset = CIPHER_IV_LENGTH_AES_CBC; 1219 ut_params->op->data.to_cipher.length = QUOTE_512_BYTES; 1220 1221 ut_params->op->data.to_hash.offset = CIPHER_IV_LENGTH_AES_CBC; 1222 ut_params->op->data.to_hash.length = QUOTE_512_BYTES; 1223 1224 rte_pktmbuf_offload_attach(ut_params->ibuf, ut_params->ol); 1225 1226 /* Process crypto operation */ 1227 ut_params->obuf = process_crypto_request(ts_params->valid_devs[0], 1228 ut_params->ibuf); 1229 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf"); 1230 1231 /* Validate obuf */ 1232 TEST_ASSERT_BUFFERS_ARE_EQUAL( 1233 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + 1234 CIPHER_IV_LENGTH_AES_CBC, catch_22_quote, 1235 QUOTE_512_BYTES, 1236 "Plaintext data not as expected"); 1237 1238 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 1239 "Digest verification failed"); 1240 1241 1242 return TEST_SUCCESS; 1243 } 1244 1245 /* ***** AES-CBC / HMAC-SHA512 Hash Tests ***** */ 1246 1247 #define HMAC_KEY_LENGTH_SHA512 (DIGEST_BYTE_LENGTH_SHA512) 1248 1249 static uint8_t hmac_sha512_key[] = { 1250 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1, 1251 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA, 1252 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76, 1253 0x9a, 0xaf, 0x88, 0x1b, 0xb6, 0x8f, 0xf8, 0x60, 1254 0xa2, 0x5a, 0x7f, 0x3f, 0xf4, 0x72, 0x70, 0xf1, 1255 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0, 1256 0x47, 0x3a, 0x75, 0x61, 0x5C, 0xa2, 0x10, 0x76, 1257 0x9a, 0xaf, 0x77, 0x5b, 0xb6, 0x7f, 0xf7, 0x60 }; 1258 1259 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest[] = { 1260 0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8, 1261 0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48, 1262 0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8, 1263 0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70, 1264 0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8, 1265 0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E, 1266 0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D, 1267 0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A }; 1268 1269 static int 1270 test_AES_CBC_HMAC_SHA512_encrypt_digest(void) 1271 { 1272 struct crypto_testsuite_params *ts_params = &testsuite_params; 1273 struct crypto_unittest_params *ut_params = &unittest_params; 1274 1275 /* Generate test mbuf data and space for digest */ 1276 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool, 1277 catch_22_quote, QUOTE_512_BYTES, 0); 1278 1279 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 1280 DIGEST_BYTE_LENGTH_SHA512); 1281 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest"); 1282 1283 /* Setup Cipher Parameters */ 1284 ut_params->cipher_xform.type = RTE_CRYPTO_XFORM_CIPHER; 1285 ut_params->cipher_xform.next = &ut_params->auth_xform; 1286 1287 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC; 1288 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; 1289 ut_params->cipher_xform.cipher.key.data = aes_cbc_key; 1290 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC; 1291 1292 /* Setup HMAC Parameters */ 1293 ut_params->auth_xform.type = RTE_CRYPTO_XFORM_AUTH; 1294 ut_params->auth_xform.next = NULL; 1295 1296 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; 1297 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC; 1298 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512; 1299 ut_params->auth_xform.auth.key.data = hmac_sha512_key; 1300 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512; 1301 1302 /* Create Crypto session*/ 1303 ut_params->sess = rte_cryptodev_session_create(ts_params->valid_devs[0], 1304 &ut_params->cipher_xform); 1305 1306 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 1307 1308 1309 /* Generate Crypto op data structure */ 1310 ut_params->ol = rte_pktmbuf_offload_alloc(ts_params->mbuf_ol_pool, 1311 RTE_PKTMBUF_OL_CRYPTO); 1312 TEST_ASSERT_NOT_NULL(ut_params->ol, 1313 "Failed to allocate pktmbuf offload"); 1314 1315 ut_params->op = &ut_params->ol->op.crypto; 1316 1317 1318 /* Set crypto operation data parameters */ 1319 rte_crypto_op_attach_session(ut_params->op, ut_params->sess); 1320 1321 ut_params->op->digest.data = ut_params->digest; 1322 ut_params->op->digest.phys_addr = rte_pktmbuf_mtophys_offset( 1323 ut_params->ibuf, QUOTE_512_BYTES); 1324 ut_params->op->digest.length = DIGEST_BYTE_LENGTH_SHA512; 1325 1326 ut_params->op->iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf, 1327 CIPHER_IV_LENGTH_AES_CBC); 1328 ut_params->op->iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); 1329 ut_params->op->iv.length = CIPHER_IV_LENGTH_AES_CBC; 1330 1331 rte_memcpy(ut_params->op->iv.data, aes_cbc_iv, 1332 CIPHER_IV_LENGTH_AES_CBC); 1333 1334 ut_params->op->data.to_cipher.offset = CIPHER_IV_LENGTH_AES_CBC; 1335 ut_params->op->data.to_cipher.length = QUOTE_512_BYTES; 1336 ut_params->op->data.to_hash.offset = CIPHER_IV_LENGTH_AES_CBC; 1337 ut_params->op->data.to_hash.length = QUOTE_512_BYTES; 1338 1339 rte_pktmbuf_offload_attach(ut_params->ibuf, ut_params->ol); 1340 1341 /* Process crypto operation */ 1342 ut_params->obuf = process_crypto_request(ts_params->valid_devs[0], 1343 ut_params->ibuf); 1344 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf"); 1345 1346 /* Validate obuf */ 1347 TEST_ASSERT_BUFFERS_ARE_EQUAL( 1348 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + 1349 CIPHER_IV_LENGTH_AES_CBC, 1350 catch_22_quote_2_512_bytes_AES_CBC_ciphertext, 1351 QUOTE_512_BYTES, 1352 "Ciphertext data not as expected"); 1353 1354 TEST_ASSERT_BUFFERS_ARE_EQUAL( 1355 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + 1356 CIPHER_IV_LENGTH_AES_CBC + QUOTE_512_BYTES, 1357 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest, 1358 gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD ? 1359 TRUNCATED_DIGEST_BYTE_LENGTH_SHA512 : 1360 DIGEST_BYTE_LENGTH_SHA512, 1361 "Generated digest data not as expected"); 1362 1363 1364 return TEST_SUCCESS; 1365 } 1366 1367 1368 static int 1369 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params( 1370 struct crypto_unittest_params *ut_params); 1371 1372 static int 1373 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_session *sess, 1374 struct crypto_unittest_params *ut_params, 1375 struct crypto_testsuite_params *ts_params); 1376 1377 static int 1378 test_AES_CBC_HMAC_SHA512_decrypt_digest_verify(void) 1379 { 1380 struct crypto_unittest_params *ut_params = &unittest_params; 1381 struct crypto_testsuite_params *ts_params = &testsuite_params; 1382 1383 TEST_ASSERT(test_AES_CBC_HMAC_SHA512_decrypt_create_session_params( 1384 ut_params) == TEST_SUCCESS, 1385 "Failed to create session params"); 1386 1387 /* Create Crypto session*/ 1388 ut_params->sess = rte_cryptodev_session_create(ts_params->valid_devs[0], 1389 &ut_params->auth_xform); 1390 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 1391 1392 return test_AES_CBC_HMAC_SHA512_decrypt_perform(ut_params->sess, 1393 ut_params, ts_params); 1394 } 1395 1396 static int 1397 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params( 1398 struct crypto_unittest_params *ut_params) 1399 { 1400 1401 /* Setup Cipher Parameters */ 1402 ut_params->cipher_xform.type = RTE_CRYPTO_XFORM_CIPHER; 1403 ut_params->cipher_xform.next = NULL; 1404 1405 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC; 1406 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT; 1407 ut_params->cipher_xform.cipher.key.data = aes_cbc_key; 1408 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC; 1409 1410 /* Setup HMAC Parameters */ 1411 ut_params->auth_xform.type = RTE_CRYPTO_XFORM_AUTH; 1412 ut_params->auth_xform.next = &ut_params->cipher_xform; 1413 1414 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY; 1415 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC; 1416 ut_params->auth_xform.auth.key.data = hmac_sha512_key; 1417 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512; 1418 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512; 1419 return TEST_SUCCESS; 1420 } 1421 1422 1423 static int 1424 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_session *sess, 1425 struct crypto_unittest_params *ut_params, 1426 struct crypto_testsuite_params *ts_params) 1427 { 1428 /* Generate test mbuf data and digest */ 1429 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool, 1430 (const char *) 1431 catch_22_quote_2_512_bytes_AES_CBC_ciphertext, 1432 QUOTE_512_BYTES, 0); 1433 1434 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 1435 DIGEST_BYTE_LENGTH_SHA512); 1436 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest"); 1437 1438 rte_memcpy(ut_params->digest, 1439 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest, 1440 DIGEST_BYTE_LENGTH_SHA512); 1441 1442 /* Generate Crypto op data structure */ 1443 ut_params->ol = rte_pktmbuf_offload_alloc(ts_params->mbuf_ol_pool, 1444 RTE_PKTMBUF_OL_CRYPTO); 1445 TEST_ASSERT_NOT_NULL(ut_params->ol, 1446 "Failed to allocate pktmbuf offload"); 1447 1448 ut_params->op = &ut_params->ol->op.crypto; 1449 1450 1451 /* Set crypto operation data parameters */ 1452 rte_crypto_op_attach_session(ut_params->op, sess); 1453 1454 ut_params->op->digest.data = ut_params->digest; 1455 ut_params->op->digest.phys_addr = rte_pktmbuf_mtophys_offset( 1456 ut_params->ibuf, QUOTE_512_BYTES); 1457 ut_params->op->digest.length = DIGEST_BYTE_LENGTH_SHA512; 1458 1459 ut_params->op->iv.data = (uint8_t *)rte_pktmbuf_prepend( 1460 ut_params->ibuf, CIPHER_IV_LENGTH_AES_CBC); 1461 ut_params->op->iv.phys_addr = rte_pktmbuf_mtophys_offset( 1462 ut_params->ibuf, 0); 1463 ut_params->op->iv.length = CIPHER_IV_LENGTH_AES_CBC; 1464 1465 rte_memcpy(ut_params->op->iv.data, aes_cbc_iv, 1466 CIPHER_IV_LENGTH_AES_CBC); 1467 1468 ut_params->op->data.to_cipher.offset = CIPHER_IV_LENGTH_AES_CBC; 1469 ut_params->op->data.to_cipher.length = QUOTE_512_BYTES; 1470 1471 ut_params->op->data.to_hash.offset = CIPHER_IV_LENGTH_AES_CBC; 1472 ut_params->op->data.to_hash.length = QUOTE_512_BYTES; 1473 1474 rte_pktmbuf_offload_attach(ut_params->ibuf, ut_params->ol); 1475 1476 /* Process crypto operation */ 1477 ut_params->obuf = process_crypto_request(ts_params->valid_devs[0], 1478 ut_params->ibuf); 1479 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf"); 1480 1481 /* Validate obuf */ 1482 TEST_ASSERT_BUFFERS_ARE_EQUAL( 1483 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + 1484 CIPHER_IV_LENGTH_AES_CBC, catch_22_quote, 1485 QUOTE_512_BYTES, 1486 "Plaintext data not as expected"); 1487 1488 /* Validate obuf */ 1489 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 1490 "Digest verification failed"); 1491 1492 1493 1494 return TEST_SUCCESS; 1495 } 1496 1497 /* ***** AES-CBC / HMAC-AES_XCBC Chain Tests ***** */ 1498 1499 static uint8_t aes_cbc_hmac_aes_xcbc_key[] = { 1500 0x87, 0x61, 0x54, 0x53, 0xC4, 0x6D, 0xDD, 0x51, 1501 0xE1, 0x9F, 0x86, 0x64, 0x39, 0x0A, 0xE6, 0x59 1502 }; 1503 1504 static const uint8_t catch_22_quote_2_512_bytes_HMAC_AES_XCBC_digest[] = { 1505 0xE0, 0xAC, 0x9A, 0xC4, 0x22, 0x64, 0x35, 0x89, 1506 0x77, 0x1D, 0x8B, 0x75 1507 }; 1508 1509 static int 1510 test_AES_CBC_HMAC_AES_XCBC_encrypt_digest(void) 1511 { 1512 struct crypto_testsuite_params *ts_params = &testsuite_params; 1513 struct crypto_unittest_params *ut_params = &unittest_params; 1514 1515 /* Generate test mbuf data and space for digest */ 1516 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool, 1517 catch_22_quote, QUOTE_512_BYTES, 0); 1518 1519 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 1520 DIGEST_BYTE_LENGTH_AES_XCBC); 1521 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest"); 1522 1523 /* Setup Cipher Parameters */ 1524 ut_params->cipher_xform.type = RTE_CRYPTO_XFORM_CIPHER; 1525 ut_params->cipher_xform.next = &ut_params->auth_xform; 1526 1527 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC; 1528 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; 1529 ut_params->cipher_xform.cipher.key.data = aes_cbc_key; 1530 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC; 1531 1532 /* Setup HMAC Parameters */ 1533 ut_params->auth_xform.type = RTE_CRYPTO_XFORM_AUTH; 1534 ut_params->auth_xform.next = NULL; 1535 1536 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; 1537 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_XCBC_MAC; 1538 ut_params->auth_xform.auth.key.length = AES_XCBC_MAC_KEY_SZ; 1539 ut_params->auth_xform.auth.key.data = aes_cbc_hmac_aes_xcbc_key; 1540 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_AES_XCBC; 1541 1542 /* Create Crypto session*/ 1543 ut_params->sess = rte_cryptodev_session_create(ts_params->valid_devs[0], 1544 &ut_params->cipher_xform); 1545 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 1546 1547 /* Generate Crypto op data structure */ 1548 ut_params->ol = rte_pktmbuf_offload_alloc(ts_params->mbuf_ol_pool, 1549 RTE_PKTMBUF_OL_CRYPTO); 1550 TEST_ASSERT_NOT_NULL(ut_params->ol, 1551 "Failed to allocate pktmbuf offload"); 1552 1553 ut_params->op = &ut_params->ol->op.crypto; 1554 1555 1556 /* Set crypto operation data parameters */ 1557 rte_crypto_op_attach_session(ut_params->op, ut_params->sess); 1558 1559 ut_params->op->iv.data = (uint8_t *) 1560 rte_pktmbuf_prepend(ut_params->ibuf, 1561 CIPHER_IV_LENGTH_AES_CBC); 1562 ut_params->op->iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); 1563 ut_params->op->iv.length = CIPHER_IV_LENGTH_AES_CBC; 1564 1565 rte_memcpy(ut_params->op->iv.data, aes_cbc_iv, 1566 CIPHER_IV_LENGTH_AES_CBC); 1567 1568 ut_params->op->data.to_cipher.offset = CIPHER_IV_LENGTH_AES_CBC; 1569 ut_params->op->data.to_cipher.length = QUOTE_512_BYTES; 1570 ut_params->op->data.to_hash.offset = CIPHER_IV_LENGTH_AES_CBC; 1571 ut_params->op->data.to_hash.length = QUOTE_512_BYTES; 1572 1573 rte_pktmbuf_offload_attach(ut_params->ibuf, ut_params->ol); 1574 1575 /* Process crypto operation */ 1576 ut_params->obuf = process_crypto_request(ts_params->valid_devs[0], 1577 ut_params->ibuf); 1578 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf"); 1579 1580 /* Validate obuf */ 1581 TEST_ASSERT_BUFFERS_ARE_EQUAL( 1582 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + 1583 CIPHER_IV_LENGTH_AES_CBC, 1584 catch_22_quote_2_512_bytes_AES_CBC_ciphertext, 1585 QUOTE_512_BYTES, 1586 "Ciphertext data not as expected"); 1587 TEST_ASSERT_BUFFERS_ARE_EQUAL( 1588 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + 1589 CIPHER_IV_LENGTH_AES_CBC + QUOTE_512_BYTES, 1590 catch_22_quote_2_512_bytes_HMAC_AES_XCBC_digest, 1591 DIGEST_BYTE_LENGTH_AES_XCBC, 1592 "Generated digest data not as expected"); 1593 1594 return TEST_SUCCESS; 1595 } 1596 1597 static int 1598 test_AES_CBC_HMAC_AES_XCBC_decrypt_digest_verify(void) 1599 { 1600 struct crypto_testsuite_params *ts_params = &testsuite_params; 1601 struct crypto_unittest_params *ut_params = &unittest_params; 1602 1603 /* Generate test mbuf data and space for digest */ 1604 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool, 1605 (const char *)catch_22_quote_2_512_bytes_AES_CBC_ciphertext, 1606 QUOTE_512_BYTES, 0); 1607 1608 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 1609 DIGEST_BYTE_LENGTH_AES_XCBC); 1610 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest"); 1611 1612 rte_memcpy(ut_params->digest, 1613 catch_22_quote_2_512_bytes_HMAC_AES_XCBC_digest, 1614 DIGEST_BYTE_LENGTH_AES_XCBC); 1615 1616 /* Setup Cipher Parameters */ 1617 ut_params->cipher_xform.type = RTE_CRYPTO_XFORM_CIPHER; 1618 ut_params->cipher_xform.next = NULL; 1619 1620 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC; 1621 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT; 1622 ut_params->cipher_xform.cipher.key.data = aes_cbc_key; 1623 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC; 1624 1625 /* Setup HMAC Parameters */ 1626 ut_params->auth_xform.type = RTE_CRYPTO_XFORM_AUTH; 1627 ut_params->auth_xform.next = &ut_params->cipher_xform; 1628 1629 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY; 1630 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_XCBC_MAC; 1631 ut_params->auth_xform.auth.key.length = AES_XCBC_MAC_KEY_SZ; 1632 ut_params->auth_xform.auth.key.data = aes_cbc_hmac_aes_xcbc_key; 1633 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_AES_XCBC; 1634 1635 /* Create Crypto session*/ 1636 ut_params->sess = rte_cryptodev_session_create(ts_params->valid_devs[0], 1637 &ut_params->auth_xform); 1638 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 1639 1640 /* Generate Crypto op data structure */ 1641 ut_params->ol = rte_pktmbuf_offload_alloc(ts_params->mbuf_ol_pool, 1642 RTE_PKTMBUF_OL_CRYPTO); 1643 TEST_ASSERT_NOT_NULL(ut_params->ol, 1644 "Failed to allocate pktmbuf offload"); 1645 1646 ut_params->op = &ut_params->ol->op.crypto; 1647 1648 1649 /* Set crypto operation data parameters */ 1650 rte_crypto_op_attach_session(ut_params->op, ut_params->sess); 1651 1652 ut_params->op->iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf, 1653 CIPHER_IV_LENGTH_AES_CBC); 1654 ut_params->op->iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); 1655 ut_params->op->iv.length = CIPHER_IV_LENGTH_AES_CBC; 1656 1657 rte_memcpy(ut_params->op->iv.data, aes_cbc_iv, 1658 CIPHER_IV_LENGTH_AES_CBC); 1659 1660 ut_params->op->data.to_cipher.offset = CIPHER_IV_LENGTH_AES_CBC; 1661 ut_params->op->data.to_cipher.length = QUOTE_512_BYTES; 1662 ut_params->op->data.to_hash.offset = CIPHER_IV_LENGTH_AES_CBC; 1663 ut_params->op->data.to_hash.length = QUOTE_512_BYTES; 1664 rte_pktmbuf_offload_attach(ut_params->ibuf, ut_params->ol); 1665 1666 /* Process crypto operation */ 1667 ut_params->obuf = process_crypto_request(ts_params->valid_devs[0], 1668 ut_params->ibuf); 1669 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf"); 1670 1671 /* Validate obuf */ 1672 TEST_ASSERT_BUFFERS_ARE_EQUAL( 1673 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + 1674 CIPHER_IV_LENGTH_AES_CBC, catch_22_quote, 1675 QUOTE_512_BYTES, 1676 "Ciphertext data not as expected"); 1677 1678 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 1679 "Digest verification failed"); 1680 1681 return TEST_SUCCESS; 1682 } 1683 1684 1685 /* ***** AES-GCM Tests ***** */ 1686 1687 static int 1688 test_stats(void) 1689 { 1690 struct crypto_testsuite_params *ts_params = &testsuite_params; 1691 struct rte_cryptodev_stats stats; 1692 struct rte_cryptodev *dev; 1693 cryptodev_stats_get_t temp_pfn; 1694 1695 rte_cryptodev_stats_reset(ts_params->valid_devs[0]); 1696 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600, 1697 &stats) == -ENODEV), 1698 "rte_cryptodev_stats_get invalid dev failed"); 1699 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0), 1700 "rte_cryptodev_stats_get invalid Param failed"); 1701 dev = &rte_cryptodevs[ts_params->valid_devs[0]]; 1702 temp_pfn = dev->dev_ops->stats_get; 1703 dev->dev_ops->stats_get = (cryptodev_stats_get_t)0; 1704 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats) 1705 == -ENOTSUP), 1706 "rte_cryptodev_stats_get invalid Param failed"); 1707 dev->dev_ops->stats_get = temp_pfn; 1708 1709 /* Test expected values */ 1710 ut_setup(); 1711 test_AES_CBC_HMAC_SHA1_encrypt_digest(); 1712 ut_teardown(); 1713 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0], 1714 &stats), 1715 "rte_cryptodev_stats_get failed"); 1716 TEST_ASSERT((stats.enqueued_count == 1), 1717 "rte_cryptodev_stats_get returned unexpected enqueued stat"); 1718 TEST_ASSERT((stats.dequeued_count == 1), 1719 "rte_cryptodev_stats_get returned unexpected enqueued stat"); 1720 TEST_ASSERT((stats.enqueue_err_count == 0), 1721 "rte_cryptodev_stats_get returned unexpected enqueued stat"); 1722 TEST_ASSERT((stats.dequeue_err_count == 0), 1723 "rte_cryptodev_stats_get returned unexpected enqueued stat"); 1724 1725 /* invalid device but should ignore and not reset device stats*/ 1726 rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300); 1727 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0], 1728 &stats), 1729 "rte_cryptodev_stats_get failed"); 1730 TEST_ASSERT((stats.enqueued_count == 1), 1731 "rte_cryptodev_stats_get returned unexpected enqueued stat"); 1732 1733 /* check that a valid reset clears stats */ 1734 rte_cryptodev_stats_reset(ts_params->valid_devs[0]); 1735 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0], 1736 &stats), 1737 "rte_cryptodev_stats_get failed"); 1738 TEST_ASSERT((stats.enqueued_count == 0), 1739 "rte_cryptodev_stats_get returned unexpected enqueued stat"); 1740 TEST_ASSERT((stats.dequeued_count == 0), 1741 "rte_cryptodev_stats_get returned unexpected enqueued stat"); 1742 1743 return TEST_SUCCESS; 1744 } 1745 1746 1747 static int 1748 test_multi_session(void) 1749 { 1750 struct crypto_testsuite_params *ts_params = &testsuite_params; 1751 struct crypto_unittest_params *ut_params = &unittest_params; 1752 1753 struct rte_cryptodev_info dev_info; 1754 struct rte_cryptodev_session **sessions; 1755 1756 uint16_t i; 1757 1758 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params); 1759 1760 1761 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 1762 1763 sessions = rte_malloc(NULL, (sizeof(struct rte_cryptodev_session *) * 1764 dev_info.max_nb_sessions) + 1, 0); 1765 1766 /* Create multiple crypto sessions*/ 1767 for (i = 0; i < dev_info.max_nb_sessions; i++) { 1768 sessions[i] = rte_cryptodev_session_create( 1769 ts_params->valid_devs[0], 1770 &ut_params->auth_xform); 1771 TEST_ASSERT_NOT_NULL(sessions[i], 1772 "Session creation failed at session number %u", 1773 i); 1774 1775 /* Attempt to send a request on each session */ 1776 TEST_ASSERT_SUCCESS(test_AES_CBC_HMAC_SHA512_decrypt_perform( 1777 sessions[i], ut_params, ts_params), 1778 "Failed to perform decrypt on request " 1779 "number %u.", i); 1780 } 1781 1782 /* Next session create should fail */ 1783 sessions[i] = rte_cryptodev_session_create(ts_params->valid_devs[0], 1784 &ut_params->auth_xform); 1785 TEST_ASSERT_NULL(sessions[i], 1786 "Session creation succeeded unexpectedly!"); 1787 1788 for (i = 0; i < dev_info.max_nb_sessions; i++) 1789 rte_cryptodev_session_free(ts_params->valid_devs[0], 1790 sessions[i]); 1791 1792 rte_free(sessions); 1793 1794 return TEST_SUCCESS; 1795 } 1796 1797 static int 1798 test_not_in_place_crypto(void) 1799 { 1800 struct crypto_testsuite_params *ts_params = &testsuite_params; 1801 struct crypto_unittest_params *ut_params = &unittest_params; 1802 struct rte_mbuf *dst_m = rte_pktmbuf_alloc(ts_params->mbuf_pool); 1803 1804 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params); 1805 1806 /* Create multiple crypto sessions*/ 1807 1808 ut_params->sess = rte_cryptodev_session_create( 1809 ts_params->valid_devs[0], &ut_params->auth_xform); 1810 1811 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 1812 1813 1814 /* Generate test mbuf data and digest */ 1815 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool, 1816 (const char *) 1817 catch_22_quote_2_512_bytes_AES_CBC_ciphertext, 1818 QUOTE_512_BYTES, 0); 1819 1820 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 1821 DIGEST_BYTE_LENGTH_SHA512); 1822 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest"); 1823 1824 rte_memcpy(ut_params->digest, 1825 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest, 1826 DIGEST_BYTE_LENGTH_SHA512); 1827 1828 /* Generate Crypto op data structure */ 1829 ut_params->ol = rte_pktmbuf_offload_alloc(ts_params->mbuf_ol_pool, 1830 RTE_PKTMBUF_OL_CRYPTO); 1831 TEST_ASSERT_NOT_NULL(ut_params->ol, 1832 "Failed to allocate pktmbuf offload"); 1833 1834 ut_params->op = &ut_params->ol->op.crypto; 1835 1836 1837 /* Set crypto operation data parameters */ 1838 rte_crypto_op_attach_session(ut_params->op, ut_params->sess); 1839 1840 ut_params->op->digest.data = ut_params->digest; 1841 ut_params->op->digest.phys_addr = rte_pktmbuf_mtophys_offset( 1842 ut_params->ibuf, QUOTE_512_BYTES); 1843 ut_params->op->digest.length = DIGEST_BYTE_LENGTH_SHA512; 1844 1845 ut_params->op->iv.data = (uint8_t *)rte_pktmbuf_prepend( 1846 ut_params->ibuf, CIPHER_IV_LENGTH_AES_CBC); 1847 ut_params->op->iv.phys_addr = rte_pktmbuf_mtophys_offset( 1848 ut_params->ibuf, 0); 1849 ut_params->op->iv.length = CIPHER_IV_LENGTH_AES_CBC; 1850 1851 rte_memcpy(ut_params->op->iv.data, aes_cbc_iv, 1852 CIPHER_IV_LENGTH_AES_CBC); 1853 1854 ut_params->op->data.to_cipher.offset = CIPHER_IV_LENGTH_AES_CBC; 1855 ut_params->op->data.to_cipher.length = QUOTE_512_BYTES; 1856 1857 ut_params->op->data.to_hash.offset = CIPHER_IV_LENGTH_AES_CBC; 1858 ut_params->op->data.to_hash.length = QUOTE_512_BYTES; 1859 1860 ut_params->op->dst.m = dst_m; 1861 ut_params->op->dst.offset = 0; 1862 1863 rte_pktmbuf_offload_attach(ut_params->ibuf, ut_params->ol); 1864 1865 /* Process crypto operation */ 1866 ut_params->obuf = process_crypto_request(ts_params->valid_devs[0], 1867 ut_params->ibuf); 1868 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf"); 1869 1870 /* Validate obuf */ 1871 TEST_ASSERT_BUFFERS_ARE_EQUAL( 1872 rte_pktmbuf_mtod(ut_params->op->dst.m, char *), 1873 catch_22_quote, 1874 QUOTE_512_BYTES, 1875 "Plaintext data not as expected"); 1876 1877 /* Validate obuf */ 1878 1879 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 1880 "Digest verification failed"); 1881 1882 return TEST_SUCCESS; 1883 } 1884 1885 1886 static struct unit_test_suite cryptodev_qat_testsuite = { 1887 .suite_name = "Crypto QAT Unit Test Suite", 1888 .setup = testsuite_setup, 1889 .teardown = testsuite_teardown, 1890 .unit_test_cases = { 1891 TEST_CASE_ST(ut_setup, ut_teardown, 1892 test_device_configure_invalid_dev_id), 1893 TEST_CASE_ST(ut_setup, ut_teardown, 1894 test_device_configure_invalid_queue_pair_ids), 1895 TEST_CASE_ST(ut_setup, ut_teardown, 1896 test_queue_pair_descriptor_setup), 1897 TEST_CASE_ST(ut_setup, ut_teardown, 1898 test_multi_session), 1899 1900 TEST_CASE_ST(ut_setup, ut_teardown, 1901 test_AES_CBC_HMAC_SHA1_encrypt_digest), 1902 TEST_CASE_ST(ut_setup, ut_teardown, 1903 test_AES_CBC_HMAC_SHA1_decrypt_digest_verify), 1904 1905 TEST_CASE_ST(ut_setup, ut_teardown, 1906 test_AES_CBC_HMAC_SHA256_encrypt_digest), 1907 TEST_CASE_ST(ut_setup, ut_teardown, 1908 test_AES_CBC_HMAC_SHA256_decrypt_digest_verify), 1909 1910 TEST_CASE_ST(ut_setup, ut_teardown, 1911 test_AES_CBC_HMAC_SHA512_encrypt_digest), 1912 TEST_CASE_ST(ut_setup, ut_teardown, 1913 test_AES_CBC_HMAC_SHA512_decrypt_digest_verify), 1914 1915 TEST_CASE_ST(ut_setup, ut_teardown, 1916 test_AES_CBC_HMAC_AES_XCBC_encrypt_digest), 1917 TEST_CASE_ST(ut_setup, ut_teardown, 1918 test_AES_CBC_HMAC_AES_XCBC_decrypt_digest_verify), 1919 1920 TEST_CASE_ST(ut_setup, ut_teardown, test_stats), 1921 1922 TEST_CASES_END() /**< NULL terminate unit test array */ 1923 } 1924 }; 1925 1926 static struct unit_test_suite cryptodev_aesni_mb_testsuite = { 1927 .suite_name = "Crypto Device AESNI MB Unit Test Suite", 1928 .setup = testsuite_setup, 1929 .teardown = testsuite_teardown, 1930 .unit_test_cases = { 1931 TEST_CASE_ST(ut_setup, ut_teardown, 1932 test_AES_CBC_HMAC_SHA1_encrypt_digest), 1933 TEST_CASE_ST(ut_setup, ut_teardown, 1934 test_AES_CBC_HMAC_SHA1_decrypt_digest_verify), 1935 1936 TEST_CASE_ST(ut_setup, ut_teardown, 1937 test_AES_CBC_HMAC_SHA256_encrypt_digest), 1938 TEST_CASE_ST(ut_setup, ut_teardown, 1939 test_AES_CBC_HMAC_SHA256_decrypt_digest_verify), 1940 1941 TEST_CASE_ST(ut_setup, ut_teardown, 1942 test_AES_CBC_HMAC_SHA512_encrypt_digest), 1943 TEST_CASE_ST(ut_setup, ut_teardown, 1944 test_AES_CBC_HMAC_SHA512_decrypt_digest_verify), 1945 1946 TEST_CASE_ST(ut_setup, ut_teardown, 1947 test_AES_CBC_HMAC_AES_XCBC_encrypt_digest), 1948 TEST_CASE_ST(ut_setup, ut_teardown, 1949 test_AES_CBC_HMAC_AES_XCBC_decrypt_digest_verify), 1950 1951 TEST_CASE_ST(ut_setup, ut_teardown, 1952 test_AES_CBC_HMAC_SHA1_encrypt_digest_sessionless), 1953 1954 TEST_CASE_ST(ut_setup, ut_teardown, 1955 test_not_in_place_crypto), 1956 1957 TEST_CASES_END() /**< NULL terminate unit test array */ 1958 } 1959 }; 1960 1961 static int 1962 test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/) 1963 { 1964 gbl_cryptodev_type = RTE_CRYPTODEV_QAT_PMD; 1965 return unit_test_suite_runner(&cryptodev_qat_testsuite); 1966 } 1967 static struct test_command cryptodev_qat_cmd = { 1968 .command = "cryptodev_qat_autotest", 1969 .callback = test_cryptodev_qat, 1970 }; 1971 1972 static int 1973 test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/) 1974 { 1975 gbl_cryptodev_type = RTE_CRYPTODEV_AESNI_MB_PMD; 1976 1977 return unit_test_suite_runner(&cryptodev_aesni_mb_testsuite); 1978 } 1979 1980 static struct test_command cryptodev_aesni_mb_cmd = { 1981 .command = "cryptodev_aesni_mb_autotest", 1982 .callback = test_cryptodev_aesni_mb, 1983 }; 1984 1985 REGISTER_TEST_COMMAND(cryptodev_qat_cmd); 1986 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_cmd); 1987