1 /*- 2 * BSD LICENSE 3 * 4 * Copyright(c) 2015-2016 Intel Corporation. All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 10 * * Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * * Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in 14 * the documentation and/or other materials provided with the 15 * distribution. 16 * * Neither the name of Intel Corporation nor the names of its 17 * contributors may be used to endorse or promote products derived 18 * from this software without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 23 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 24 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 25 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 26 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 30 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 #include <rte_common.h> 34 #include <rte_hexdump.h> 35 #include <rte_mbuf.h> 36 #include <rte_malloc.h> 37 #include <rte_memcpy.h> 38 39 #include <rte_crypto.h> 40 #include <rte_cryptodev.h> 41 #include <rte_cryptodev_pmd.h> 42 43 #include "test.h" 44 #include "test_cryptodev.h" 45 46 #include "test_cryptodev_aes.h" 47 #include "test_cryptodev_kasumi_test_vectors.h" 48 #include "test_cryptodev_kasumi_hash_test_vectors.h" 49 #include "test_cryptodev_snow3g_test_vectors.h" 50 #include "test_cryptodev_snow3g_hash_test_vectors.h" 51 #include "test_cryptodev_gcm_test_vectors.h" 52 53 static enum rte_cryptodev_type gbl_cryptodev_type; 54 55 struct crypto_testsuite_params { 56 struct rte_mempool *mbuf_pool; 57 struct rte_mempool *op_mpool; 58 struct rte_cryptodev_config conf; 59 struct rte_cryptodev_qp_conf qp_conf; 60 61 uint8_t valid_devs[RTE_CRYPTO_MAX_DEVS]; 62 uint8_t valid_dev_count; 63 }; 64 65 struct crypto_unittest_params { 66 struct rte_crypto_sym_xform cipher_xform; 67 struct rte_crypto_sym_xform auth_xform; 68 69 struct rte_cryptodev_sym_session *sess; 70 71 struct rte_crypto_op *op; 72 73 struct rte_mbuf *obuf, *ibuf; 74 75 uint8_t *digest; 76 }; 77 78 #define ALIGN_POW2_ROUNDUP(num, align) \ 79 (((num) + (align) - 1) & ~((align) - 1)) 80 81 /* 82 * Forward declarations. 83 */ 84 static int 85 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params( 86 struct crypto_unittest_params *ut_params); 87 88 static int 89 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess, 90 struct crypto_unittest_params *ut_params, 91 struct crypto_testsuite_params *ts_param); 92 93 static struct rte_mbuf * 94 setup_test_string(struct rte_mempool *mpool, 95 const char *string, size_t len, uint8_t blocksize) 96 { 97 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool); 98 size_t t_len = len - (blocksize ? (len % blocksize) : 0); 99 100 memset(m->buf_addr, 0, m->buf_len); 101 if (m) { 102 char *dst = rte_pktmbuf_append(m, t_len); 103 104 if (!dst) { 105 rte_pktmbuf_free(m); 106 return NULL; 107 } 108 if (string != NULL) 109 rte_memcpy(dst, string, t_len); 110 else 111 memset(dst, 0, t_len); 112 } 113 114 return m; 115 } 116 117 /* Get number of bytes in X bits (rounding up) */ 118 static uint32_t 119 ceil_byte_length(uint32_t num_bits) 120 { 121 if (num_bits % 8) 122 return ((num_bits >> 3) + 1); 123 else 124 return (num_bits >> 3); 125 } 126 127 static struct rte_crypto_op * 128 process_crypto_request(uint8_t dev_id, struct rte_crypto_op *op) 129 { 130 if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) { 131 printf("Error sending packet for encryption"); 132 return NULL; 133 } 134 135 op = NULL; 136 137 while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0) 138 rte_pause(); 139 140 return op; 141 } 142 143 static struct crypto_testsuite_params testsuite_params = { NULL }; 144 static struct crypto_unittest_params unittest_params; 145 146 static int 147 testsuite_setup(void) 148 { 149 struct crypto_testsuite_params *ts_params = &testsuite_params; 150 struct rte_cryptodev_info info; 151 unsigned i, nb_devs, dev_id; 152 int ret; 153 uint16_t qp_id; 154 155 memset(ts_params, 0, sizeof(*ts_params)); 156 157 ts_params->mbuf_pool = rte_mempool_lookup("CRYPTO_MBUFPOOL"); 158 if (ts_params->mbuf_pool == NULL) { 159 /* Not already created so create */ 160 ts_params->mbuf_pool = rte_pktmbuf_pool_create( 161 "CRYPTO_MBUFPOOL", 162 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE, 163 rte_socket_id()); 164 if (ts_params->mbuf_pool == NULL) { 165 RTE_LOG(ERR, USER1, "Can't create CRYPTO_MBUFPOOL\n"); 166 return TEST_FAILED; 167 } 168 } 169 170 ts_params->op_mpool = rte_crypto_op_pool_create( 171 "MBUF_CRYPTO_SYM_OP_POOL", 172 RTE_CRYPTO_OP_TYPE_SYMMETRIC, 173 NUM_MBUFS, MBUF_CACHE_SIZE, 174 DEFAULT_NUM_XFORMS * 175 sizeof(struct rte_crypto_sym_xform), 176 rte_socket_id()); 177 if (ts_params->op_mpool == NULL) { 178 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n"); 179 return TEST_FAILED; 180 } 181 182 /* Create 2 AESNI MB devices if required */ 183 if (gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD) { 184 nb_devs = rte_cryptodev_count_devtype( 185 RTE_CRYPTODEV_AESNI_MB_PMD); 186 if (nb_devs < 2) { 187 for (i = nb_devs; i < 2; i++) { 188 ret = rte_eal_vdev_init( 189 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL); 190 191 TEST_ASSERT(ret == 0, 192 "Failed to create instance %u of" 193 " pmd : %s", 194 i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)); 195 } 196 } 197 } 198 199 /* Create 2 AESNI GCM devices if required */ 200 if (gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_GCM_PMD) { 201 nb_devs = rte_cryptodev_count_devtype( 202 RTE_CRYPTODEV_AESNI_GCM_PMD); 203 if (nb_devs < 2) { 204 for (i = nb_devs; i < 2; i++) { 205 TEST_ASSERT_SUCCESS(rte_eal_vdev_init( 206 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD), NULL), 207 "Failed to create instance %u of" 208 " pmd : %s", 209 i, RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD)); 210 } 211 } 212 } 213 214 /* Create 2 Snow3G devices if required */ 215 if (gbl_cryptodev_type == RTE_CRYPTODEV_SNOW3G_PMD) { 216 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_SNOW3G_PMD); 217 if (nb_devs < 2) { 218 for (i = nb_devs; i < 2; i++) { 219 TEST_ASSERT_SUCCESS(rte_eal_vdev_init( 220 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD), NULL), 221 "Failed to create instance %u of" 222 " pmd : %s", 223 i, RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD)); 224 } 225 } 226 } 227 228 /* Create 2 KASUMI devices if required */ 229 if (gbl_cryptodev_type == RTE_CRYPTODEV_KASUMI_PMD) { 230 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_KASUMI_PMD); 231 if (nb_devs < 2) { 232 for (i = nb_devs; i < 2; i++) { 233 TEST_ASSERT_SUCCESS(rte_eal_vdev_init( 234 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD), NULL), 235 "Failed to create instance %u of" 236 " pmd : %s", 237 i, RTE_STR(CRYPTODEV_NAME_KASUMI_PMD)); 238 } 239 } 240 } 241 242 /* Create 2 NULL devices if required */ 243 if (gbl_cryptodev_type == RTE_CRYPTODEV_NULL_PMD) { 244 nb_devs = rte_cryptodev_count_devtype( 245 RTE_CRYPTODEV_NULL_PMD); 246 if (nb_devs < 2) { 247 for (i = nb_devs; i < 2; i++) { 248 int dev_id = rte_eal_vdev_init( 249 RTE_STR(CRYPTODEV_NAME_NULL_PMD), NULL); 250 251 TEST_ASSERT(dev_id >= 0, 252 "Failed to create instance %u of" 253 " pmd : %s", 254 i, RTE_STR(CRYPTODEV_NAME_NULL_PMD)); 255 } 256 } 257 } 258 259 nb_devs = rte_cryptodev_count(); 260 if (nb_devs < 1) { 261 RTE_LOG(ERR, USER1, "No crypto devices found?"); 262 return TEST_FAILED; 263 } 264 265 /* Create list of valid crypto devs */ 266 for (i = 0; i < nb_devs; i++) { 267 rte_cryptodev_info_get(i, &info); 268 if (info.dev_type == gbl_cryptodev_type) 269 ts_params->valid_devs[ts_params->valid_dev_count++] = i; 270 } 271 272 if (ts_params->valid_dev_count < 1) 273 return TEST_FAILED; 274 275 /* Set up all the qps on the first of the valid devices found */ 276 for (i = 0; i < 1; i++) { 277 dev_id = ts_params->valid_devs[i]; 278 279 rte_cryptodev_info_get(dev_id, &info); 280 281 /* 282 * Since we can't free and re-allocate queue memory always set 283 * the queues on this device up to max size first so enough 284 * memory is allocated for any later re-configures needed by 285 * other tests 286 */ 287 288 ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs; 289 ts_params->conf.socket_id = SOCKET_ID_ANY; 290 ts_params->conf.session_mp.nb_objs = info.sym.max_nb_sessions; 291 292 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, 293 &ts_params->conf), 294 "Failed to configure cryptodev %u with %u qps", 295 dev_id, ts_params->conf.nb_queue_pairs); 296 297 ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; 298 299 for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) { 300 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( 301 dev_id, qp_id, &ts_params->qp_conf, 302 rte_cryptodev_socket_id(dev_id)), 303 "Failed to setup queue pair %u on " 304 "cryptodev %u", 305 qp_id, dev_id); 306 } 307 } 308 309 return TEST_SUCCESS; 310 } 311 312 static void 313 testsuite_teardown(void) 314 { 315 struct crypto_testsuite_params *ts_params = &testsuite_params; 316 317 if (ts_params->mbuf_pool != NULL) { 318 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n", 319 rte_mempool_avail_count(ts_params->mbuf_pool)); 320 } 321 322 if (ts_params->op_mpool != NULL) { 323 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n", 324 rte_mempool_avail_count(ts_params->op_mpool)); 325 } 326 327 } 328 329 static int 330 ut_setup(void) 331 { 332 struct crypto_testsuite_params *ts_params = &testsuite_params; 333 struct crypto_unittest_params *ut_params = &unittest_params; 334 335 uint16_t qp_id; 336 337 /* Clear unit test parameters before running test */ 338 memset(ut_params, 0, sizeof(*ut_params)); 339 340 /* Reconfigure device to default parameters */ 341 ts_params->conf.nb_queue_pairs = DEFAULT_NUM_QPS_PER_QAT_DEVICE; 342 ts_params->conf.socket_id = SOCKET_ID_ANY; 343 ts_params->conf.session_mp.nb_objs = 344 (gbl_cryptodev_type == RTE_CRYPTODEV_QAT_SYM_PMD) ? 345 DEFAULT_NUM_OPS_INFLIGHT : 346 DEFAULT_NUM_OPS_INFLIGHT; 347 348 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0], 349 &ts_params->conf), 350 "Failed to configure cryptodev %u", 351 ts_params->valid_devs[0]); 352 353 /* 354 * Now reconfigure queues to size we actually want to use in this 355 * test suite. 356 */ 357 ts_params->qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT; 358 359 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) { 360 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( 361 ts_params->valid_devs[0], qp_id, 362 &ts_params->qp_conf, 363 rte_cryptodev_socket_id(ts_params->valid_devs[0])), 364 "Failed to setup queue pair %u on cryptodev %u", 365 qp_id, ts_params->valid_devs[0]); 366 } 367 368 369 rte_cryptodev_stats_reset(ts_params->valid_devs[0]); 370 371 /* Start the device */ 372 TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]), 373 "Failed to start cryptodev %u", 374 ts_params->valid_devs[0]); 375 376 return TEST_SUCCESS; 377 } 378 379 static void 380 ut_teardown(void) 381 { 382 struct crypto_testsuite_params *ts_params = &testsuite_params; 383 struct crypto_unittest_params *ut_params = &unittest_params; 384 struct rte_cryptodev_stats stats; 385 386 /* free crypto session structure */ 387 if (ut_params->sess) { 388 rte_cryptodev_sym_session_free(ts_params->valid_devs[0], 389 ut_params->sess); 390 ut_params->sess = NULL; 391 } 392 393 /* free crypto operation structure */ 394 if (ut_params->op) 395 rte_crypto_op_free(ut_params->op); 396 397 /* 398 * free mbuf - both obuf and ibuf are usually the same, 399 * so check if they point at the same address is necessary, 400 * to avoid freeing the mbuf twice. 401 */ 402 if (ut_params->obuf) { 403 rte_pktmbuf_free(ut_params->obuf); 404 if (ut_params->ibuf == ut_params->obuf) 405 ut_params->ibuf = 0; 406 ut_params->obuf = 0; 407 } 408 if (ut_params->ibuf) { 409 rte_pktmbuf_free(ut_params->ibuf); 410 ut_params->ibuf = 0; 411 } 412 413 if (ts_params->mbuf_pool != NULL) 414 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n", 415 rte_mempool_avail_count(ts_params->mbuf_pool)); 416 417 rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats); 418 419 /* Stop the device */ 420 rte_cryptodev_stop(ts_params->valid_devs[0]); 421 } 422 423 static int 424 test_device_configure_invalid_dev_id(void) 425 { 426 struct crypto_testsuite_params *ts_params = &testsuite_params; 427 uint16_t dev_id, num_devs = 0; 428 429 TEST_ASSERT((num_devs = rte_cryptodev_count()) >= 1, 430 "Need at least %d devices for test", 1); 431 432 /* valid dev_id values */ 433 dev_id = ts_params->valid_devs[ts_params->valid_dev_count - 1]; 434 435 /* Stop the device in case it's started so it can be configured */ 436 rte_cryptodev_stop(ts_params->valid_devs[dev_id]); 437 438 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf), 439 "Failed test for rte_cryptodev_configure: " 440 "invalid dev_num %u", dev_id); 441 442 /* invalid dev_id values */ 443 dev_id = num_devs; 444 445 TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf), 446 "Failed test for rte_cryptodev_configure: " 447 "invalid dev_num %u", dev_id); 448 449 dev_id = 0xff; 450 451 TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf), 452 "Failed test for rte_cryptodev_configure:" 453 "invalid dev_num %u", dev_id); 454 455 return TEST_SUCCESS; 456 } 457 458 static int 459 test_device_configure_invalid_queue_pair_ids(void) 460 { 461 struct crypto_testsuite_params *ts_params = &testsuite_params; 462 463 /* Stop the device in case it's started so it can be configured */ 464 rte_cryptodev_stop(ts_params->valid_devs[0]); 465 466 /* valid - one queue pairs */ 467 ts_params->conf.nb_queue_pairs = 1; 468 469 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0], 470 &ts_params->conf), 471 "Failed to configure cryptodev: dev_id %u, qp_id %u", 472 ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs); 473 474 475 /* valid - max value queue pairs */ 476 ts_params->conf.nb_queue_pairs = MAX_NUM_QPS_PER_QAT_DEVICE; 477 478 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0], 479 &ts_params->conf), 480 "Failed to configure cryptodev: dev_id %u, qp_id %u", 481 ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs); 482 483 484 /* invalid - zero queue pairs */ 485 ts_params->conf.nb_queue_pairs = 0; 486 487 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0], 488 &ts_params->conf), 489 "Failed test for rte_cryptodev_configure, dev_id %u," 490 " invalid qps: %u", 491 ts_params->valid_devs[0], 492 ts_params->conf.nb_queue_pairs); 493 494 495 /* invalid - max value supported by field queue pairs */ 496 ts_params->conf.nb_queue_pairs = UINT16_MAX; 497 498 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0], 499 &ts_params->conf), 500 "Failed test for rte_cryptodev_configure, dev_id %u," 501 " invalid qps: %u", 502 ts_params->valid_devs[0], 503 ts_params->conf.nb_queue_pairs); 504 505 506 /* invalid - max value + 1 queue pairs */ 507 ts_params->conf.nb_queue_pairs = MAX_NUM_QPS_PER_QAT_DEVICE + 1; 508 509 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0], 510 &ts_params->conf), 511 "Failed test for rte_cryptodev_configure, dev_id %u," 512 " invalid qps: %u", 513 ts_params->valid_devs[0], 514 ts_params->conf.nb_queue_pairs); 515 516 return TEST_SUCCESS; 517 } 518 519 static int 520 test_queue_pair_descriptor_setup(void) 521 { 522 struct crypto_testsuite_params *ts_params = &testsuite_params; 523 struct rte_cryptodev_info dev_info; 524 struct rte_cryptodev_qp_conf qp_conf = { 525 .nb_descriptors = MAX_NUM_OPS_INFLIGHT 526 }; 527 528 uint16_t qp_id; 529 530 /* Stop the device in case it's started so it can be configured */ 531 rte_cryptodev_stop(ts_params->valid_devs[0]); 532 533 534 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 535 536 ts_params->conf.session_mp.nb_objs = dev_info.sym.max_nb_sessions; 537 538 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0], 539 &ts_params->conf), "Failed to configure cryptodev %u", 540 ts_params->valid_devs[0]); 541 542 543 /* 544 * Test various ring sizes on this device. memzones can't be 545 * freed so are re-used if ring is released and re-created. 546 */ 547 qp_conf.nb_descriptors = MIN_NUM_OPS_INFLIGHT; /* min size*/ 548 549 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) { 550 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( 551 ts_params->valid_devs[0], qp_id, &qp_conf, 552 rte_cryptodev_socket_id( 553 ts_params->valid_devs[0])), 554 "Failed test for " 555 "rte_cryptodev_queue_pair_setup: num_inflights " 556 "%u on qp %u on cryptodev %u", 557 qp_conf.nb_descriptors, qp_id, 558 ts_params->valid_devs[0]); 559 } 560 561 qp_conf.nb_descriptors = (uint32_t)(MAX_NUM_OPS_INFLIGHT / 2); 562 563 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) { 564 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( 565 ts_params->valid_devs[0], qp_id, &qp_conf, 566 rte_cryptodev_socket_id( 567 ts_params->valid_devs[0])), 568 "Failed test for" 569 " rte_cryptodev_queue_pair_setup: num_inflights" 570 " %u on qp %u on cryptodev %u", 571 qp_conf.nb_descriptors, qp_id, 572 ts_params->valid_devs[0]); 573 } 574 575 qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; /* valid */ 576 577 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) { 578 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( 579 ts_params->valid_devs[0], qp_id, &qp_conf, 580 rte_cryptodev_socket_id( 581 ts_params->valid_devs[0])), 582 "Failed test for " 583 "rte_cryptodev_queue_pair_setup: num_inflights" 584 " %u on qp %u on cryptodev %u", 585 qp_conf.nb_descriptors, qp_id, 586 ts_params->valid_devs[0]); 587 } 588 589 /* invalid number of descriptors - max supported + 2 */ 590 qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT + 2; 591 592 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) { 593 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup( 594 ts_params->valid_devs[0], qp_id, &qp_conf, 595 rte_cryptodev_socket_id( 596 ts_params->valid_devs[0])), 597 "Unexpectedly passed test for " 598 "rte_cryptodev_queue_pair_setup:" 599 "num_inflights %u on qp %u on cryptodev %u", 600 qp_conf.nb_descriptors, qp_id, 601 ts_params->valid_devs[0]); 602 } 603 604 /* invalid number of descriptors - max value of parameter */ 605 qp_conf.nb_descriptors = UINT32_MAX-1; 606 607 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) { 608 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup( 609 ts_params->valid_devs[0], qp_id, &qp_conf, 610 rte_cryptodev_socket_id( 611 ts_params->valid_devs[0])), 612 "Unexpectedly passed test for " 613 "rte_cryptodev_queue_pair_setup:" 614 "num_inflights %u on qp %u on cryptodev %u", 615 qp_conf.nb_descriptors, qp_id, 616 ts_params->valid_devs[0]); 617 } 618 619 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT; 620 621 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) { 622 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( 623 ts_params->valid_devs[0], qp_id, &qp_conf, 624 rte_cryptodev_socket_id( 625 ts_params->valid_devs[0])), 626 "Failed test for" 627 " rte_cryptodev_queue_pair_setup:" 628 "num_inflights %u on qp %u on cryptodev %u", 629 qp_conf.nb_descriptors, qp_id, 630 ts_params->valid_devs[0]); 631 } 632 633 /* invalid number of descriptors - max supported + 1 */ 634 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT + 1; 635 636 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) { 637 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup( 638 ts_params->valid_devs[0], qp_id, &qp_conf, 639 rte_cryptodev_socket_id( 640 ts_params->valid_devs[0])), 641 "Unexpectedly passed test for " 642 "rte_cryptodev_queue_pair_setup:" 643 "num_inflights %u on qp %u on cryptodev %u", 644 qp_conf.nb_descriptors, qp_id, 645 ts_params->valid_devs[0]); 646 } 647 648 /* test invalid queue pair id */ 649 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT; /*valid */ 650 651 qp_id = DEFAULT_NUM_QPS_PER_QAT_DEVICE; /*invalid */ 652 653 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup( 654 ts_params->valid_devs[0], 655 qp_id, &qp_conf, 656 rte_cryptodev_socket_id(ts_params->valid_devs[0])), 657 "Failed test for rte_cryptodev_queue_pair_setup:" 658 "invalid qp %u on cryptodev %u", 659 qp_id, ts_params->valid_devs[0]); 660 661 qp_id = 0xffff; /*invalid*/ 662 663 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup( 664 ts_params->valid_devs[0], 665 qp_id, &qp_conf, 666 rte_cryptodev_socket_id(ts_params->valid_devs[0])), 667 "Failed test for rte_cryptodev_queue_pair_setup:" 668 "invalid qp %u on cryptodev %u", 669 qp_id, ts_params->valid_devs[0]); 670 671 return TEST_SUCCESS; 672 } 673 674 /* ***** Plaintext data for tests ***** */ 675 676 const char catch_22_quote_1[] = 677 "There was only one catch and that was Catch-22, which " 678 "specified that a concern for one's safety in the face of " 679 "dangers that were real and immediate was the process of a " 680 "rational mind. Orr was crazy and could be grounded. All he " 681 "had to do was ask; and as soon as he did, he would no longer " 682 "be crazy and would have to fly more missions. Orr would be " 683 "crazy to fly more missions and sane if he didn't, but if he " 684 "was sane he had to fly them. If he flew them he was crazy " 685 "and didn't have to; but if he didn't want to he was sane and " 686 "had to. Yossarian was moved very deeply by the absolute " 687 "simplicity of this clause of Catch-22 and let out a " 688 "respectful whistle. \"That's some catch, that Catch-22\", he " 689 "observed. \"It's the best there is,\" Doc Daneeka agreed."; 690 691 const char catch_22_quote[] = 692 "What a lousy earth! He wondered how many people were " 693 "destitute that same night even in his own prosperous country, " 694 "how many homes were shanties, how many husbands were drunk " 695 "and wives socked, and how many children were bullied, abused, " 696 "or abandoned. How many families hungered for food they could " 697 "not afford to buy? How many hearts were broken? How many " 698 "suicides would take place that same night, how many people " 699 "would go insane? How many cockroaches and landlords would " 700 "triumph? How many winners were losers, successes failures, " 701 "and rich men poor men? How many wise guys were stupid? How " 702 "many happy endings were unhappy endings? How many honest men " 703 "were liars, brave men cowards, loyal men traitors, how many " 704 "sainted men were corrupt, how many people in positions of " 705 "trust had sold their souls to bodyguards, how many had never " 706 "had souls? How many straight-and-narrow paths were crooked " 707 "paths? How many best families were worst families and how " 708 "many good people were bad people? When you added them all up " 709 "and then subtracted, you might be left with only the children, " 710 "and perhaps with Albert Einstein and an old violinist or " 711 "sculptor somewhere."; 712 713 #define QUOTE_480_BYTES (480) 714 #define QUOTE_512_BYTES (512) 715 #define QUOTE_768_BYTES (768) 716 #define QUOTE_1024_BYTES (1024) 717 718 719 720 /* ***** SHA1 Hash Tests ***** */ 721 722 #define HMAC_KEY_LENGTH_SHA1 (DIGEST_BYTE_LENGTH_SHA1) 723 724 static uint8_t hmac_sha1_key[] = { 725 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA, 726 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD, 727 0xDE, 0xF4, 0xDE, 0xAD }; 728 729 /* ***** SHA224 Hash Tests ***** */ 730 731 #define HMAC_KEY_LENGTH_SHA224 (DIGEST_BYTE_LENGTH_SHA224) 732 733 734 /* ***** AES-CBC Cipher Tests ***** */ 735 736 #define CIPHER_KEY_LENGTH_AES_CBC (16) 737 #define CIPHER_IV_LENGTH_AES_CBC (CIPHER_KEY_LENGTH_AES_CBC) 738 739 static uint8_t aes_cbc_key[] = { 740 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2, 741 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A }; 742 743 static uint8_t aes_cbc_iv[] = { 744 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 745 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f }; 746 747 748 /* ***** AES-CBC / HMAC-SHA1 Hash Tests ***** */ 749 750 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_ciphertext[] = { 751 0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31, 752 0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76, 753 0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E, 754 0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A, 755 0x3F, 0x6B, 0x5D, 0xDF, 0x52, 0x85, 0x5F, 0x8E, 756 0x42, 0x3C, 0xFB, 0xE9, 0x1A, 0x24, 0xD6, 0x08, 757 0xDD, 0xFD, 0x16, 0xFB, 0xE9, 0x55, 0xEF, 0xF0, 758 0xA0, 0x8D, 0x13, 0xAB, 0x81, 0xC6, 0x90, 0x01, 759 0xB5, 0x18, 0x84, 0xB3, 0xF6, 0xE6, 0x11, 0x57, 760 0xD6, 0x71, 0xC6, 0x3C, 0x3F, 0x2F, 0x33, 0xEE, 761 0x24, 0x42, 0x6E, 0xAC, 0x0B, 0xCA, 0xEC, 0xF9, 762 0x84, 0xF8, 0x22, 0xAA, 0x60, 0xF0, 0x32, 0xA9, 763 0x75, 0x75, 0x3B, 0xCB, 0x70, 0x21, 0x0A, 0x8D, 764 0x0F, 0xE0, 0xC4, 0x78, 0x2B, 0xF8, 0x97, 0xE3, 765 0xE4, 0x26, 0x4B, 0x29, 0xDA, 0x88, 0xCD, 0x46, 766 0xEC, 0xAA, 0xF9, 0x7F, 0xF1, 0x15, 0xEA, 0xC3, 767 0x87, 0xE6, 0x31, 0xF2, 0xCF, 0xDE, 0x4D, 0x80, 768 0x70, 0x91, 0x7E, 0x0C, 0xF7, 0x26, 0x3A, 0x92, 769 0x4F, 0x18, 0x83, 0xC0, 0x8F, 0x59, 0x01, 0xA5, 770 0x88, 0xD1, 0xDB, 0x26, 0x71, 0x27, 0x16, 0xF5, 771 0xEE, 0x10, 0x82, 0xAC, 0x68, 0x26, 0x9B, 0xE2, 772 0x6D, 0xD8, 0x9A, 0x80, 0xDF, 0x04, 0x31, 0xD5, 773 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA, 774 0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76, 775 0x73, 0x02, 0x42, 0xC9, 0x23, 0x18, 0x8E, 0xB4, 776 0x6F, 0xB4, 0xA3, 0x54, 0x6E, 0x88, 0x3B, 0x62, 777 0x7C, 0x02, 0x8D, 0x4C, 0x9F, 0xC8, 0x45, 0xF4, 778 0xC9, 0xDE, 0x4F, 0xEB, 0x22, 0x83, 0x1B, 0xE4, 779 0x49, 0x37, 0xE4, 0xAD, 0xE7, 0xCD, 0x21, 0x54, 780 0xBC, 0x1C, 0xC2, 0x04, 0x97, 0xB4, 0x10, 0x61, 781 0xF0, 0xE4, 0xEF, 0x27, 0x63, 0x3A, 0xDA, 0x91, 782 0x41, 0x25, 0x62, 0x1C, 0x5C, 0xB6, 0x38, 0x4A, 783 0x88, 0x71, 0x59, 0x5A, 0x8D, 0xA0, 0x09, 0xAF, 784 0x72, 0x94, 0xD7, 0x79, 0x5C, 0x60, 0x7C, 0x8F, 785 0x4C, 0xF5, 0xD9, 0xA1, 0x39, 0x6D, 0x81, 0x28, 786 0xEF, 0x13, 0x28, 0xDF, 0xF5, 0x3E, 0xF7, 0x8E, 787 0x09, 0x9C, 0x78, 0x18, 0x79, 0xB8, 0x68, 0xD7, 788 0xA8, 0x29, 0x62, 0xAD, 0xDE, 0xE1, 0x61, 0x76, 789 0x1B, 0x05, 0x16, 0xCD, 0xBF, 0x02, 0x8E, 0xA6, 790 0x43, 0x6E, 0x92, 0x55, 0x4F, 0x60, 0x9C, 0x03, 791 0xB8, 0x4F, 0xA3, 0x02, 0xAC, 0xA8, 0xA7, 0x0C, 792 0x1E, 0xB5, 0x6B, 0xF8, 0xC8, 0x4D, 0xDE, 0xD2, 793 0xB0, 0x29, 0x6E, 0x40, 0xE6, 0xD6, 0xC9, 0xE6, 794 0xB9, 0x0F, 0xB6, 0x63, 0xF5, 0xAA, 0x2B, 0x96, 795 0xA7, 0x16, 0xAC, 0x4E, 0x0A, 0x33, 0x1C, 0xA6, 796 0xE6, 0xBD, 0x8A, 0xCF, 0x40, 0xA9, 0xB2, 0xFA, 797 0x63, 0x27, 0xFD, 0x9B, 0xD9, 0xFC, 0xD5, 0x87, 798 0x8D, 0x4C, 0xB6, 0xA4, 0xCB, 0xE7, 0x74, 0x55, 799 0xF4, 0xFB, 0x41, 0x25, 0xB5, 0x4B, 0x0A, 0x1B, 800 0xB1, 0xD6, 0xB7, 0xD9, 0x47, 0x2A, 0xC3, 0x98, 801 0x6A, 0xC4, 0x03, 0x73, 0x1F, 0x93, 0x6E, 0x53, 802 0x19, 0x25, 0x64, 0x15, 0x83, 0xF9, 0x73, 0x2A, 803 0x74, 0xB4, 0x93, 0x69, 0xC4, 0x72, 0xFC, 0x26, 804 0xA2, 0x9F, 0x43, 0x45, 0xDD, 0xB9, 0xEF, 0x36, 805 0xC8, 0x3A, 0xCD, 0x99, 0x9B, 0x54, 0x1A, 0x36, 806 0xC1, 0x59, 0xF8, 0x98, 0xA8, 0xCC, 0x28, 0x0D, 807 0x73, 0x4C, 0xEE, 0x98, 0xCB, 0x7C, 0x58, 0x7E, 808 0x20, 0x75, 0x1E, 0xB7, 0xC9, 0xF8, 0xF2, 0x0E, 809 0x63, 0x9E, 0x05, 0x78, 0x1A, 0xB6, 0xA8, 0x7A, 810 0xF9, 0x98, 0x6A, 0xA6, 0x46, 0x84, 0x2E, 0xF6, 811 0x4B, 0xDC, 0x9B, 0x8F, 0x9B, 0x8F, 0xEE, 0xB4, 812 0xAA, 0x3F, 0xEE, 0xC0, 0x37, 0x27, 0x76, 0xC7, 813 0x95, 0xBB, 0x26, 0x74, 0x69, 0x12, 0x7F, 0xF1, 814 0xBB, 0xFF, 0xAE, 0xB5, 0x99, 0x6E, 0xCB, 0x0C 815 }; 816 817 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest[] = { 818 0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60, 819 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1, 820 0x18, 0x8c, 0x1d, 0x32 821 }; 822 823 824 static int 825 test_AES_CBC_HMAC_SHA1_encrypt_digest(void) 826 { 827 struct crypto_testsuite_params *ts_params = &testsuite_params; 828 struct crypto_unittest_params *ut_params = &unittest_params; 829 830 /* Generate test mbuf data and space for digest */ 831 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool, 832 catch_22_quote, QUOTE_512_BYTES, 0); 833 834 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 835 DIGEST_BYTE_LENGTH_SHA1); 836 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest"); 837 838 /* Setup Cipher Parameters */ 839 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 840 ut_params->cipher_xform.next = &ut_params->auth_xform; 841 842 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC; 843 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; 844 ut_params->cipher_xform.cipher.key.data = aes_cbc_key; 845 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC; 846 847 /* Setup HMAC Parameters */ 848 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 849 850 ut_params->auth_xform.next = NULL; 851 852 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; 853 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC; 854 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1; 855 ut_params->auth_xform.auth.key.data = hmac_sha1_key; 856 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1; 857 858 /* Create crypto session*/ 859 ut_params->sess = rte_cryptodev_sym_session_create( 860 ts_params->valid_devs[0], 861 &ut_params->cipher_xform); 862 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 863 864 /* Generate crypto op data structure */ 865 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 866 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 867 TEST_ASSERT_NOT_NULL(ut_params->op, 868 "Failed to allocate symmetric crypto operation struct"); 869 870 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 871 872 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 873 874 /* set crypto operation source mbuf */ 875 sym_op->m_src = ut_params->ibuf; 876 877 /* Set crypto operation authentication parameters */ 878 sym_op->auth.digest.data = ut_params->digest; 879 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( 880 ut_params->ibuf, QUOTE_512_BYTES); 881 sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA1; 882 883 sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC; 884 sym_op->auth.data.length = QUOTE_512_BYTES; 885 886 /* Set crypto operation cipher parameters */ 887 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf, 888 CIPHER_IV_LENGTH_AES_CBC); 889 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); 890 sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC; 891 892 rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv, 893 CIPHER_IV_LENGTH_AES_CBC); 894 895 sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC; 896 sym_op->cipher.data.length = QUOTE_512_BYTES; 897 898 /* Process crypto operation */ 899 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], 900 ut_params->op), "failed to process sym crypto op"); 901 902 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 903 "crypto op processing failed"); 904 905 /* Validate obuf */ 906 uint8_t *ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src, 907 uint8_t *, CIPHER_IV_LENGTH_AES_CBC); 908 909 TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext, 910 catch_22_quote_2_512_bytes_AES_CBC_ciphertext, 911 QUOTE_512_BYTES, 912 "ciphertext data not as expected"); 913 914 uint8_t *digest = ciphertext + QUOTE_512_BYTES; 915 916 TEST_ASSERT_BUFFERS_ARE_EQUAL(digest, 917 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest, 918 gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD ? 919 TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 : 920 DIGEST_BYTE_LENGTH_SHA1, 921 "Generated digest data not as expected"); 922 923 return TEST_SUCCESS; 924 } 925 926 /* ***** AES-CBC / HMAC-SHA512 Hash Tests ***** */ 927 928 #define HMAC_KEY_LENGTH_SHA512 (DIGEST_BYTE_LENGTH_SHA512) 929 930 static uint8_t hmac_sha512_key[] = { 931 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1, 932 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA, 933 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76, 934 0x9a, 0xaf, 0x88, 0x1b, 0xb6, 0x8f, 0xf8, 0x60, 935 0xa2, 0x5a, 0x7f, 0x3f, 0xf4, 0x72, 0x70, 0xf1, 936 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0, 937 0x47, 0x3a, 0x75, 0x61, 0x5C, 0xa2, 0x10, 0x76, 938 0x9a, 0xaf, 0x77, 0x5b, 0xb6, 0x7f, 0xf7, 0x60 }; 939 940 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest[] = { 941 0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8, 942 0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48, 943 0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8, 944 0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70, 945 0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8, 946 0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E, 947 0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D, 948 0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A }; 949 950 951 952 static int 953 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params( 954 struct crypto_unittest_params *ut_params); 955 956 static int 957 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess, 958 struct crypto_unittest_params *ut_params, 959 struct crypto_testsuite_params *ts_params); 960 961 962 static int 963 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params( 964 struct crypto_unittest_params *ut_params) 965 { 966 967 /* Setup Cipher Parameters */ 968 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 969 ut_params->cipher_xform.next = NULL; 970 971 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC; 972 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT; 973 ut_params->cipher_xform.cipher.key.data = aes_cbc_key; 974 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC; 975 976 /* Setup HMAC Parameters */ 977 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 978 ut_params->auth_xform.next = &ut_params->cipher_xform; 979 980 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY; 981 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC; 982 ut_params->auth_xform.auth.key.data = hmac_sha512_key; 983 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512; 984 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512; 985 986 return TEST_SUCCESS; 987 } 988 989 990 static int 991 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess, 992 struct crypto_unittest_params *ut_params, 993 struct crypto_testsuite_params *ts_params) 994 { 995 /* Generate test mbuf data and digest */ 996 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool, 997 (const char *) 998 catch_22_quote_2_512_bytes_AES_CBC_ciphertext, 999 QUOTE_512_BYTES, 0); 1000 1001 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 1002 DIGEST_BYTE_LENGTH_SHA512); 1003 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest"); 1004 1005 rte_memcpy(ut_params->digest, 1006 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest, 1007 DIGEST_BYTE_LENGTH_SHA512); 1008 1009 /* Generate Crypto op data structure */ 1010 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 1011 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 1012 TEST_ASSERT_NOT_NULL(ut_params->op, 1013 "Failed to allocate symmetric crypto operation struct"); 1014 1015 rte_crypto_op_attach_sym_session(ut_params->op, sess); 1016 1017 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 1018 1019 /* set crypto operation source mbuf */ 1020 sym_op->m_src = ut_params->ibuf; 1021 1022 sym_op->auth.digest.data = ut_params->digest; 1023 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( 1024 ut_params->ibuf, QUOTE_512_BYTES); 1025 sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA512; 1026 1027 sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC; 1028 sym_op->auth.data.length = QUOTE_512_BYTES; 1029 1030 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend( 1031 ut_params->ibuf, CIPHER_IV_LENGTH_AES_CBC); 1032 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys_offset( 1033 ut_params->ibuf, 0); 1034 sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC; 1035 1036 rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv, 1037 CIPHER_IV_LENGTH_AES_CBC); 1038 1039 sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC; 1040 sym_op->cipher.data.length = QUOTE_512_BYTES; 1041 1042 /* Process crypto operation */ 1043 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], 1044 ut_params->op), "failed to process sym crypto op"); 1045 1046 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 1047 "crypto op processing failed"); 1048 1049 ut_params->obuf = ut_params->op->sym->m_src; 1050 1051 /* Validate obuf */ 1052 TEST_ASSERT_BUFFERS_ARE_EQUAL( 1053 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + 1054 CIPHER_IV_LENGTH_AES_CBC, catch_22_quote, 1055 QUOTE_512_BYTES, 1056 "Plaintext data not as expected"); 1057 1058 /* Validate obuf */ 1059 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 1060 "Digest verification failed"); 1061 1062 return TEST_SUCCESS; 1063 } 1064 1065 static int 1066 test_AES_mb_all(void) 1067 { 1068 struct crypto_testsuite_params *ts_params = &testsuite_params; 1069 int status; 1070 1071 status = test_AES_all_tests(ts_params->mbuf_pool, 1072 ts_params->op_mpool, ts_params->valid_devs[0], 1073 RTE_CRYPTODEV_AESNI_MB_PMD); 1074 1075 TEST_ASSERT_EQUAL(status, 0, "Test failed"); 1076 1077 return TEST_SUCCESS; 1078 } 1079 1080 static int 1081 test_AES_qat_all(void) 1082 { 1083 struct crypto_testsuite_params *ts_params = &testsuite_params; 1084 int status; 1085 1086 status = test_AES_all_tests(ts_params->mbuf_pool, 1087 ts_params->op_mpool, ts_params->valid_devs[0], 1088 RTE_CRYPTODEV_QAT_SYM_PMD); 1089 1090 TEST_ASSERT_EQUAL(status, 0, "Test failed"); 1091 1092 return TEST_SUCCESS; 1093 } 1094 1095 /* ***** Snow3G Tests ***** */ 1096 static int 1097 create_snow3g_kasumi_hash_session(uint8_t dev_id, 1098 const uint8_t *key, const uint8_t key_len, 1099 const uint8_t aad_len, const uint8_t auth_len, 1100 enum rte_crypto_auth_operation op, 1101 enum rte_crypto_auth_algorithm algo) 1102 { 1103 uint8_t hash_key[key_len]; 1104 1105 struct crypto_unittest_params *ut_params = &unittest_params; 1106 1107 memcpy(hash_key, key, key_len); 1108 1109 TEST_HEXDUMP(stdout, "key:", key, key_len); 1110 1111 /* Setup Authentication Parameters */ 1112 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 1113 ut_params->auth_xform.next = NULL; 1114 1115 ut_params->auth_xform.auth.op = op; 1116 ut_params->auth_xform.auth.algo = algo; 1117 ut_params->auth_xform.auth.key.length = key_len; 1118 ut_params->auth_xform.auth.key.data = hash_key; 1119 ut_params->auth_xform.auth.digest_length = auth_len; 1120 ut_params->auth_xform.auth.add_auth_data_length = aad_len; 1121 ut_params->sess = rte_cryptodev_sym_session_create(dev_id, 1122 &ut_params->auth_xform); 1123 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 1124 return 0; 1125 } 1126 1127 static int 1128 create_snow3g_kasumi_cipher_session(uint8_t dev_id, 1129 enum rte_crypto_cipher_operation op, 1130 enum rte_crypto_cipher_algorithm algo, 1131 const uint8_t *key, const uint8_t key_len) 1132 { 1133 uint8_t cipher_key[key_len]; 1134 1135 struct crypto_unittest_params *ut_params = &unittest_params; 1136 1137 memcpy(cipher_key, key, key_len); 1138 1139 /* Setup Cipher Parameters */ 1140 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 1141 ut_params->cipher_xform.next = NULL; 1142 1143 ut_params->cipher_xform.cipher.algo = algo; 1144 ut_params->cipher_xform.cipher.op = op; 1145 ut_params->cipher_xform.cipher.key.data = cipher_key; 1146 ut_params->cipher_xform.cipher.key.length = key_len; 1147 1148 TEST_HEXDUMP(stdout, "key:", key, key_len); 1149 1150 /* Create Crypto session */ 1151 ut_params->sess = rte_cryptodev_sym_session_create(dev_id, 1152 &ut_params-> 1153 cipher_xform); 1154 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 1155 return 0; 1156 } 1157 1158 static int 1159 create_snow3g_kasumi_cipher_operation(const uint8_t *iv, const unsigned iv_len, 1160 const unsigned cipher_len, 1161 const unsigned cipher_offset, 1162 enum rte_crypto_cipher_algorithm algo) 1163 { 1164 struct crypto_testsuite_params *ts_params = &testsuite_params; 1165 struct crypto_unittest_params *ut_params = &unittest_params; 1166 unsigned iv_pad_len = 0; 1167 1168 /* Generate Crypto op data structure */ 1169 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 1170 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 1171 TEST_ASSERT_NOT_NULL(ut_params->op, 1172 "Failed to allocate pktmbuf offload"); 1173 1174 /* Set crypto operation data parameters */ 1175 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 1176 1177 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 1178 1179 /* set crypto operation source mbuf */ 1180 sym_op->m_src = ut_params->ibuf; 1181 1182 /* iv */ 1183 if (algo == RTE_CRYPTO_CIPHER_KASUMI_F8) 1184 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8); 1185 else 1186 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16); 1187 1188 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf 1189 , iv_pad_len); 1190 1191 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv"); 1192 1193 memset(sym_op->cipher.iv.data, 0, iv_pad_len); 1194 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); 1195 sym_op->cipher.iv.length = iv_pad_len; 1196 1197 rte_memcpy(sym_op->cipher.iv.data, iv, iv_len); 1198 sym_op->cipher.data.length = cipher_len; 1199 sym_op->cipher.data.offset = cipher_offset; 1200 return 0; 1201 } 1202 1203 static int 1204 create_snow3g_kasumi_cipher_operation_oop(const uint8_t *iv, const uint8_t iv_len, 1205 const unsigned cipher_len, 1206 const unsigned cipher_offset, 1207 enum rte_crypto_cipher_algorithm algo) 1208 { 1209 struct crypto_testsuite_params *ts_params = &testsuite_params; 1210 struct crypto_unittest_params *ut_params = &unittest_params; 1211 unsigned iv_pad_len = 0; 1212 1213 /* Generate Crypto op data structure */ 1214 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 1215 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 1216 TEST_ASSERT_NOT_NULL(ut_params->op, 1217 "Failed to allocate pktmbuf offload"); 1218 1219 /* Set crypto operation data parameters */ 1220 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 1221 1222 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 1223 1224 /* set crypto operation source mbuf */ 1225 sym_op->m_src = ut_params->ibuf; 1226 sym_op->m_dst = ut_params->obuf; 1227 1228 /* iv */ 1229 if (algo == RTE_CRYPTO_CIPHER_KASUMI_F8) 1230 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8); 1231 else 1232 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16); 1233 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf, 1234 iv_pad_len); 1235 1236 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv"); 1237 1238 memset(sym_op->cipher.iv.data, 0, iv_pad_len); 1239 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); 1240 sym_op->cipher.iv.length = iv_pad_len; 1241 1242 rte_memcpy(sym_op->cipher.iv.data, iv, iv_len); 1243 sym_op->cipher.data.length = cipher_len; 1244 sym_op->cipher.data.offset = cipher_offset; 1245 return 0; 1246 } 1247 1248 static int 1249 create_snow3g_kasumi_cipher_auth_session(uint8_t dev_id, 1250 enum rte_crypto_cipher_operation cipher_op, 1251 enum rte_crypto_auth_operation auth_op, 1252 enum rte_crypto_auth_algorithm auth_algo, 1253 enum rte_crypto_cipher_algorithm cipher_algo, 1254 const uint8_t *key, const uint8_t key_len, 1255 const uint8_t aad_len, const uint8_t auth_len) 1256 1257 { 1258 uint8_t cipher_auth_key[key_len]; 1259 1260 struct crypto_unittest_params *ut_params = &unittest_params; 1261 1262 memcpy(cipher_auth_key, key, key_len); 1263 1264 /* Setup Authentication Parameters */ 1265 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 1266 ut_params->auth_xform.next = NULL; 1267 1268 ut_params->auth_xform.auth.op = auth_op; 1269 ut_params->auth_xform.auth.algo = auth_algo; 1270 ut_params->auth_xform.auth.key.length = key_len; 1271 /* Hash key = cipher key */ 1272 ut_params->auth_xform.auth.key.data = cipher_auth_key; 1273 ut_params->auth_xform.auth.digest_length = auth_len; 1274 ut_params->auth_xform.auth.add_auth_data_length = aad_len; 1275 1276 /* Setup Cipher Parameters */ 1277 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 1278 ut_params->cipher_xform.next = &ut_params->auth_xform; 1279 1280 ut_params->cipher_xform.cipher.algo = cipher_algo; 1281 ut_params->cipher_xform.cipher.op = cipher_op; 1282 ut_params->cipher_xform.cipher.key.data = cipher_auth_key; 1283 ut_params->cipher_xform.cipher.key.length = key_len; 1284 1285 TEST_HEXDUMP(stdout, "key:", key, key_len); 1286 1287 /* Create Crypto session*/ 1288 ut_params->sess = rte_cryptodev_sym_session_create(dev_id, 1289 &ut_params->cipher_xform); 1290 1291 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 1292 return 0; 1293 } 1294 1295 static int 1296 create_snow3g_kasumi_auth_cipher_session(uint8_t dev_id, 1297 enum rte_crypto_cipher_operation cipher_op, 1298 enum rte_crypto_auth_operation auth_op, 1299 enum rte_crypto_auth_algorithm auth_algo, 1300 enum rte_crypto_cipher_algorithm cipher_algo, 1301 const uint8_t *key, const uint8_t key_len, 1302 const uint8_t aad_len, const uint8_t auth_len) 1303 { 1304 uint8_t auth_cipher_key[key_len]; 1305 1306 struct crypto_unittest_params *ut_params = &unittest_params; 1307 1308 memcpy(auth_cipher_key, key, key_len); 1309 1310 /* Setup Authentication Parameters */ 1311 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 1312 ut_params->auth_xform.auth.op = auth_op; 1313 ut_params->auth_xform.next = &ut_params->cipher_xform; 1314 ut_params->auth_xform.auth.algo = auth_algo; 1315 ut_params->auth_xform.auth.key.length = key_len; 1316 ut_params->auth_xform.auth.key.data = auth_cipher_key; 1317 ut_params->auth_xform.auth.digest_length = auth_len; 1318 ut_params->auth_xform.auth.add_auth_data_length = aad_len; 1319 1320 /* Setup Cipher Parameters */ 1321 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 1322 ut_params->cipher_xform.next = NULL; 1323 ut_params->cipher_xform.cipher.algo = cipher_algo; 1324 ut_params->cipher_xform.cipher.op = cipher_op; 1325 ut_params->cipher_xform.cipher.key.data = auth_cipher_key; 1326 ut_params->cipher_xform.cipher.key.length = key_len; 1327 1328 TEST_HEXDUMP(stdout, "key:", key, key_len); 1329 1330 /* Create Crypto session*/ 1331 ut_params->sess = rte_cryptodev_sym_session_create(dev_id, 1332 &ut_params->auth_xform); 1333 1334 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 1335 1336 return 0; 1337 } 1338 1339 static int 1340 create_snow3g_kasumi_hash_operation(const uint8_t *auth_tag, 1341 const unsigned auth_tag_len, 1342 const uint8_t *aad, const unsigned aad_len, 1343 unsigned data_pad_len, 1344 enum rte_crypto_auth_operation op, 1345 enum rte_crypto_auth_algorithm algo, 1346 const unsigned auth_len, const unsigned auth_offset) 1347 { 1348 struct crypto_testsuite_params *ts_params = &testsuite_params; 1349 1350 struct crypto_unittest_params *ut_params = &unittest_params; 1351 1352 unsigned aad_buffer_len; 1353 1354 /* Generate Crypto op data structure */ 1355 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 1356 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 1357 TEST_ASSERT_NOT_NULL(ut_params->op, 1358 "Failed to allocate pktmbuf offload"); 1359 1360 /* Set crypto operation data parameters */ 1361 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 1362 1363 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 1364 1365 /* set crypto operation source mbuf */ 1366 sym_op->m_src = ut_params->ibuf; 1367 1368 /* aad */ 1369 /* 1370 * Always allocate the aad up to the block size. 1371 * The cryptodev API calls out - 1372 * - the array must be big enough to hold the AAD, plus any 1373 * space to round this up to the nearest multiple of the 1374 * block size (8 bytes for KASUMI and 16 bytes for SNOW3G). 1375 */ 1376 if (algo == RTE_CRYPTO_AUTH_KASUMI_F9) 1377 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 8); 1378 else 1379 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16); 1380 sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend( 1381 ut_params->ibuf, aad_buffer_len); 1382 TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data, 1383 "no room to prepend aad"); 1384 sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys( 1385 ut_params->ibuf); 1386 sym_op->auth.aad.length = aad_len; 1387 1388 memset(sym_op->auth.aad.data, 0, aad_buffer_len); 1389 rte_memcpy(sym_op->auth.aad.data, aad, aad_len); 1390 1391 TEST_HEXDUMP(stdout, "aad:", 1392 sym_op->auth.aad.data, aad_len); 1393 1394 /* digest */ 1395 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( 1396 ut_params->ibuf, auth_tag_len); 1397 1398 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, 1399 "no room to append auth tag"); 1400 ut_params->digest = sym_op->auth.digest.data; 1401 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( 1402 ut_params->ibuf, data_pad_len + aad_len); 1403 sym_op->auth.digest.length = auth_tag_len; 1404 if (op == RTE_CRYPTO_AUTH_OP_GENERATE) 1405 memset(sym_op->auth.digest.data, 0, auth_tag_len); 1406 else 1407 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len); 1408 1409 TEST_HEXDUMP(stdout, "digest:", 1410 sym_op->auth.digest.data, 1411 sym_op->auth.digest.length); 1412 1413 sym_op->auth.data.length = auth_len; 1414 sym_op->auth.data.offset = auth_offset; 1415 1416 return 0; 1417 } 1418 1419 static int 1420 create_snow3g_kasumi_cipher_hash_operation(const uint8_t *auth_tag, 1421 const unsigned auth_tag_len, 1422 const uint8_t *aad, const uint8_t aad_len, 1423 unsigned data_pad_len, 1424 enum rte_crypto_auth_operation op, 1425 enum rte_crypto_auth_algorithm auth_algo, 1426 enum rte_crypto_cipher_algorithm cipher_algo, 1427 const uint8_t *iv, const uint8_t iv_len, 1428 const unsigned cipher_len, const unsigned cipher_offset, 1429 const unsigned auth_len, const unsigned auth_offset) 1430 { 1431 struct crypto_testsuite_params *ts_params = &testsuite_params; 1432 struct crypto_unittest_params *ut_params = &unittest_params; 1433 1434 unsigned iv_pad_len = 0; 1435 unsigned aad_buffer_len; 1436 1437 /* Generate Crypto op data structure */ 1438 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 1439 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 1440 TEST_ASSERT_NOT_NULL(ut_params->op, 1441 "Failed to allocate pktmbuf offload"); 1442 /* Set crypto operation data parameters */ 1443 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 1444 1445 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 1446 1447 /* set crypto operation source mbuf */ 1448 sym_op->m_src = ut_params->ibuf; 1449 1450 1451 /* iv */ 1452 if (cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8) 1453 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8); 1454 else 1455 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16); 1456 1457 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend( 1458 ut_params->ibuf, iv_pad_len); 1459 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv"); 1460 1461 memset(sym_op->cipher.iv.data, 0, iv_pad_len); 1462 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); 1463 sym_op->cipher.iv.length = iv_pad_len; 1464 1465 rte_memcpy(sym_op->cipher.iv.data, iv, iv_len); 1466 1467 sym_op->cipher.data.length = cipher_len; 1468 sym_op->cipher.data.offset = cipher_offset; 1469 1470 /* aad */ 1471 /* 1472 * Always allocate the aad up to the block size. 1473 * The cryptodev API calls out - 1474 * - the array must be big enough to hold the AAD, plus any 1475 * space to round this up to the nearest multiple of the 1476 * block size (8 bytes for KASUMI and 16 bytes for SNOW3G). 1477 */ 1478 if (auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9) 1479 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 8); 1480 else 1481 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16); 1482 1483 sym_op->auth.aad.data = 1484 (uint8_t *)rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *); 1485 TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data, 1486 "no room to prepend aad"); 1487 sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys( 1488 ut_params->ibuf); 1489 sym_op->auth.aad.length = aad_len; 1490 1491 memset(sym_op->auth.aad.data, 0, aad_buffer_len); 1492 rte_memcpy(sym_op->auth.aad.data, aad, aad_len); 1493 1494 TEST_HEXDUMP(stdout, "aad:", 1495 sym_op->auth.aad.data, aad_len); 1496 1497 /* digest */ 1498 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( 1499 ut_params->ibuf, auth_tag_len); 1500 1501 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, 1502 "no room to append auth tag"); 1503 ut_params->digest = sym_op->auth.digest.data; 1504 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( 1505 ut_params->ibuf, data_pad_len + aad_len); 1506 sym_op->auth.digest.length = auth_tag_len; 1507 if (op == RTE_CRYPTO_AUTH_OP_GENERATE) 1508 memset(sym_op->auth.digest.data, 0, auth_tag_len); 1509 else 1510 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len); 1511 1512 TEST_HEXDUMP(stdout, "digest:", 1513 sym_op->auth.digest.data, 1514 sym_op->auth.digest.length); 1515 1516 sym_op->auth.data.length = auth_len; 1517 sym_op->auth.data.offset = auth_offset; 1518 1519 return 0; 1520 } 1521 1522 static int 1523 create_snow3g_kasumi_auth_cipher_operation(const unsigned auth_tag_len, 1524 const uint8_t *iv, const uint8_t iv_len, 1525 const uint8_t *aad, const uint8_t aad_len, 1526 unsigned data_pad_len, 1527 const unsigned cipher_len, const unsigned cipher_offset, 1528 const unsigned auth_len, const unsigned auth_offset, 1529 enum rte_crypto_auth_algorithm auth_algo, 1530 enum rte_crypto_cipher_algorithm cipher_algo) 1531 { 1532 struct crypto_testsuite_params *ts_params = &testsuite_params; 1533 struct crypto_unittest_params *ut_params = &unittest_params; 1534 1535 unsigned iv_pad_len = 0; 1536 unsigned aad_buffer_len = 0; 1537 1538 /* Generate Crypto op data structure */ 1539 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 1540 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 1541 TEST_ASSERT_NOT_NULL(ut_params->op, 1542 "Failed to allocate pktmbuf offload"); 1543 1544 /* Set crypto operation data parameters */ 1545 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 1546 1547 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 1548 1549 /* set crypto operation source mbuf */ 1550 sym_op->m_src = ut_params->ibuf; 1551 1552 /* digest */ 1553 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( 1554 ut_params->ibuf, auth_tag_len); 1555 1556 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, 1557 "no room to append auth tag"); 1558 1559 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( 1560 ut_params->ibuf, data_pad_len); 1561 sym_op->auth.digest.length = auth_tag_len; 1562 1563 memset(sym_op->auth.digest.data, 0, auth_tag_len); 1564 1565 TEST_HEXDUMP(stdout, "digest:", 1566 sym_op->auth.digest.data, 1567 sym_op->auth.digest.length); 1568 1569 /* iv */ 1570 if (cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8) 1571 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8); 1572 else 1573 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16); 1574 1575 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend( 1576 ut_params->ibuf, iv_pad_len); 1577 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv"); 1578 1579 memset(sym_op->cipher.iv.data, 0, iv_pad_len); 1580 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); 1581 sym_op->cipher.iv.length = iv_pad_len; 1582 1583 rte_memcpy(sym_op->cipher.iv.data, iv, iv_len); 1584 1585 /* aad */ 1586 /* 1587 * Always allocate the aad up to the block size. 1588 * The cryptodev API calls out - 1589 * - the array must be big enough to hold the AAD, plus any 1590 * space to round this up to the nearest multiple of the 1591 * block size (8 bytes for KASUMI 16 bytes). 1592 */ 1593 if (auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9) 1594 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 8); 1595 else 1596 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16); 1597 1598 sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend( 1599 ut_params->ibuf, aad_buffer_len); 1600 TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data, 1601 "no room to prepend aad"); 1602 sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys( 1603 ut_params->ibuf); 1604 sym_op->auth.aad.length = aad_len; 1605 1606 memset(sym_op->auth.aad.data, 0, aad_buffer_len); 1607 rte_memcpy(sym_op->auth.aad.data, aad, aad_len); 1608 1609 TEST_HEXDUMP(stdout, "aad:", 1610 sym_op->auth.aad.data, aad_len); 1611 1612 sym_op->cipher.data.length = cipher_len; 1613 sym_op->cipher.data.offset = auth_offset + cipher_offset; 1614 1615 sym_op->auth.data.length = auth_len; 1616 sym_op->auth.data.offset = auth_offset + cipher_offset; 1617 1618 return 0; 1619 } 1620 1621 static int 1622 test_snow3g_authentication(const struct snow3g_hash_test_data *tdata) 1623 { 1624 struct crypto_testsuite_params *ts_params = &testsuite_params; 1625 struct crypto_unittest_params *ut_params = &unittest_params; 1626 1627 int retval; 1628 unsigned plaintext_pad_len; 1629 unsigned plaintext_len; 1630 uint8_t *plaintext; 1631 1632 /* Create SNOW3G session */ 1633 retval = create_snow3g_kasumi_hash_session(ts_params->valid_devs[0], 1634 tdata->key.data, tdata->key.len, 1635 tdata->aad.len, tdata->digest.len, 1636 RTE_CRYPTO_AUTH_OP_GENERATE, 1637 RTE_CRYPTO_AUTH_SNOW3G_UIA2); 1638 if (retval < 0) 1639 return retval; 1640 1641 /* alloc mbuf and set payload */ 1642 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 1643 1644 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 1645 rte_pktmbuf_tailroom(ut_params->ibuf)); 1646 1647 plaintext_len = ceil_byte_length(tdata->plaintext.len); 1648 /* Append data which is padded to a multiple of */ 1649 /* the algorithms block size */ 1650 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); 1651 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 1652 plaintext_pad_len); 1653 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 1654 1655 /* Create SNOW3G operation */ 1656 retval = create_snow3g_kasumi_hash_operation(NULL, tdata->digest.len, 1657 tdata->aad.data, tdata->aad.len, 1658 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE, 1659 RTE_CRYPTO_AUTH_SNOW3G_UIA2, 1660 tdata->validAuthLenInBits.len, 1661 tdata->validAuthOffsetLenInBits.len); 1662 if (retval < 0) 1663 return retval; 1664 1665 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 1666 ut_params->op); 1667 ut_params->obuf = ut_params->op->sym->m_src; 1668 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 1669 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 1670 + plaintext_pad_len + tdata->aad.len; 1671 1672 /* Validate obuf */ 1673 TEST_ASSERT_BUFFERS_ARE_EQUAL( 1674 ut_params->digest, 1675 tdata->digest.data, 1676 DIGEST_BYTE_LENGTH_SNOW3G_UIA2, 1677 "Snow3G Generated auth tag not as expected"); 1678 1679 return 0; 1680 } 1681 1682 static int 1683 test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata) 1684 { 1685 struct crypto_testsuite_params *ts_params = &testsuite_params; 1686 struct crypto_unittest_params *ut_params = &unittest_params; 1687 1688 int retval; 1689 unsigned plaintext_pad_len; 1690 unsigned plaintext_len; 1691 uint8_t *plaintext; 1692 1693 /* Create SNOW3G session */ 1694 retval = create_snow3g_kasumi_hash_session(ts_params->valid_devs[0], 1695 tdata->key.data, tdata->key.len, 1696 tdata->aad.len, tdata->digest.len, 1697 RTE_CRYPTO_AUTH_OP_VERIFY, 1698 RTE_CRYPTO_AUTH_SNOW3G_UIA2); 1699 if (retval < 0) 1700 return retval; 1701 /* alloc mbuf and set payload */ 1702 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 1703 1704 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 1705 rte_pktmbuf_tailroom(ut_params->ibuf)); 1706 1707 plaintext_len = ceil_byte_length(tdata->plaintext.len); 1708 /* Append data which is padded to a multiple of */ 1709 /* the algorithms block size */ 1710 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); 1711 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 1712 plaintext_pad_len); 1713 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 1714 1715 /* Create SNOW3G operation */ 1716 retval = create_snow3g_kasumi_hash_operation(tdata->digest.data, 1717 tdata->digest.len, 1718 tdata->aad.data, tdata->aad.len, 1719 plaintext_pad_len, 1720 RTE_CRYPTO_AUTH_OP_VERIFY, 1721 RTE_CRYPTO_AUTH_SNOW3G_UIA2, 1722 tdata->validAuthLenInBits.len, 1723 tdata->validAuthOffsetLenInBits.len); 1724 if (retval < 0) 1725 return retval; 1726 1727 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 1728 ut_params->op); 1729 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 1730 ut_params->obuf = ut_params->op->sym->m_src; 1731 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 1732 + plaintext_pad_len + tdata->aad.len; 1733 1734 /* Validate obuf */ 1735 if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS) 1736 return 0; 1737 else 1738 return -1; 1739 1740 return 0; 1741 } 1742 1743 static int 1744 test_kasumi_authentication(const struct kasumi_hash_test_data *tdata) 1745 { 1746 struct crypto_testsuite_params *ts_params = &testsuite_params; 1747 struct crypto_unittest_params *ut_params = &unittest_params; 1748 1749 int retval; 1750 unsigned plaintext_pad_len; 1751 unsigned plaintext_len; 1752 uint8_t *plaintext; 1753 1754 /* Create KASUMI session */ 1755 retval = create_snow3g_kasumi_hash_session(ts_params->valid_devs[0], 1756 tdata->key.data, tdata->key.len, 1757 tdata->aad.len, tdata->digest.len, 1758 RTE_CRYPTO_AUTH_OP_GENERATE, 1759 RTE_CRYPTO_AUTH_KASUMI_F9); 1760 if (retval < 0) 1761 return retval; 1762 1763 /* alloc mbuf and set payload */ 1764 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 1765 1766 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 1767 rte_pktmbuf_tailroom(ut_params->ibuf)); 1768 1769 plaintext_len = ceil_byte_length(tdata->plaintext.len); 1770 /* Append data which is padded to a multiple of */ 1771 /* the algorithms block size */ 1772 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); 1773 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 1774 plaintext_pad_len); 1775 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 1776 1777 /* Create KASUMI operation */ 1778 retval = create_snow3g_kasumi_hash_operation(NULL, tdata->digest.len, 1779 tdata->aad.data, tdata->aad.len, 1780 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE, 1781 RTE_CRYPTO_AUTH_KASUMI_F9, 1782 tdata->validAuthLenInBits.len, 1783 tdata->validAuthOffsetLenInBits.len); 1784 if (retval < 0) 1785 return retval; 1786 1787 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 1788 ut_params->op); 1789 ut_params->obuf = ut_params->op->sym->m_src; 1790 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 1791 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 1792 + plaintext_pad_len + ALIGN_POW2_ROUNDUP(tdata->aad.len, 8); 1793 1794 /* Validate obuf */ 1795 TEST_ASSERT_BUFFERS_ARE_EQUAL( 1796 ut_params->digest, 1797 tdata->digest.data, 1798 DIGEST_BYTE_LENGTH_KASUMI_F9, 1799 "KASUMI Generated auth tag not as expected"); 1800 1801 return 0; 1802 } 1803 1804 static int 1805 test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata) 1806 { 1807 struct crypto_testsuite_params *ts_params = &testsuite_params; 1808 struct crypto_unittest_params *ut_params = &unittest_params; 1809 1810 int retval; 1811 unsigned plaintext_pad_len; 1812 unsigned plaintext_len; 1813 uint8_t *plaintext; 1814 1815 /* Create KASUMI session */ 1816 retval = create_snow3g_kasumi_hash_session(ts_params->valid_devs[0], 1817 tdata->key.data, tdata->key.len, 1818 tdata->aad.len, tdata->digest.len, 1819 RTE_CRYPTO_AUTH_OP_VERIFY, 1820 RTE_CRYPTO_AUTH_KASUMI_F9); 1821 if (retval < 0) 1822 return retval; 1823 /* alloc mbuf and set payload */ 1824 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 1825 1826 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 1827 rte_pktmbuf_tailroom(ut_params->ibuf)); 1828 1829 plaintext_len = ceil_byte_length(tdata->plaintext.len); 1830 /* Append data which is padded to a multiple */ 1831 /* of the algorithms block size */ 1832 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); 1833 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 1834 plaintext_pad_len); 1835 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 1836 1837 /* Create KASUMI operation */ 1838 retval = create_snow3g_kasumi_hash_operation(tdata->digest.data, 1839 tdata->digest.len, 1840 tdata->aad.data, tdata->aad.len, 1841 plaintext_pad_len, 1842 RTE_CRYPTO_AUTH_OP_VERIFY, 1843 RTE_CRYPTO_AUTH_KASUMI_F9, 1844 tdata->validAuthLenInBits.len, 1845 tdata->validAuthOffsetLenInBits.len); 1846 if (retval < 0) 1847 return retval; 1848 1849 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 1850 ut_params->op); 1851 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 1852 ut_params->obuf = ut_params->op->sym->m_src; 1853 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 1854 + plaintext_pad_len + tdata->aad.len; 1855 1856 /* Validate obuf */ 1857 if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS) 1858 return 0; 1859 else 1860 return -1; 1861 1862 return 0; 1863 } 1864 1865 static int 1866 test_snow3g_hash_generate_test_case_1(void) 1867 { 1868 return test_snow3g_authentication(&snow3g_hash_test_case_1); 1869 } 1870 1871 static int 1872 test_snow3g_hash_generate_test_case_2(void) 1873 { 1874 return test_snow3g_authentication(&snow3g_hash_test_case_2); 1875 } 1876 1877 static int 1878 test_snow3g_hash_generate_test_case_3(void) 1879 { 1880 return test_snow3g_authentication(&snow3g_hash_test_case_3); 1881 } 1882 1883 static int 1884 test_snow3g_hash_generate_test_case_4(void) 1885 { 1886 return test_snow3g_authentication(&snow3g_hash_test_case_4); 1887 } 1888 1889 static int 1890 test_snow3g_hash_generate_test_case_5(void) 1891 { 1892 return test_snow3g_authentication(&snow3g_hash_test_case_5); 1893 } 1894 1895 static int 1896 test_snow3g_hash_generate_test_case_6(void) 1897 { 1898 return test_snow3g_authentication(&snow3g_hash_test_case_6); 1899 } 1900 1901 static int 1902 test_snow3g_hash_verify_test_case_1(void) 1903 { 1904 return test_snow3g_authentication_verify(&snow3g_hash_test_case_1); 1905 1906 } 1907 1908 static int 1909 test_snow3g_hash_verify_test_case_2(void) 1910 { 1911 return test_snow3g_authentication_verify(&snow3g_hash_test_case_2); 1912 } 1913 1914 static int 1915 test_snow3g_hash_verify_test_case_3(void) 1916 { 1917 return test_snow3g_authentication_verify(&snow3g_hash_test_case_3); 1918 } 1919 1920 static int 1921 test_snow3g_hash_verify_test_case_4(void) 1922 { 1923 return test_snow3g_authentication_verify(&snow3g_hash_test_case_4); 1924 } 1925 1926 static int 1927 test_snow3g_hash_verify_test_case_5(void) 1928 { 1929 return test_snow3g_authentication_verify(&snow3g_hash_test_case_5); 1930 } 1931 1932 static int 1933 test_snow3g_hash_verify_test_case_6(void) 1934 { 1935 return test_snow3g_authentication_verify(&snow3g_hash_test_case_6); 1936 } 1937 1938 static int 1939 test_kasumi_hash_generate_test_case_1(void) 1940 { 1941 return test_kasumi_authentication(&kasumi_hash_test_case_1); 1942 } 1943 1944 static int 1945 test_kasumi_hash_generate_test_case_2(void) 1946 { 1947 return test_kasumi_authentication(&kasumi_hash_test_case_2); 1948 } 1949 1950 static int 1951 test_kasumi_hash_generate_test_case_3(void) 1952 { 1953 return test_kasumi_authentication(&kasumi_hash_test_case_3); 1954 } 1955 1956 static int 1957 test_kasumi_hash_generate_test_case_4(void) 1958 { 1959 return test_kasumi_authentication(&kasumi_hash_test_case_4); 1960 } 1961 1962 static int 1963 test_kasumi_hash_generate_test_case_5(void) 1964 { 1965 return test_kasumi_authentication(&kasumi_hash_test_case_5); 1966 } 1967 1968 static int 1969 test_kasumi_hash_verify_test_case_1(void) 1970 { 1971 return test_kasumi_authentication_verify(&kasumi_hash_test_case_1); 1972 } 1973 1974 static int 1975 test_kasumi_hash_verify_test_case_2(void) 1976 { 1977 return test_kasumi_authentication_verify(&kasumi_hash_test_case_2); 1978 } 1979 1980 static int 1981 test_kasumi_hash_verify_test_case_3(void) 1982 { 1983 return test_kasumi_authentication_verify(&kasumi_hash_test_case_3); 1984 } 1985 1986 static int 1987 test_kasumi_hash_verify_test_case_4(void) 1988 { 1989 return test_kasumi_authentication_verify(&kasumi_hash_test_case_4); 1990 } 1991 1992 static int 1993 test_kasumi_hash_verify_test_case_5(void) 1994 { 1995 return test_kasumi_authentication_verify(&kasumi_hash_test_case_5); 1996 } 1997 1998 static int 1999 test_kasumi_encryption(const struct kasumi_test_data *tdata) 2000 { 2001 struct crypto_testsuite_params *ts_params = &testsuite_params; 2002 struct crypto_unittest_params *ut_params = &unittest_params; 2003 2004 int retval; 2005 uint8_t *plaintext, *ciphertext; 2006 unsigned plaintext_pad_len; 2007 unsigned plaintext_len; 2008 2009 /* Create KASUMI session */ 2010 retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0], 2011 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 2012 RTE_CRYPTO_CIPHER_KASUMI_F8, 2013 tdata->key.data, tdata->key.len); 2014 if (retval < 0) 2015 return retval; 2016 2017 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 2018 2019 /* Clear mbuf payload */ 2020 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 2021 rte_pktmbuf_tailroom(ut_params->ibuf)); 2022 2023 plaintext_len = ceil_byte_length(tdata->plaintext.len); 2024 /* Append data which is padded to a multiple */ 2025 /* of the algorithms block size */ 2026 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); 2027 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 2028 plaintext_pad_len); 2029 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 2030 2031 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len); 2032 2033 /* Create KASUMI operation */ 2034 retval = create_snow3g_kasumi_cipher_operation(tdata->iv.data, tdata->iv.len, 2035 tdata->plaintext.len, 2036 tdata->validCipherOffsetLenInBits.len, 2037 RTE_CRYPTO_CIPHER_KASUMI_F8); 2038 if (retval < 0) 2039 return retval; 2040 2041 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 2042 ut_params->op); 2043 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 2044 2045 ut_params->obuf = ut_params->op->sym->m_dst; 2046 if (ut_params->obuf) 2047 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 2048 + tdata->iv.len; 2049 else 2050 ciphertext = plaintext; 2051 2052 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len); 2053 2054 /* Validate obuf */ 2055 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 2056 ciphertext, 2057 tdata->ciphertext.data, 2058 tdata->validCipherLenInBits.len, 2059 "KASUMI Ciphertext data not as expected"); 2060 return 0; 2061 } 2062 2063 static int 2064 test_kasumi_encryption_oop(const struct kasumi_test_data *tdata) 2065 { 2066 struct crypto_testsuite_params *ts_params = &testsuite_params; 2067 struct crypto_unittest_params *ut_params = &unittest_params; 2068 2069 int retval; 2070 uint8_t *plaintext, *ciphertext; 2071 unsigned plaintext_pad_len; 2072 unsigned plaintext_len; 2073 2074 /* Create KASUMI session */ 2075 retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0], 2076 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 2077 RTE_CRYPTO_CIPHER_KASUMI_F8, 2078 tdata->key.data, tdata->key.len); 2079 if (retval < 0) 2080 return retval; 2081 2082 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 2083 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 2084 2085 /* Clear mbuf payload */ 2086 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 2087 rte_pktmbuf_tailroom(ut_params->ibuf)); 2088 2089 plaintext_len = ceil_byte_length(tdata->plaintext.len); 2090 /* Append data which is padded to a multiple */ 2091 /* of the algorithms block size */ 2092 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); 2093 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 2094 plaintext_pad_len); 2095 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len); 2096 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 2097 2098 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len); 2099 2100 /* Create KASUMI operation */ 2101 retval = create_snow3g_kasumi_cipher_operation_oop(tdata->iv.data, 2102 tdata->iv.len, 2103 tdata->plaintext.len, 2104 tdata->validCipherOffsetLenInBits.len, 2105 RTE_CRYPTO_CIPHER_KASUMI_F8); 2106 if (retval < 0) 2107 return retval; 2108 2109 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 2110 ut_params->op); 2111 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 2112 2113 ut_params->obuf = ut_params->op->sym->m_dst; 2114 if (ut_params->obuf) 2115 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 2116 + tdata->iv.len; 2117 else 2118 ciphertext = plaintext; 2119 2120 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len); 2121 2122 /* Validate obuf */ 2123 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 2124 ciphertext, 2125 tdata->ciphertext.data, 2126 tdata->validCipherLenInBits.len, 2127 "KASUMI Ciphertext data not as expected"); 2128 return 0; 2129 } 2130 2131 static int 2132 test_kasumi_decryption_oop(const struct kasumi_test_data *tdata) 2133 { 2134 struct crypto_testsuite_params *ts_params = &testsuite_params; 2135 struct crypto_unittest_params *ut_params = &unittest_params; 2136 2137 int retval; 2138 uint8_t *ciphertext, *plaintext; 2139 unsigned ciphertext_pad_len; 2140 unsigned ciphertext_len; 2141 2142 /* Create KASUMI session */ 2143 retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0], 2144 RTE_CRYPTO_CIPHER_OP_DECRYPT, 2145 RTE_CRYPTO_CIPHER_KASUMI_F8, 2146 tdata->key.data, tdata->key.len); 2147 if (retval < 0) 2148 return retval; 2149 2150 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 2151 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 2152 2153 /* Clear mbuf payload */ 2154 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 2155 rte_pktmbuf_tailroom(ut_params->ibuf)); 2156 2157 ciphertext_len = ceil_byte_length(tdata->ciphertext.len); 2158 /* Append data which is padded to a multiple */ 2159 /* of the algorithms block size */ 2160 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8); 2161 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 2162 ciphertext_pad_len); 2163 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len); 2164 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len); 2165 2166 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len); 2167 2168 /* Create KASUMI operation */ 2169 retval = create_snow3g_kasumi_cipher_operation_oop(tdata->iv.data, 2170 tdata->iv.len, 2171 tdata->ciphertext.len, 2172 tdata->validCipherOffsetLenInBits.len, 2173 RTE_CRYPTO_CIPHER_KASUMI_F8); 2174 if (retval < 0) 2175 return retval; 2176 2177 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 2178 ut_params->op); 2179 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 2180 2181 ut_params->obuf = ut_params->op->sym->m_dst; 2182 if (ut_params->obuf) 2183 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 2184 + tdata->iv.len; 2185 else 2186 plaintext = ciphertext; 2187 2188 TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len); 2189 2190 /* Validate obuf */ 2191 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 2192 plaintext, 2193 tdata->plaintext.data, 2194 tdata->validCipherLenInBits.len, 2195 "KASUMI Plaintext data not as expected"); 2196 return 0; 2197 } 2198 2199 static int 2200 test_kasumi_decryption(const struct kasumi_test_data *tdata) 2201 { 2202 struct crypto_testsuite_params *ts_params = &testsuite_params; 2203 struct crypto_unittest_params *ut_params = &unittest_params; 2204 2205 int retval; 2206 uint8_t *ciphertext, *plaintext; 2207 unsigned ciphertext_pad_len; 2208 unsigned ciphertext_len; 2209 2210 /* Create KASUMI session */ 2211 retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0], 2212 RTE_CRYPTO_CIPHER_OP_DECRYPT, 2213 RTE_CRYPTO_CIPHER_KASUMI_F8, 2214 tdata->key.data, tdata->key.len); 2215 if (retval < 0) 2216 return retval; 2217 2218 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 2219 2220 /* Clear mbuf payload */ 2221 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 2222 rte_pktmbuf_tailroom(ut_params->ibuf)); 2223 2224 ciphertext_len = ceil_byte_length(tdata->ciphertext.len); 2225 /* Append data which is padded to a multiple */ 2226 /* of the algorithms block size */ 2227 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8); 2228 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 2229 ciphertext_pad_len); 2230 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len); 2231 2232 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len); 2233 2234 /* Create KASUMI operation */ 2235 retval = create_snow3g_kasumi_cipher_operation(tdata->iv.data, 2236 tdata->iv.len, 2237 tdata->ciphertext.len, 2238 tdata->validCipherOffsetLenInBits.len, 2239 RTE_CRYPTO_CIPHER_KASUMI_F8); 2240 if (retval < 0) 2241 return retval; 2242 2243 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 2244 ut_params->op); 2245 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 2246 2247 ut_params->obuf = ut_params->op->sym->m_dst; 2248 if (ut_params->obuf) 2249 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 2250 + tdata->iv.len; 2251 else 2252 plaintext = ciphertext; 2253 2254 TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len); 2255 2256 /* Validate obuf */ 2257 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 2258 plaintext, 2259 tdata->plaintext.data, 2260 tdata->validCipherLenInBits.len, 2261 "KASUMI Plaintext data not as expected"); 2262 return 0; 2263 } 2264 2265 static int 2266 test_snow3g_encryption(const struct snow3g_test_data *tdata) 2267 { 2268 struct crypto_testsuite_params *ts_params = &testsuite_params; 2269 struct crypto_unittest_params *ut_params = &unittest_params; 2270 2271 int retval; 2272 uint8_t *plaintext, *ciphertext; 2273 unsigned plaintext_pad_len; 2274 unsigned plaintext_len; 2275 2276 /* Create SNOW3G session */ 2277 retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0], 2278 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 2279 RTE_CRYPTO_CIPHER_SNOW3G_UEA2, 2280 tdata->key.data, tdata->key.len); 2281 if (retval < 0) 2282 return retval; 2283 2284 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 2285 2286 /* Clear mbuf payload */ 2287 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 2288 rte_pktmbuf_tailroom(ut_params->ibuf)); 2289 2290 plaintext_len = ceil_byte_length(tdata->plaintext.len); 2291 /* Append data which is padded to a multiple of */ 2292 /* the algorithms block size */ 2293 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); 2294 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 2295 plaintext_pad_len); 2296 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 2297 2298 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len); 2299 2300 /* Create SNOW3G operation */ 2301 retval = create_snow3g_kasumi_cipher_operation(tdata->iv.data, tdata->iv.len, 2302 tdata->validCipherLenInBits.len, 2303 tdata->validCipherOffsetLenInBits.len, 2304 RTE_CRYPTO_CIPHER_SNOW3G_UEA2); 2305 if (retval < 0) 2306 return retval; 2307 2308 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 2309 ut_params->op); 2310 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 2311 2312 ut_params->obuf = ut_params->op->sym->m_dst; 2313 if (ut_params->obuf) 2314 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 2315 + tdata->iv.len; 2316 else 2317 ciphertext = plaintext; 2318 2319 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len); 2320 2321 /* Validate obuf */ 2322 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 2323 ciphertext, 2324 tdata->ciphertext.data, 2325 tdata->validDataLenInBits.len, 2326 "Snow3G Ciphertext data not as expected"); 2327 return 0; 2328 } 2329 2330 2331 static int 2332 test_snow3g_encryption_oop(const struct snow3g_test_data *tdata) 2333 { 2334 struct crypto_testsuite_params *ts_params = &testsuite_params; 2335 struct crypto_unittest_params *ut_params = &unittest_params; 2336 uint8_t *plaintext, *ciphertext; 2337 2338 int retval; 2339 unsigned plaintext_pad_len; 2340 unsigned plaintext_len; 2341 2342 /* Create SNOW3G session */ 2343 retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0], 2344 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 2345 RTE_CRYPTO_CIPHER_SNOW3G_UEA2, 2346 tdata->key.data, tdata->key.len); 2347 if (retval < 0) 2348 return retval; 2349 2350 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 2351 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 2352 2353 TEST_ASSERT_NOT_NULL(ut_params->ibuf, 2354 "Failed to allocate input buffer in mempool"); 2355 TEST_ASSERT_NOT_NULL(ut_params->obuf, 2356 "Failed to allocate output buffer in mempool"); 2357 2358 /* Clear mbuf payload */ 2359 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 2360 rte_pktmbuf_tailroom(ut_params->ibuf)); 2361 2362 plaintext_len = ceil_byte_length(tdata->plaintext.len); 2363 /* Append data which is padded to a multiple of */ 2364 /* the algorithms block size */ 2365 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); 2366 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 2367 plaintext_pad_len); 2368 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len); 2369 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 2370 2371 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len); 2372 2373 /* Create SNOW3G operation */ 2374 retval = create_snow3g_kasumi_cipher_operation_oop(tdata->iv.data, 2375 tdata->iv.len, 2376 tdata->validCipherLenInBits.len, 2377 tdata->validCipherOffsetLenInBits.len, 2378 RTE_CRYPTO_CIPHER_SNOW3G_UEA2); 2379 if (retval < 0) 2380 return retval; 2381 2382 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 2383 ut_params->op); 2384 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 2385 2386 ut_params->obuf = ut_params->op->sym->m_dst; 2387 if (ut_params->obuf) 2388 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 2389 + tdata->iv.len; 2390 else 2391 ciphertext = plaintext; 2392 2393 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len); 2394 2395 /* Validate obuf */ 2396 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 2397 ciphertext, 2398 tdata->ciphertext.data, 2399 tdata->validDataLenInBits.len, 2400 "Snow3G Ciphertext data not as expected"); 2401 return 0; 2402 } 2403 2404 /* Shift right a buffer by "offset" bits, "offset" < 8 */ 2405 static void 2406 buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset) 2407 { 2408 uint8_t curr_byte, prev_byte; 2409 uint32_t length_in_bytes = ceil_byte_length(length + offset); 2410 uint8_t lower_byte_mask = (1 << offset) - 1; 2411 unsigned i; 2412 2413 prev_byte = buffer[0]; 2414 buffer[0] >>= offset; 2415 2416 for (i = 1; i < length_in_bytes; i++) { 2417 curr_byte = buffer[i]; 2418 buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) | 2419 (curr_byte >> offset); 2420 prev_byte = curr_byte; 2421 } 2422 } 2423 2424 static int 2425 test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata) 2426 { 2427 struct crypto_testsuite_params *ts_params = &testsuite_params; 2428 struct crypto_unittest_params *ut_params = &unittest_params; 2429 uint8_t *plaintext, *ciphertext; 2430 int retval; 2431 uint32_t plaintext_len; 2432 uint32_t plaintext_pad_len; 2433 uint8_t extra_offset = 4; 2434 uint8_t *expected_ciphertext_shifted; 2435 2436 /* Create SNOW3G session */ 2437 retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0], 2438 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 2439 RTE_CRYPTO_CIPHER_SNOW3G_UEA2, 2440 tdata->key.data, tdata->key.len); 2441 if (retval < 0) 2442 return retval; 2443 2444 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 2445 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 2446 2447 TEST_ASSERT_NOT_NULL(ut_params->ibuf, 2448 "Failed to allocate input buffer in mempool"); 2449 TEST_ASSERT_NOT_NULL(ut_params->obuf, 2450 "Failed to allocate output buffer in mempool"); 2451 2452 /* Clear mbuf payload */ 2453 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 2454 rte_pktmbuf_tailroom(ut_params->ibuf)); 2455 2456 plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset); 2457 /* 2458 * Append data which is padded to a 2459 * multiple of the algorithms block size 2460 */ 2461 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); 2462 2463 plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf, 2464 plaintext_pad_len); 2465 2466 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len); 2467 2468 memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3)); 2469 buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset); 2470 2471 #ifdef RTE_APP_TEST_DEBUG 2472 rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len); 2473 #endif 2474 /* Create SNOW3G operation */ 2475 retval = create_snow3g_kasumi_cipher_operation_oop(tdata->iv.data, 2476 tdata->iv.len, 2477 tdata->validCipherLenInBits.len, 2478 tdata->validCipherOffsetLenInBits.len + 2479 extra_offset, 2480 RTE_CRYPTO_CIPHER_SNOW3G_UEA2); 2481 if (retval < 0) 2482 return retval; 2483 2484 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 2485 ut_params->op); 2486 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 2487 2488 ut_params->obuf = ut_params->op->sym->m_dst; 2489 if (ut_params->obuf) 2490 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 2491 + tdata->iv.len; 2492 else 2493 ciphertext = plaintext; 2494 2495 #ifdef RTE_APP_TEST_DEBUG 2496 rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len); 2497 #endif 2498 2499 expected_ciphertext_shifted = rte_malloc(NULL, 2500 ceil_byte_length(plaintext_len + extra_offset), 0); 2501 2502 TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted, 2503 "failed to reserve memory for ciphertext shifted\n"); 2504 2505 memcpy(expected_ciphertext_shifted, tdata->ciphertext.data, 2506 ceil_byte_length(tdata->ciphertext.len)); 2507 buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len, 2508 extra_offset); 2509 /* Validate obuf */ 2510 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET( 2511 ciphertext, 2512 expected_ciphertext_shifted, 2513 tdata->validDataLenInBits.len, 2514 extra_offset, 2515 "Snow3G Ciphertext data not as expected"); 2516 return 0; 2517 } 2518 2519 static int test_snow3g_decryption(const struct snow3g_test_data *tdata) 2520 { 2521 struct crypto_testsuite_params *ts_params = &testsuite_params; 2522 struct crypto_unittest_params *ut_params = &unittest_params; 2523 2524 int retval; 2525 2526 uint8_t *plaintext, *ciphertext; 2527 unsigned ciphertext_pad_len; 2528 unsigned ciphertext_len; 2529 2530 /* Create SNOW3G session */ 2531 retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0], 2532 RTE_CRYPTO_CIPHER_OP_DECRYPT, 2533 RTE_CRYPTO_CIPHER_SNOW3G_UEA2, 2534 tdata->key.data, tdata->key.len); 2535 if (retval < 0) 2536 return retval; 2537 2538 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 2539 2540 /* Clear mbuf payload */ 2541 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 2542 rte_pktmbuf_tailroom(ut_params->ibuf)); 2543 2544 ciphertext_len = ceil_byte_length(tdata->ciphertext.len); 2545 /* Append data which is padded to a multiple of */ 2546 /* the algorithms block size */ 2547 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16); 2548 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 2549 ciphertext_pad_len); 2550 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len); 2551 2552 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len); 2553 2554 /* Create SNOW3G operation */ 2555 retval = create_snow3g_kasumi_cipher_operation(tdata->iv.data, tdata->iv.len, 2556 tdata->validCipherLenInBits.len, 2557 tdata->validCipherOffsetLenInBits.len, 2558 RTE_CRYPTO_CIPHER_SNOW3G_UEA2); 2559 if (retval < 0) 2560 return retval; 2561 2562 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 2563 ut_params->op); 2564 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 2565 ut_params->obuf = ut_params->op->sym->m_dst; 2566 if (ut_params->obuf) 2567 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 2568 + tdata->iv.len; 2569 else 2570 plaintext = ciphertext; 2571 2572 TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len); 2573 2574 /* Validate obuf */ 2575 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext, 2576 tdata->plaintext.data, 2577 tdata->validDataLenInBits.len, 2578 "Snow3G Plaintext data not as expected"); 2579 return 0; 2580 } 2581 2582 static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata) 2583 { 2584 struct crypto_testsuite_params *ts_params = &testsuite_params; 2585 struct crypto_unittest_params *ut_params = &unittest_params; 2586 2587 int retval; 2588 2589 uint8_t *plaintext, *ciphertext; 2590 unsigned ciphertext_pad_len; 2591 unsigned ciphertext_len; 2592 2593 /* Create SNOW3G session */ 2594 retval = create_snow3g_kasumi_cipher_session(ts_params->valid_devs[0], 2595 RTE_CRYPTO_CIPHER_OP_DECRYPT, 2596 RTE_CRYPTO_CIPHER_SNOW3G_UEA2, 2597 tdata->key.data, tdata->key.len); 2598 if (retval < 0) 2599 return retval; 2600 2601 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 2602 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 2603 2604 TEST_ASSERT_NOT_NULL(ut_params->ibuf, 2605 "Failed to allocate input buffer"); 2606 TEST_ASSERT_NOT_NULL(ut_params->obuf, 2607 "Failed to allocate output buffer"); 2608 2609 /* Clear mbuf payload */ 2610 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 2611 rte_pktmbuf_tailroom(ut_params->ibuf)); 2612 2613 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0, 2614 rte_pktmbuf_tailroom(ut_params->obuf)); 2615 2616 ciphertext_len = ceil_byte_length(tdata->ciphertext.len); 2617 /* Append data which is padded to a multiple of */ 2618 /* the algorithms block size */ 2619 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16); 2620 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 2621 ciphertext_pad_len); 2622 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len); 2623 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len); 2624 2625 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len); 2626 2627 /* Create SNOW3G operation */ 2628 retval = create_snow3g_kasumi_cipher_operation_oop(tdata->iv.data, 2629 tdata->iv.len, 2630 tdata->validCipherLenInBits.len, 2631 tdata->validCipherOffsetLenInBits.len, 2632 RTE_CRYPTO_CIPHER_SNOW3G_UEA2); 2633 if (retval < 0) 2634 return retval; 2635 2636 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 2637 ut_params->op); 2638 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 2639 ut_params->obuf = ut_params->op->sym->m_dst; 2640 if (ut_params->obuf) 2641 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 2642 + tdata->iv.len; 2643 else 2644 plaintext = ciphertext; 2645 2646 TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len); 2647 2648 /* Validate obuf */ 2649 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext, 2650 tdata->plaintext.data, 2651 tdata->validDataLenInBits.len, 2652 "Snow3G Plaintext data not as expected"); 2653 return 0; 2654 } 2655 2656 static int 2657 test_snow3g_authenticated_encryption(const struct snow3g_test_data *tdata) 2658 { 2659 struct crypto_testsuite_params *ts_params = &testsuite_params; 2660 struct crypto_unittest_params *ut_params = &unittest_params; 2661 2662 int retval; 2663 2664 uint8_t *plaintext, *ciphertext; 2665 unsigned plaintext_pad_len; 2666 unsigned plaintext_len; 2667 2668 /* Create SNOW3G session */ 2669 retval = create_snow3g_kasumi_cipher_auth_session(ts_params->valid_devs[0], 2670 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 2671 RTE_CRYPTO_AUTH_OP_GENERATE, 2672 RTE_CRYPTO_AUTH_SNOW3G_UIA2, 2673 RTE_CRYPTO_CIPHER_SNOW3G_UEA2, 2674 tdata->key.data, tdata->key.len, 2675 tdata->aad.len, tdata->digest.len); 2676 if (retval < 0) 2677 return retval; 2678 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 2679 2680 /* clear mbuf payload */ 2681 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 2682 rte_pktmbuf_tailroom(ut_params->ibuf)); 2683 2684 plaintext_len = ceil_byte_length(tdata->plaintext.len); 2685 /* Append data which is padded to a multiple of */ 2686 /* the algorithms block size */ 2687 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); 2688 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 2689 plaintext_pad_len); 2690 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 2691 2692 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len); 2693 2694 /* Create SNOW3G operation */ 2695 retval = create_snow3g_kasumi_cipher_hash_operation(tdata->digest.data, 2696 tdata->digest.len, tdata->aad.data, 2697 tdata->aad.len, /*tdata->plaintext.len,*/ 2698 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE, 2699 RTE_CRYPTO_AUTH_SNOW3G_UIA2, 2700 RTE_CRYPTO_CIPHER_SNOW3G_UEA2, 2701 tdata->iv.data, tdata->iv.len, 2702 tdata->validCipherLenInBits.len, 2703 tdata->validCipherOffsetLenInBits.len, 2704 tdata->validAuthLenInBits.len, 2705 tdata->validAuthOffsetLenInBits.len 2706 ); 2707 if (retval < 0) 2708 return retval; 2709 2710 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 2711 ut_params->op); 2712 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 2713 ut_params->obuf = ut_params->op->sym->m_src; 2714 if (ut_params->obuf) 2715 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 2716 + tdata->iv.len; 2717 else 2718 ciphertext = plaintext; 2719 2720 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len); 2721 2722 /* Validate obuf */ 2723 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 2724 ciphertext, 2725 tdata->ciphertext.data, 2726 tdata->validDataLenInBits.len, 2727 "Snow3G Ciphertext data not as expected"); 2728 2729 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 2730 + plaintext_pad_len + tdata->aad.len; 2731 2732 /* Validate obuf */ 2733 TEST_ASSERT_BUFFERS_ARE_EQUAL( 2734 ut_params->digest, 2735 tdata->digest.data, 2736 DIGEST_BYTE_LENGTH_SNOW3G_UIA2, 2737 "Snow3G Generated auth tag not as expected"); 2738 return 0; 2739 } 2740 static int 2741 test_snow3g_encrypted_authentication(const struct snow3g_test_data *tdata) 2742 { 2743 struct crypto_testsuite_params *ts_params = &testsuite_params; 2744 struct crypto_unittest_params *ut_params = &unittest_params; 2745 2746 int retval; 2747 2748 uint8_t *plaintext, *ciphertext; 2749 unsigned plaintext_pad_len; 2750 unsigned plaintext_len; 2751 2752 /* Create SNOW3G session */ 2753 retval = create_snow3g_kasumi_auth_cipher_session(ts_params->valid_devs[0], 2754 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 2755 RTE_CRYPTO_AUTH_OP_GENERATE, 2756 RTE_CRYPTO_AUTH_SNOW3G_UIA2, 2757 RTE_CRYPTO_CIPHER_SNOW3G_UEA2, 2758 tdata->key.data, tdata->key.len, 2759 tdata->aad.len, tdata->digest.len); 2760 if (retval < 0) 2761 return retval; 2762 2763 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 2764 2765 /* clear mbuf payload */ 2766 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 2767 rte_pktmbuf_tailroom(ut_params->ibuf)); 2768 2769 plaintext_len = ceil_byte_length(tdata->plaintext.len); 2770 /* Append data which is padded to a multiple of */ 2771 /* the algorithms block size */ 2772 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); 2773 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 2774 plaintext_pad_len); 2775 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 2776 2777 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len); 2778 2779 /* Create SNOW3G operation */ 2780 retval = create_snow3g_kasumi_auth_cipher_operation( 2781 tdata->digest.len, 2782 tdata->iv.data, tdata->iv.len, 2783 tdata->aad.data, tdata->aad.len, 2784 plaintext_pad_len, 2785 tdata->validCipherLenInBits.len, 2786 tdata->validCipherOffsetLenInBits.len, 2787 tdata->validAuthLenInBits.len, 2788 tdata->validAuthOffsetLenInBits.len, 2789 RTE_CRYPTO_AUTH_SNOW3G_UIA2, 2790 RTE_CRYPTO_CIPHER_SNOW3G_UEA2 2791 ); 2792 2793 if (retval < 0) 2794 return retval; 2795 2796 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 2797 ut_params->op); 2798 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 2799 ut_params->obuf = ut_params->op->sym->m_src; 2800 if (ut_params->obuf) 2801 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 2802 + tdata->aad.len + tdata->iv.len; 2803 else 2804 ciphertext = plaintext; 2805 2806 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 2807 + plaintext_pad_len + tdata->aad.len + tdata->iv.len; 2808 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len); 2809 2810 /* Validate obuf */ 2811 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 2812 ciphertext, 2813 tdata->ciphertext.data, 2814 tdata->validDataLenInBits.len, 2815 "Snow3G Ciphertext data not as expected"); 2816 2817 /* Validate obuf */ 2818 TEST_ASSERT_BUFFERS_ARE_EQUAL( 2819 ut_params->digest, 2820 tdata->digest.data, 2821 DIGEST_BYTE_LENGTH_SNOW3G_UIA2, 2822 "Snow3G Generated auth tag not as expected"); 2823 return 0; 2824 } 2825 2826 static int 2827 test_kasumi_encryption_test_case_1(void) 2828 { 2829 return test_kasumi_encryption(&kasumi_test_case_1); 2830 } 2831 2832 static int 2833 test_kasumi_encryption_test_case_1_oop(void) 2834 { 2835 return test_kasumi_encryption_oop(&kasumi_test_case_1); 2836 } 2837 2838 static int 2839 test_kasumi_encryption_test_case_2(void) 2840 { 2841 return test_kasumi_encryption(&kasumi_test_case_2); 2842 } 2843 2844 static int 2845 test_kasumi_encryption_test_case_3(void) 2846 { 2847 return test_kasumi_encryption(&kasumi_test_case_3); 2848 } 2849 2850 static int 2851 test_kasumi_encryption_test_case_4(void) 2852 { 2853 return test_kasumi_encryption(&kasumi_test_case_4); 2854 } 2855 2856 static int 2857 test_kasumi_encryption_test_case_5(void) 2858 { 2859 return test_kasumi_encryption(&kasumi_test_case_5); 2860 } 2861 2862 static int 2863 test_kasumi_decryption_test_case_1(void) 2864 { 2865 return test_kasumi_decryption(&kasumi_test_case_1); 2866 } 2867 2868 static int 2869 test_kasumi_decryption_test_case_1_oop(void) 2870 { 2871 return test_kasumi_decryption_oop(&kasumi_test_case_1); 2872 } 2873 2874 static int 2875 test_kasumi_decryption_test_case_2(void) 2876 { 2877 return test_kasumi_decryption(&kasumi_test_case_2); 2878 } 2879 2880 static int 2881 test_kasumi_decryption_test_case_3(void) 2882 { 2883 return test_kasumi_decryption(&kasumi_test_case_3); 2884 } 2885 2886 static int 2887 test_kasumi_decryption_test_case_4(void) 2888 { 2889 return test_kasumi_decryption(&kasumi_test_case_4); 2890 } 2891 2892 static int 2893 test_kasumi_decryption_test_case_5(void) 2894 { 2895 return test_kasumi_decryption(&kasumi_test_case_5); 2896 } 2897 static int 2898 test_snow3g_encryption_test_case_1(void) 2899 { 2900 return test_snow3g_encryption(&snow3g_test_case_1); 2901 } 2902 2903 static int 2904 test_snow3g_encryption_test_case_1_oop(void) 2905 { 2906 return test_snow3g_encryption_oop(&snow3g_test_case_1); 2907 } 2908 2909 static int 2910 test_snow3g_encryption_test_case_1_offset_oop(void) 2911 { 2912 return test_snow3g_encryption_offset_oop(&snow3g_test_case_1); 2913 } 2914 2915 static int 2916 test_snow3g_encryption_test_case_2(void) 2917 { 2918 return test_snow3g_encryption(&snow3g_test_case_2); 2919 } 2920 2921 static int 2922 test_snow3g_encryption_test_case_3(void) 2923 { 2924 return test_snow3g_encryption(&snow3g_test_case_3); 2925 } 2926 2927 static int 2928 test_snow3g_encryption_test_case_4(void) 2929 { 2930 return test_snow3g_encryption(&snow3g_test_case_4); 2931 } 2932 2933 static int 2934 test_snow3g_encryption_test_case_5(void) 2935 { 2936 return test_snow3g_encryption(&snow3g_test_case_5); 2937 } 2938 2939 static int 2940 test_snow3g_decryption_test_case_1(void) 2941 { 2942 return test_snow3g_decryption(&snow3g_test_case_1); 2943 } 2944 2945 static int 2946 test_snow3g_decryption_test_case_1_oop(void) 2947 { 2948 return test_snow3g_decryption_oop(&snow3g_test_case_1); 2949 } 2950 2951 static int 2952 test_snow3g_decryption_test_case_2(void) 2953 { 2954 return test_snow3g_decryption(&snow3g_test_case_2); 2955 } 2956 2957 static int 2958 test_snow3g_decryption_test_case_3(void) 2959 { 2960 return test_snow3g_decryption(&snow3g_test_case_3); 2961 } 2962 2963 static int 2964 test_snow3g_decryption_test_case_4(void) 2965 { 2966 return test_snow3g_decryption(&snow3g_test_case_4); 2967 } 2968 2969 static int 2970 test_snow3g_decryption_test_case_5(void) 2971 { 2972 return test_snow3g_decryption(&snow3g_test_case_5); 2973 } 2974 static int 2975 test_snow3g_authenticated_encryption_test_case_1(void) 2976 { 2977 return test_snow3g_authenticated_encryption(&snow3g_test_case_3); 2978 } 2979 2980 static int 2981 test_snow3g_encrypted_authentication_test_case_1(void) 2982 { 2983 return test_snow3g_encrypted_authentication(&snow3g_test_case_6); 2984 } 2985 2986 /* ***** AES-GCM Tests ***** */ 2987 2988 static int 2989 create_gcm_session(uint8_t dev_id, enum rte_crypto_cipher_operation op, 2990 const uint8_t *key, const uint8_t key_len, 2991 const uint8_t aad_len, const uint8_t auth_len) 2992 { 2993 uint8_t cipher_key[key_len]; 2994 2995 struct crypto_unittest_params *ut_params = &unittest_params; 2996 2997 2998 memcpy(cipher_key, key, key_len); 2999 3000 /* Setup Cipher Parameters */ 3001 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 3002 ut_params->cipher_xform.next = NULL; 3003 3004 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_GCM; 3005 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; 3006 ut_params->cipher_xform.cipher.op = op; 3007 ut_params->cipher_xform.cipher.key.data = cipher_key; 3008 ut_params->cipher_xform.cipher.key.length = key_len; 3009 3010 TEST_HEXDUMP(stdout, "key:", key, key_len); 3011 3012 /* Setup Authentication Parameters */ 3013 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 3014 ut_params->auth_xform.next = NULL; 3015 3016 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GCM; 3017 3018 ut_params->auth_xform.auth.digest_length = auth_len; 3019 ut_params->auth_xform.auth.add_auth_data_length = aad_len; 3020 ut_params->auth_xform.auth.key.length = 0; 3021 ut_params->auth_xform.auth.key.data = NULL; 3022 3023 if (op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) { 3024 ut_params->cipher_xform.next = &ut_params->auth_xform; 3025 3026 /* Create Crypto session*/ 3027 ut_params->sess = rte_cryptodev_sym_session_create(dev_id, 3028 &ut_params->cipher_xform); 3029 } else {/* Create Crypto session*/ 3030 ut_params->auth_xform.next = &ut_params->cipher_xform; 3031 ut_params->sess = rte_cryptodev_sym_session_create(dev_id, 3032 &ut_params->auth_xform); 3033 } 3034 3035 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 3036 3037 return 0; 3038 } 3039 3040 static int 3041 create_gcm_operation(enum rte_crypto_cipher_operation op, 3042 const uint8_t *auth_tag, const unsigned auth_tag_len, 3043 const uint8_t *iv, const unsigned iv_len, 3044 const uint8_t *aad, const unsigned aad_len, 3045 const unsigned data_len, unsigned data_pad_len) 3046 { 3047 struct crypto_testsuite_params *ts_params = &testsuite_params; 3048 struct crypto_unittest_params *ut_params = &unittest_params; 3049 3050 unsigned iv_pad_len = 0, aad_buffer_len; 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 symmetric crypto operation struct"); 3057 3058 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 3059 3060 3061 3062 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( 3063 ut_params->ibuf, auth_tag_len); 3064 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, 3065 "no room to append digest"); 3066 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( 3067 ut_params->ibuf, data_pad_len); 3068 sym_op->auth.digest.length = auth_tag_len; 3069 3070 if (op == RTE_CRYPTO_CIPHER_OP_DECRYPT) { 3071 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len); 3072 TEST_HEXDUMP(stdout, "digest:", 3073 sym_op->auth.digest.data, 3074 sym_op->auth.digest.length); 3075 } 3076 3077 /* iv */ 3078 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16); 3079 3080 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend( 3081 ut_params->ibuf, iv_pad_len); 3082 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv"); 3083 3084 memset(sym_op->cipher.iv.data, 0, iv_pad_len); 3085 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); 3086 sym_op->cipher.iv.length = iv_pad_len; 3087 3088 rte_memcpy(sym_op->cipher.iv.data, iv, iv_len); 3089 3090 /* CalcY0 */ 3091 if (iv_len != 16) 3092 sym_op->cipher.iv.data[15] = 1; 3093 3094 /* 3095 * Always allocate the aad up to the block size. 3096 * The cryptodev API calls out - 3097 * - the array must be big enough to hold the AAD, plus any 3098 * space to round this up to the nearest multiple of the 3099 * block size (16 bytes). 3100 */ 3101 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16); 3102 3103 sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend( 3104 ut_params->ibuf, aad_buffer_len); 3105 TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data, 3106 "no room to prepend aad"); 3107 sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys( 3108 ut_params->ibuf); 3109 sym_op->auth.aad.length = aad_len; 3110 3111 memset(sym_op->auth.aad.data, 0, aad_buffer_len); 3112 rte_memcpy(sym_op->auth.aad.data, aad, aad_len); 3113 3114 TEST_HEXDUMP(stdout, "iv:", sym_op->cipher.iv.data, iv_pad_len); 3115 TEST_HEXDUMP(stdout, "aad:", 3116 sym_op->auth.aad.data, aad_len); 3117 3118 sym_op->cipher.data.length = data_len; 3119 sym_op->cipher.data.offset = aad_buffer_len + iv_pad_len; 3120 3121 sym_op->auth.data.offset = aad_buffer_len + iv_pad_len; 3122 sym_op->auth.data.length = data_len; 3123 3124 return 0; 3125 } 3126 3127 static int 3128 test_mb_AES_GCM_authenticated_encryption(const struct gcm_test_data *tdata) 3129 { 3130 struct crypto_testsuite_params *ts_params = &testsuite_params; 3131 struct crypto_unittest_params *ut_params = &unittest_params; 3132 3133 int retval; 3134 3135 uint8_t *plaintext, *ciphertext, *auth_tag; 3136 uint16_t plaintext_pad_len; 3137 3138 /* Create GCM session */ 3139 retval = create_gcm_session(ts_params->valid_devs[0], 3140 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 3141 tdata->key.data, tdata->key.len, 3142 tdata->aad.len, tdata->auth_tag.len); 3143 if (retval < 0) 3144 return retval; 3145 3146 3147 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 3148 3149 /* clear mbuf payload */ 3150 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 3151 rte_pktmbuf_tailroom(ut_params->ibuf)); 3152 3153 /* 3154 * Append data which is padded to a multiple 3155 * of the algorithms block size 3156 */ 3157 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16); 3158 3159 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 3160 plaintext_pad_len); 3161 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len); 3162 3163 TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->plaintext.len); 3164 3165 /* Create GCM opertaion */ 3166 retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_ENCRYPT, 3167 tdata->auth_tag.data, tdata->auth_tag.len, 3168 tdata->iv.data, tdata->iv.len, 3169 tdata->aad.data, tdata->aad.len, 3170 tdata->plaintext.len, plaintext_pad_len); 3171 if (retval < 0) 3172 return retval; 3173 3174 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 3175 3176 ut_params->op->sym->m_src = ut_params->ibuf; 3177 3178 /* Process crypto operation */ 3179 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], 3180 ut_params->op), "failed to process sym crypto op"); 3181 3182 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 3183 "crypto op processing failed"); 3184 3185 if (ut_params->op->sym->m_dst) { 3186 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst, 3187 uint8_t *); 3188 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst, 3189 uint8_t *, plaintext_pad_len); 3190 } else { 3191 ciphertext = plaintext; 3192 auth_tag = plaintext + plaintext_pad_len; 3193 } 3194 3195 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len); 3196 TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->auth_tag.len); 3197 3198 /* Validate obuf */ 3199 TEST_ASSERT_BUFFERS_ARE_EQUAL( 3200 ciphertext, 3201 tdata->ciphertext.data, 3202 tdata->ciphertext.len, 3203 "GCM Ciphertext data not as expected"); 3204 3205 TEST_ASSERT_BUFFERS_ARE_EQUAL( 3206 auth_tag, 3207 tdata->auth_tag.data, 3208 tdata->auth_tag.len, 3209 "GCM Generated auth tag not as expected"); 3210 3211 return 0; 3212 3213 } 3214 3215 static int 3216 test_mb_AES_GCM_authenticated_encryption_test_case_1(void) 3217 { 3218 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_1); 3219 } 3220 3221 static int 3222 test_mb_AES_GCM_authenticated_encryption_test_case_2(void) 3223 { 3224 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_2); 3225 } 3226 3227 static int 3228 test_mb_AES_GCM_authenticated_encryption_test_case_3(void) 3229 { 3230 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_3); 3231 } 3232 3233 static int 3234 test_mb_AES_GCM_authenticated_encryption_test_case_4(void) 3235 { 3236 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_4); 3237 } 3238 3239 static int 3240 test_mb_AES_GCM_authenticated_encryption_test_case_5(void) 3241 { 3242 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_5); 3243 } 3244 3245 static int 3246 test_mb_AES_GCM_authenticated_encryption_test_case_6(void) 3247 { 3248 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_6); 3249 } 3250 3251 static int 3252 test_mb_AES_GCM_authenticated_encryption_test_case_7(void) 3253 { 3254 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_7); 3255 } 3256 3257 static int 3258 test_mb_AES_GCM_authenticated_decryption(const struct gcm_test_data *tdata) 3259 { 3260 struct crypto_testsuite_params *ts_params = &testsuite_params; 3261 struct crypto_unittest_params *ut_params = &unittest_params; 3262 3263 int retval; 3264 3265 uint8_t *plaintext, *ciphertext; 3266 uint16_t ciphertext_pad_len; 3267 3268 /* Create GCM session */ 3269 retval = create_gcm_session(ts_params->valid_devs[0], 3270 RTE_CRYPTO_CIPHER_OP_DECRYPT, 3271 tdata->key.data, tdata->key.len, 3272 tdata->aad.len, tdata->auth_tag.len); 3273 if (retval < 0) 3274 return retval; 3275 3276 3277 /* alloc mbuf and set payload */ 3278 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 3279 3280 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 3281 rte_pktmbuf_tailroom(ut_params->ibuf)); 3282 3283 ciphertext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16); 3284 3285 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 3286 ciphertext_pad_len); 3287 memcpy(ciphertext, tdata->ciphertext.data, tdata->ciphertext.len); 3288 3289 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len); 3290 3291 /* Create GCM opertaion */ 3292 retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_DECRYPT, 3293 tdata->auth_tag.data, tdata->auth_tag.len, 3294 tdata->iv.data, tdata->iv.len, 3295 tdata->aad.data, tdata->aad.len, 3296 tdata->ciphertext.len, ciphertext_pad_len); 3297 if (retval < 0) 3298 return retval; 3299 3300 3301 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 3302 3303 ut_params->op->sym->m_src = ut_params->ibuf; 3304 3305 /* Process crypto operation */ 3306 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], 3307 ut_params->op), "failed to process sym crypto op"); 3308 3309 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 3310 "crypto op processing failed"); 3311 3312 if (ut_params->op->sym->m_dst) 3313 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst, 3314 uint8_t *); 3315 else 3316 plaintext = ciphertext; 3317 3318 TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->ciphertext.len); 3319 3320 /* Validate obuf */ 3321 TEST_ASSERT_BUFFERS_ARE_EQUAL( 3322 plaintext, 3323 tdata->plaintext.data, 3324 tdata->plaintext.len, 3325 "GCM plaintext data not as expected"); 3326 3327 TEST_ASSERT_EQUAL(ut_params->op->status, 3328 RTE_CRYPTO_OP_STATUS_SUCCESS, 3329 "GCM authentication failed"); 3330 return 0; 3331 } 3332 3333 static int 3334 test_mb_AES_GCM_authenticated_decryption_test_case_1(void) 3335 { 3336 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_1); 3337 } 3338 3339 static int 3340 test_mb_AES_GCM_authenticated_decryption_test_case_2(void) 3341 { 3342 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_2); 3343 } 3344 3345 static int 3346 test_mb_AES_GCM_authenticated_decryption_test_case_3(void) 3347 { 3348 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_3); 3349 } 3350 3351 static int 3352 test_mb_AES_GCM_authenticated_decryption_test_case_4(void) 3353 { 3354 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_4); 3355 } 3356 3357 static int 3358 test_mb_AES_GCM_authenticated_decryption_test_case_5(void) 3359 { 3360 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_5); 3361 } 3362 3363 static int 3364 test_mb_AES_GCM_authenticated_decryption_test_case_6(void) 3365 { 3366 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_6); 3367 } 3368 3369 static int 3370 test_mb_AES_GCM_authenticated_decryption_test_case_7(void) 3371 { 3372 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_7); 3373 } 3374 3375 static int 3376 test_stats(void) 3377 { 3378 struct crypto_testsuite_params *ts_params = &testsuite_params; 3379 struct rte_cryptodev_stats stats; 3380 struct rte_cryptodev *dev; 3381 cryptodev_stats_get_t temp_pfn; 3382 3383 rte_cryptodev_stats_reset(ts_params->valid_devs[0]); 3384 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600, 3385 &stats) == -ENODEV), 3386 "rte_cryptodev_stats_get invalid dev failed"); 3387 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0), 3388 "rte_cryptodev_stats_get invalid Param failed"); 3389 dev = &rte_cryptodevs[ts_params->valid_devs[0]]; 3390 temp_pfn = dev->dev_ops->stats_get; 3391 dev->dev_ops->stats_get = (cryptodev_stats_get_t)0; 3392 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats) 3393 == -ENOTSUP), 3394 "rte_cryptodev_stats_get invalid Param failed"); 3395 dev->dev_ops->stats_get = temp_pfn; 3396 3397 /* Test expected values */ 3398 ut_setup(); 3399 test_AES_CBC_HMAC_SHA1_encrypt_digest(); 3400 ut_teardown(); 3401 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0], 3402 &stats), 3403 "rte_cryptodev_stats_get failed"); 3404 TEST_ASSERT((stats.enqueued_count == 1), 3405 "rte_cryptodev_stats_get returned unexpected enqueued stat"); 3406 TEST_ASSERT((stats.dequeued_count == 1), 3407 "rte_cryptodev_stats_get returned unexpected enqueued stat"); 3408 TEST_ASSERT((stats.enqueue_err_count == 0), 3409 "rte_cryptodev_stats_get returned unexpected enqueued stat"); 3410 TEST_ASSERT((stats.dequeue_err_count == 0), 3411 "rte_cryptodev_stats_get returned unexpected enqueued stat"); 3412 3413 /* invalid device but should ignore and not reset device stats*/ 3414 rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300); 3415 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0], 3416 &stats), 3417 "rte_cryptodev_stats_get failed"); 3418 TEST_ASSERT((stats.enqueued_count == 1), 3419 "rte_cryptodev_stats_get returned unexpected enqueued stat"); 3420 3421 /* check that a valid reset clears stats */ 3422 rte_cryptodev_stats_reset(ts_params->valid_devs[0]); 3423 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0], 3424 &stats), 3425 "rte_cryptodev_stats_get failed"); 3426 TEST_ASSERT((stats.enqueued_count == 0), 3427 "rte_cryptodev_stats_get returned unexpected enqueued stat"); 3428 TEST_ASSERT((stats.dequeued_count == 0), 3429 "rte_cryptodev_stats_get returned unexpected enqueued stat"); 3430 3431 return TEST_SUCCESS; 3432 } 3433 3434 3435 static int 3436 test_multi_session(void) 3437 { 3438 struct crypto_testsuite_params *ts_params = &testsuite_params; 3439 struct crypto_unittest_params *ut_params = &unittest_params; 3440 3441 struct rte_cryptodev_info dev_info; 3442 struct rte_cryptodev_sym_session **sessions; 3443 3444 uint16_t i; 3445 3446 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params); 3447 3448 3449 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 3450 3451 sessions = rte_malloc(NULL, 3452 (sizeof(struct rte_cryptodev_sym_session *) * 3453 dev_info.sym.max_nb_sessions) + 1, 0); 3454 3455 /* Create multiple crypto sessions*/ 3456 for (i = 0; i < dev_info.sym.max_nb_sessions; i++) { 3457 sessions[i] = rte_cryptodev_sym_session_create( 3458 ts_params->valid_devs[0], 3459 &ut_params->auth_xform); 3460 TEST_ASSERT_NOT_NULL(sessions[i], 3461 "Session creation failed at session number %u", 3462 i); 3463 3464 /* Attempt to send a request on each session */ 3465 TEST_ASSERT_SUCCESS(test_AES_CBC_HMAC_SHA512_decrypt_perform( 3466 sessions[i], ut_params, ts_params), 3467 "Failed to perform decrypt on request " 3468 "number %u.", i); 3469 /* free crypto operation structure */ 3470 if (ut_params->op) 3471 rte_crypto_op_free(ut_params->op); 3472 3473 /* 3474 * free mbuf - both obuf and ibuf are usually the same, 3475 * so check if they point at the same address is necessary, 3476 * to avoid freeing the mbuf twice. 3477 */ 3478 if (ut_params->obuf) { 3479 rte_pktmbuf_free(ut_params->obuf); 3480 if (ut_params->ibuf == ut_params->obuf) 3481 ut_params->ibuf = 0; 3482 ut_params->obuf = 0; 3483 } 3484 if (ut_params->ibuf) { 3485 rte_pktmbuf_free(ut_params->ibuf); 3486 ut_params->ibuf = 0; 3487 } 3488 } 3489 3490 /* Next session create should fail */ 3491 sessions[i] = rte_cryptodev_sym_session_create(ts_params->valid_devs[0], 3492 &ut_params->auth_xform); 3493 TEST_ASSERT_NULL(sessions[i], 3494 "Session creation succeeded unexpectedly!"); 3495 3496 for (i = 0; i < dev_info.sym.max_nb_sessions; i++) 3497 rte_cryptodev_sym_session_free(ts_params->valid_devs[0], 3498 sessions[i]); 3499 3500 rte_free(sessions); 3501 3502 return TEST_SUCCESS; 3503 } 3504 3505 static int 3506 test_null_cipher_only_operation(void) 3507 { 3508 struct crypto_testsuite_params *ts_params = &testsuite_params; 3509 struct crypto_unittest_params *ut_params = &unittest_params; 3510 3511 /* Generate test mbuf data and space for digest */ 3512 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool, 3513 catch_22_quote, QUOTE_512_BYTES, 0); 3514 3515 /* Setup Cipher Parameters */ 3516 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 3517 ut_params->cipher_xform.next = NULL; 3518 3519 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL; 3520 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; 3521 3522 /* Create Crypto session*/ 3523 ut_params->sess = rte_cryptodev_sym_session_create( 3524 ts_params->valid_devs[0], &ut_params->cipher_xform); 3525 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 3526 3527 /* Generate Crypto op data structure */ 3528 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 3529 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 3530 TEST_ASSERT_NOT_NULL(ut_params->op, 3531 "Failed to allocate symmetric crypto operation struct"); 3532 3533 /* Set crypto operation data parameters */ 3534 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 3535 3536 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 3537 3538 /* set crypto operation source mbuf */ 3539 sym_op->m_src = ut_params->ibuf; 3540 3541 sym_op->cipher.data.offset = 0; 3542 sym_op->cipher.data.length = QUOTE_512_BYTES; 3543 3544 /* Process crypto operation */ 3545 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 3546 ut_params->op); 3547 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned"); 3548 3549 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 3550 "crypto operation processing failed"); 3551 3552 /* Validate obuf */ 3553 TEST_ASSERT_BUFFERS_ARE_EQUAL( 3554 rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *), 3555 catch_22_quote, 3556 QUOTE_512_BYTES, 3557 "Ciphertext data not as expected"); 3558 3559 return TEST_SUCCESS; 3560 } 3561 3562 static int 3563 test_null_auth_only_operation(void) 3564 { 3565 struct crypto_testsuite_params *ts_params = &testsuite_params; 3566 struct crypto_unittest_params *ut_params = &unittest_params; 3567 3568 /* Generate test mbuf data and space for digest */ 3569 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool, 3570 catch_22_quote, QUOTE_512_BYTES, 0); 3571 3572 /* Setup HMAC Parameters */ 3573 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 3574 ut_params->auth_xform.next = NULL; 3575 3576 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL; 3577 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; 3578 3579 /* Create Crypto session*/ 3580 ut_params->sess = rte_cryptodev_sym_session_create( 3581 ts_params->valid_devs[0], &ut_params->auth_xform); 3582 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 3583 3584 /* Generate Crypto op data structure */ 3585 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 3586 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 3587 TEST_ASSERT_NOT_NULL(ut_params->op, 3588 "Failed to allocate symmetric crypto operation struct"); 3589 3590 /* Set crypto operation data parameters */ 3591 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 3592 3593 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 3594 3595 sym_op->m_src = ut_params->ibuf; 3596 3597 sym_op->auth.data.offset = 0; 3598 sym_op->auth.data.length = QUOTE_512_BYTES; 3599 3600 /* Process crypto operation */ 3601 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 3602 ut_params->op); 3603 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned"); 3604 3605 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 3606 "crypto operation processing failed"); 3607 3608 return TEST_SUCCESS; 3609 } 3610 3611 static int 3612 test_null_cipher_auth_operation(void) 3613 { 3614 struct crypto_testsuite_params *ts_params = &testsuite_params; 3615 struct crypto_unittest_params *ut_params = &unittest_params; 3616 3617 /* Generate test mbuf data and space for digest */ 3618 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool, 3619 catch_22_quote, QUOTE_512_BYTES, 0); 3620 3621 /* Setup Cipher Parameters */ 3622 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 3623 ut_params->cipher_xform.next = &ut_params->auth_xform; 3624 3625 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL; 3626 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; 3627 3628 /* Setup HMAC Parameters */ 3629 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 3630 ut_params->auth_xform.next = NULL; 3631 3632 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL; 3633 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; 3634 3635 /* Create Crypto session*/ 3636 ut_params->sess = rte_cryptodev_sym_session_create( 3637 ts_params->valid_devs[0], &ut_params->cipher_xform); 3638 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 3639 3640 /* Generate Crypto op data structure */ 3641 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 3642 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 3643 TEST_ASSERT_NOT_NULL(ut_params->op, 3644 "Failed to allocate symmetric crypto operation struct"); 3645 3646 /* Set crypto operation data parameters */ 3647 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 3648 3649 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 3650 3651 sym_op->m_src = ut_params->ibuf; 3652 3653 sym_op->cipher.data.offset = 0; 3654 sym_op->cipher.data.length = QUOTE_512_BYTES; 3655 3656 sym_op->auth.data.offset = 0; 3657 sym_op->auth.data.length = QUOTE_512_BYTES; 3658 3659 /* Process crypto operation */ 3660 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 3661 ut_params->op); 3662 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned"); 3663 3664 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 3665 "crypto operation processing failed"); 3666 3667 /* Validate obuf */ 3668 TEST_ASSERT_BUFFERS_ARE_EQUAL( 3669 rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *), 3670 catch_22_quote, 3671 QUOTE_512_BYTES, 3672 "Ciphertext data not as expected"); 3673 3674 return TEST_SUCCESS; 3675 } 3676 3677 static int 3678 test_null_auth_cipher_operation(void) 3679 { 3680 struct crypto_testsuite_params *ts_params = &testsuite_params; 3681 struct crypto_unittest_params *ut_params = &unittest_params; 3682 3683 /* Generate test mbuf data and space for digest */ 3684 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool, 3685 catch_22_quote, QUOTE_512_BYTES, 0); 3686 3687 /* Setup Cipher Parameters */ 3688 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 3689 ut_params->cipher_xform.next = NULL; 3690 3691 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL; 3692 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; 3693 3694 /* Setup HMAC Parameters */ 3695 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 3696 ut_params->auth_xform.next = &ut_params->cipher_xform; 3697 3698 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL; 3699 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; 3700 3701 /* Create Crypto session*/ 3702 ut_params->sess = rte_cryptodev_sym_session_create( 3703 ts_params->valid_devs[0], &ut_params->cipher_xform); 3704 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 3705 3706 /* Generate Crypto op data structure */ 3707 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 3708 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 3709 TEST_ASSERT_NOT_NULL(ut_params->op, 3710 "Failed to allocate symmetric crypto operation struct"); 3711 3712 /* Set crypto operation data parameters */ 3713 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 3714 3715 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 3716 3717 sym_op->m_src = ut_params->ibuf; 3718 3719 sym_op->cipher.data.offset = 0; 3720 sym_op->cipher.data.length = QUOTE_512_BYTES; 3721 3722 sym_op->auth.data.offset = 0; 3723 sym_op->auth.data.length = QUOTE_512_BYTES; 3724 3725 /* Process crypto operation */ 3726 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 3727 ut_params->op); 3728 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned"); 3729 3730 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 3731 "crypto operation processing failed"); 3732 3733 /* Validate obuf */ 3734 TEST_ASSERT_BUFFERS_ARE_EQUAL( 3735 rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *), 3736 catch_22_quote, 3737 QUOTE_512_BYTES, 3738 "Ciphertext data not as expected"); 3739 3740 return TEST_SUCCESS; 3741 } 3742 3743 3744 static int 3745 test_null_invalid_operation(void) 3746 { 3747 struct crypto_testsuite_params *ts_params = &testsuite_params; 3748 struct crypto_unittest_params *ut_params = &unittest_params; 3749 3750 /* Setup Cipher Parameters */ 3751 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 3752 ut_params->cipher_xform.next = NULL; 3753 3754 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC; 3755 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; 3756 3757 /* Create Crypto session*/ 3758 ut_params->sess = rte_cryptodev_sym_session_create( 3759 ts_params->valid_devs[0], &ut_params->cipher_xform); 3760 TEST_ASSERT_NULL(ut_params->sess, 3761 "Session creation succeeded unexpectedly"); 3762 3763 3764 /* Setup HMAC Parameters */ 3765 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 3766 ut_params->auth_xform.next = NULL; 3767 3768 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC; 3769 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; 3770 3771 /* Create Crypto session*/ 3772 ut_params->sess = rte_cryptodev_sym_session_create( 3773 ts_params->valid_devs[0], &ut_params->auth_xform); 3774 TEST_ASSERT_NULL(ut_params->sess, 3775 "Session creation succeeded unexpectedly"); 3776 3777 return TEST_SUCCESS; 3778 } 3779 3780 3781 #define NULL_BURST_LENGTH (32) 3782 3783 static int 3784 test_null_burst_operation(void) 3785 { 3786 struct crypto_testsuite_params *ts_params = &testsuite_params; 3787 struct crypto_unittest_params *ut_params = &unittest_params; 3788 3789 unsigned i, burst_len = NULL_BURST_LENGTH; 3790 3791 struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL }; 3792 struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL }; 3793 3794 /* Setup Cipher Parameters */ 3795 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 3796 ut_params->cipher_xform.next = &ut_params->auth_xform; 3797 3798 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL; 3799 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; 3800 3801 /* Setup HMAC Parameters */ 3802 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 3803 ut_params->auth_xform.next = NULL; 3804 3805 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL; 3806 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; 3807 3808 /* Create Crypto session*/ 3809 ut_params->sess = rte_cryptodev_sym_session_create( 3810 ts_params->valid_devs[0], &ut_params->cipher_xform); 3811 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 3812 3813 TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool, 3814 RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len), 3815 burst_len, "failed to generate burst of crypto ops"); 3816 3817 /* Generate an operation for each mbuf in burst */ 3818 for (i = 0; i < burst_len; i++) { 3819 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool); 3820 3821 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf"); 3822 3823 unsigned *data = (unsigned *)rte_pktmbuf_append(m, 3824 sizeof(unsigned)); 3825 *data = i; 3826 3827 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess); 3828 3829 burst[i]->sym->m_src = m; 3830 } 3831 3832 /* Process crypto operation */ 3833 TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0], 3834 0, burst, burst_len), 3835 burst_len, 3836 "Error enqueuing burst"); 3837 3838 TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0], 3839 0, burst_dequeued, burst_len), 3840 burst_len, 3841 "Error dequeuing burst"); 3842 3843 3844 for (i = 0; i < burst_len; i++) { 3845 TEST_ASSERT_EQUAL( 3846 *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *), 3847 *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src, 3848 uint32_t *), 3849 "data not as expected"); 3850 3851 rte_pktmbuf_free(burst[i]->sym->m_src); 3852 rte_crypto_op_free(burst[i]); 3853 } 3854 3855 return TEST_SUCCESS; 3856 } 3857 3858 3859 3860 3861 static struct unit_test_suite cryptodev_qat_testsuite = { 3862 .suite_name = "Crypto QAT Unit Test Suite", 3863 .setup = testsuite_setup, 3864 .teardown = testsuite_teardown, 3865 .unit_test_cases = { 3866 TEST_CASE_ST(ut_setup, ut_teardown, 3867 test_device_configure_invalid_dev_id), 3868 TEST_CASE_ST(ut_setup, ut_teardown, 3869 test_device_configure_invalid_queue_pair_ids), 3870 TEST_CASE_ST(ut_setup, ut_teardown, 3871 test_queue_pair_descriptor_setup), 3872 TEST_CASE_ST(ut_setup, ut_teardown, 3873 test_multi_session), 3874 3875 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_qat_all), 3876 TEST_CASE_ST(ut_setup, ut_teardown, test_stats), 3877 3878 /** AES GCM Authenticated Encryption */ 3879 TEST_CASE_ST(ut_setup, ut_teardown, 3880 test_mb_AES_GCM_authenticated_encryption_test_case_1), 3881 TEST_CASE_ST(ut_setup, ut_teardown, 3882 test_mb_AES_GCM_authenticated_encryption_test_case_2), 3883 TEST_CASE_ST(ut_setup, ut_teardown, 3884 test_mb_AES_GCM_authenticated_encryption_test_case_3), 3885 TEST_CASE_ST(ut_setup, ut_teardown, 3886 test_mb_AES_GCM_authenticated_encryption_test_case_4), 3887 TEST_CASE_ST(ut_setup, ut_teardown, 3888 test_mb_AES_GCM_authenticated_encryption_test_case_5), 3889 TEST_CASE_ST(ut_setup, ut_teardown, 3890 test_mb_AES_GCM_authenticated_encryption_test_case_6), 3891 TEST_CASE_ST(ut_setup, ut_teardown, 3892 test_mb_AES_GCM_authenticated_encryption_test_case_7), 3893 3894 /** AES GCM Authenticated Decryption */ 3895 TEST_CASE_ST(ut_setup, ut_teardown, 3896 test_mb_AES_GCM_authenticated_decryption_test_case_1), 3897 TEST_CASE_ST(ut_setup, ut_teardown, 3898 test_mb_AES_GCM_authenticated_decryption_test_case_2), 3899 TEST_CASE_ST(ut_setup, ut_teardown, 3900 test_mb_AES_GCM_authenticated_decryption_test_case_3), 3901 TEST_CASE_ST(ut_setup, ut_teardown, 3902 test_mb_AES_GCM_authenticated_decryption_test_case_4), 3903 TEST_CASE_ST(ut_setup, ut_teardown, 3904 test_mb_AES_GCM_authenticated_decryption_test_case_5), 3905 TEST_CASE_ST(ut_setup, ut_teardown, 3906 test_mb_AES_GCM_authenticated_decryption_test_case_6), 3907 TEST_CASE_ST(ut_setup, ut_teardown, 3908 test_mb_AES_GCM_authenticated_decryption_test_case_7), 3909 3910 /** Snow3G encrypt only (UEA2) */ 3911 TEST_CASE_ST(ut_setup, ut_teardown, 3912 test_snow3g_encryption_test_case_1), 3913 TEST_CASE_ST(ut_setup, ut_teardown, 3914 test_snow3g_encryption_test_case_2), 3915 TEST_CASE_ST(ut_setup, ut_teardown, 3916 test_snow3g_encryption_test_case_3), 3917 TEST_CASE_ST(ut_setup, ut_teardown, 3918 test_snow3g_encryption_test_case_4), 3919 TEST_CASE_ST(ut_setup, ut_teardown, 3920 test_snow3g_encryption_test_case_5), 3921 3922 TEST_CASE_ST(ut_setup, ut_teardown, 3923 test_snow3g_encryption_test_case_1_oop), 3924 TEST_CASE_ST(ut_setup, ut_teardown, 3925 test_snow3g_decryption_test_case_1_oop), 3926 3927 /** Snow3G decrypt only (UEA2) */ 3928 TEST_CASE_ST(ut_setup, ut_teardown, 3929 test_snow3g_decryption_test_case_1), 3930 TEST_CASE_ST(ut_setup, ut_teardown, 3931 test_snow3g_decryption_test_case_2), 3932 TEST_CASE_ST(ut_setup, ut_teardown, 3933 test_snow3g_decryption_test_case_3), 3934 TEST_CASE_ST(ut_setup, ut_teardown, 3935 test_snow3g_decryption_test_case_4), 3936 TEST_CASE_ST(ut_setup, ut_teardown, 3937 test_snow3g_decryption_test_case_5), 3938 TEST_CASE_ST(ut_setup, ut_teardown, 3939 test_snow3g_hash_generate_test_case_1), 3940 TEST_CASE_ST(ut_setup, ut_teardown, 3941 test_snow3g_hash_generate_test_case_2), 3942 TEST_CASE_ST(ut_setup, ut_teardown, 3943 test_snow3g_hash_generate_test_case_3), 3944 TEST_CASE_ST(ut_setup, ut_teardown, 3945 test_snow3g_hash_verify_test_case_1), 3946 TEST_CASE_ST(ut_setup, ut_teardown, 3947 test_snow3g_hash_verify_test_case_2), 3948 TEST_CASE_ST(ut_setup, ut_teardown, 3949 test_snow3g_hash_verify_test_case_3), 3950 TEST_CASE_ST(ut_setup, ut_teardown, 3951 test_snow3g_authenticated_encryption_test_case_1), 3952 TEST_CASE_ST(ut_setup, ut_teardown, 3953 test_snow3g_encrypted_authentication_test_case_1), 3954 TEST_CASES_END() /**< NULL terminate unit test array */ 3955 } 3956 }; 3957 3958 static struct unit_test_suite cryptodev_aesni_mb_testsuite = { 3959 .suite_name = "Crypto Device AESNI MB Unit Test Suite", 3960 .setup = testsuite_setup, 3961 .teardown = testsuite_teardown, 3962 .unit_test_cases = { 3963 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_mb_all), 3964 3965 TEST_CASES_END() /**< NULL terminate unit test array */ 3966 } 3967 }; 3968 3969 static struct unit_test_suite cryptodev_aesni_gcm_testsuite = { 3970 .suite_name = "Crypto Device AESNI GCM Unit Test Suite", 3971 .setup = testsuite_setup, 3972 .teardown = testsuite_teardown, 3973 .unit_test_cases = { 3974 /** AES GCM Authenticated Encryption */ 3975 TEST_CASE_ST(ut_setup, ut_teardown, 3976 test_mb_AES_GCM_authenticated_encryption_test_case_1), 3977 TEST_CASE_ST(ut_setup, ut_teardown, 3978 test_mb_AES_GCM_authenticated_encryption_test_case_2), 3979 TEST_CASE_ST(ut_setup, ut_teardown, 3980 test_mb_AES_GCM_authenticated_encryption_test_case_3), 3981 TEST_CASE_ST(ut_setup, ut_teardown, 3982 test_mb_AES_GCM_authenticated_encryption_test_case_4), 3983 TEST_CASE_ST(ut_setup, ut_teardown, 3984 test_mb_AES_GCM_authenticated_encryption_test_case_5), 3985 TEST_CASE_ST(ut_setup, ut_teardown, 3986 test_mb_AES_GCM_authenticated_encryption_test_case_6), 3987 TEST_CASE_ST(ut_setup, ut_teardown, 3988 test_mb_AES_GCM_authenticated_encryption_test_case_7), 3989 3990 /** AES GCM Authenticated Decryption */ 3991 TEST_CASE_ST(ut_setup, ut_teardown, 3992 test_mb_AES_GCM_authenticated_decryption_test_case_1), 3993 TEST_CASE_ST(ut_setup, ut_teardown, 3994 test_mb_AES_GCM_authenticated_decryption_test_case_2), 3995 TEST_CASE_ST(ut_setup, ut_teardown, 3996 test_mb_AES_GCM_authenticated_decryption_test_case_3), 3997 TEST_CASE_ST(ut_setup, ut_teardown, 3998 test_mb_AES_GCM_authenticated_decryption_test_case_4), 3999 TEST_CASE_ST(ut_setup, ut_teardown, 4000 test_mb_AES_GCM_authenticated_decryption_test_case_5), 4001 TEST_CASE_ST(ut_setup, ut_teardown, 4002 test_mb_AES_GCM_authenticated_decryption_test_case_6), 4003 TEST_CASE_ST(ut_setup, ut_teardown, 4004 test_mb_AES_GCM_authenticated_decryption_test_case_7), 4005 4006 TEST_CASES_END() /**< NULL terminate unit test array */ 4007 } 4008 }; 4009 4010 static struct unit_test_suite cryptodev_sw_kasumi_testsuite = { 4011 .suite_name = "Crypto Device SW KASUMI Unit Test Suite", 4012 .setup = testsuite_setup, 4013 .teardown = testsuite_teardown, 4014 .unit_test_cases = { 4015 /** KASUMI encrypt only (UEA1) */ 4016 TEST_CASE_ST(ut_setup, ut_teardown, 4017 test_kasumi_encryption_test_case_1), 4018 TEST_CASE_ST(ut_setup, ut_teardown, 4019 test_kasumi_encryption_test_case_2), 4020 TEST_CASE_ST(ut_setup, ut_teardown, 4021 test_kasumi_encryption_test_case_3), 4022 TEST_CASE_ST(ut_setup, ut_teardown, 4023 test_kasumi_encryption_test_case_4), 4024 TEST_CASE_ST(ut_setup, ut_teardown, 4025 test_kasumi_encryption_test_case_5), 4026 /** KASUMI decrypt only (UEA1) */ 4027 TEST_CASE_ST(ut_setup, ut_teardown, 4028 test_kasumi_decryption_test_case_1), 4029 TEST_CASE_ST(ut_setup, ut_teardown, 4030 test_kasumi_decryption_test_case_2), 4031 TEST_CASE_ST(ut_setup, ut_teardown, 4032 test_kasumi_decryption_test_case_3), 4033 TEST_CASE_ST(ut_setup, ut_teardown, 4034 test_kasumi_decryption_test_case_4), 4035 TEST_CASE_ST(ut_setup, ut_teardown, 4036 test_kasumi_decryption_test_case_5), 4037 4038 TEST_CASE_ST(ut_setup, ut_teardown, 4039 test_kasumi_encryption_test_case_1_oop), 4040 TEST_CASE_ST(ut_setup, ut_teardown, 4041 test_kasumi_decryption_test_case_1_oop), 4042 4043 /** KASUMI hash only (UIA1) */ 4044 TEST_CASE_ST(ut_setup, ut_teardown, 4045 test_kasumi_hash_generate_test_case_1), 4046 TEST_CASE_ST(ut_setup, ut_teardown, 4047 test_kasumi_hash_generate_test_case_2), 4048 TEST_CASE_ST(ut_setup, ut_teardown, 4049 test_kasumi_hash_generate_test_case_3), 4050 TEST_CASE_ST(ut_setup, ut_teardown, 4051 test_kasumi_hash_generate_test_case_4), 4052 TEST_CASE_ST(ut_setup, ut_teardown, 4053 test_kasumi_hash_generate_test_case_5), 4054 TEST_CASE_ST(ut_setup, ut_teardown, 4055 test_kasumi_hash_verify_test_case_1), 4056 TEST_CASE_ST(ut_setup, ut_teardown, 4057 test_kasumi_hash_verify_test_case_2), 4058 TEST_CASE_ST(ut_setup, ut_teardown, 4059 test_kasumi_hash_verify_test_case_3), 4060 TEST_CASE_ST(ut_setup, ut_teardown, 4061 test_kasumi_hash_verify_test_case_4), 4062 TEST_CASE_ST(ut_setup, ut_teardown, 4063 test_kasumi_hash_verify_test_case_5), 4064 4065 TEST_CASES_END() /**< NULL terminate unit test array */ 4066 } 4067 }; 4068 static struct unit_test_suite cryptodev_sw_snow3g_testsuite = { 4069 .suite_name = "Crypto Device SW Snow3G Unit Test Suite", 4070 .setup = testsuite_setup, 4071 .teardown = testsuite_teardown, 4072 .unit_test_cases = { 4073 /** Snow3G encrypt only (UEA2) */ 4074 TEST_CASE_ST(ut_setup, ut_teardown, 4075 test_snow3g_encryption_test_case_1), 4076 TEST_CASE_ST(ut_setup, ut_teardown, 4077 test_snow3g_encryption_test_case_2), 4078 TEST_CASE_ST(ut_setup, ut_teardown, 4079 test_snow3g_encryption_test_case_3), 4080 TEST_CASE_ST(ut_setup, ut_teardown, 4081 test_snow3g_encryption_test_case_4), 4082 TEST_CASE_ST(ut_setup, ut_teardown, 4083 test_snow3g_encryption_test_case_5), 4084 4085 TEST_CASE_ST(ut_setup, ut_teardown, 4086 test_snow3g_encryption_test_case_1_oop), 4087 TEST_CASE_ST(ut_setup, ut_teardown, 4088 test_snow3g_decryption_test_case_1_oop), 4089 4090 TEST_CASE_ST(ut_setup, ut_teardown, 4091 test_snow3g_encryption_test_case_1_offset_oop), 4092 4093 /** Snow3G decrypt only (UEA2) */ 4094 TEST_CASE_ST(ut_setup, ut_teardown, 4095 test_snow3g_decryption_test_case_1), 4096 TEST_CASE_ST(ut_setup, ut_teardown, 4097 test_snow3g_decryption_test_case_2), 4098 TEST_CASE_ST(ut_setup, ut_teardown, 4099 test_snow3g_decryption_test_case_3), 4100 TEST_CASE_ST(ut_setup, ut_teardown, 4101 test_snow3g_decryption_test_case_4), 4102 TEST_CASE_ST(ut_setup, ut_teardown, 4103 test_snow3g_decryption_test_case_5), 4104 TEST_CASE_ST(ut_setup, ut_teardown, 4105 test_snow3g_hash_generate_test_case_1), 4106 TEST_CASE_ST(ut_setup, ut_teardown, 4107 test_snow3g_hash_generate_test_case_2), 4108 TEST_CASE_ST(ut_setup, ut_teardown, 4109 test_snow3g_hash_generate_test_case_3), 4110 /* Tests with buffers which length is not byte-aligned */ 4111 TEST_CASE_ST(ut_setup, ut_teardown, 4112 test_snow3g_hash_generate_test_case_4), 4113 TEST_CASE_ST(ut_setup, ut_teardown, 4114 test_snow3g_hash_generate_test_case_5), 4115 TEST_CASE_ST(ut_setup, ut_teardown, 4116 test_snow3g_hash_generate_test_case_6), 4117 TEST_CASE_ST(ut_setup, ut_teardown, 4118 test_snow3g_hash_verify_test_case_1), 4119 TEST_CASE_ST(ut_setup, ut_teardown, 4120 test_snow3g_hash_verify_test_case_2), 4121 TEST_CASE_ST(ut_setup, ut_teardown, 4122 test_snow3g_hash_verify_test_case_3), 4123 /* Tests with buffers which length is not byte-aligned */ 4124 TEST_CASE_ST(ut_setup, ut_teardown, 4125 test_snow3g_hash_verify_test_case_4), 4126 TEST_CASE_ST(ut_setup, ut_teardown, 4127 test_snow3g_hash_verify_test_case_5), 4128 TEST_CASE_ST(ut_setup, ut_teardown, 4129 test_snow3g_hash_verify_test_case_6), 4130 TEST_CASE_ST(ut_setup, ut_teardown, 4131 test_snow3g_authenticated_encryption_test_case_1), 4132 TEST_CASE_ST(ut_setup, ut_teardown, 4133 test_snow3g_encrypted_authentication_test_case_1), 4134 4135 TEST_CASES_END() /**< NULL terminate unit test array */ 4136 } 4137 }; 4138 4139 static struct unit_test_suite cryptodev_null_testsuite = { 4140 .suite_name = "Crypto Device NULL Unit Test Suite", 4141 .setup = testsuite_setup, 4142 .teardown = testsuite_teardown, 4143 .unit_test_cases = { 4144 TEST_CASE_ST(ut_setup, ut_teardown, 4145 test_null_auth_only_operation), 4146 TEST_CASE_ST(ut_setup, ut_teardown, 4147 test_null_cipher_only_operation), 4148 TEST_CASE_ST(ut_setup, ut_teardown, 4149 test_null_cipher_auth_operation), 4150 TEST_CASE_ST(ut_setup, ut_teardown, 4151 test_null_auth_cipher_operation), 4152 TEST_CASE_ST(ut_setup, ut_teardown, 4153 test_null_invalid_operation), 4154 TEST_CASE_ST(ut_setup, ut_teardown, 4155 test_null_burst_operation), 4156 4157 TEST_CASES_END() /**< NULL terminate unit test array */ 4158 } 4159 }; 4160 4161 static int 4162 test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/) 4163 { 4164 gbl_cryptodev_type = RTE_CRYPTODEV_QAT_SYM_PMD; 4165 return unit_test_suite_runner(&cryptodev_qat_testsuite); 4166 } 4167 4168 static int 4169 test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/) 4170 { 4171 gbl_cryptodev_type = RTE_CRYPTODEV_AESNI_MB_PMD; 4172 4173 return unit_test_suite_runner(&cryptodev_aesni_mb_testsuite); 4174 } 4175 4176 static int 4177 test_cryptodev_aesni_gcm(void) 4178 { 4179 gbl_cryptodev_type = RTE_CRYPTODEV_AESNI_GCM_PMD; 4180 4181 return unit_test_suite_runner(&cryptodev_aesni_gcm_testsuite); 4182 } 4183 4184 static int 4185 test_cryptodev_null(void) 4186 { 4187 gbl_cryptodev_type = RTE_CRYPTODEV_NULL_PMD; 4188 4189 return unit_test_suite_runner(&cryptodev_null_testsuite); 4190 } 4191 4192 static int 4193 test_cryptodev_sw_snow3g(void /*argv __rte_unused, int argc __rte_unused*/) 4194 { 4195 gbl_cryptodev_type = RTE_CRYPTODEV_SNOW3G_PMD; 4196 4197 return unit_test_suite_runner(&cryptodev_sw_snow3g_testsuite); 4198 } 4199 4200 static int 4201 test_cryptodev_sw_kasumi(void /*argv __rte_unused, int argc __rte_unused*/) 4202 { 4203 gbl_cryptodev_type = RTE_CRYPTODEV_KASUMI_PMD; 4204 4205 return unit_test_suite_runner(&cryptodev_sw_kasumi_testsuite); 4206 } 4207 4208 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat); 4209 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb); 4210 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm); 4211 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null); 4212 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g); 4213 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi); 4214