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_blockcipher.h" 47 #include "test_cryptodev_aes_test_vectors.h" 48 #include "test_cryptodev_des_test_vectors.h" 49 #include "test_cryptodev_hash_test_vectors.h" 50 #include "test_cryptodev_kasumi_test_vectors.h" 51 #include "test_cryptodev_kasumi_hash_test_vectors.h" 52 #include "test_cryptodev_snow3g_test_vectors.h" 53 #include "test_cryptodev_snow3g_hash_test_vectors.h" 54 #include "test_cryptodev_zuc_test_vectors.h" 55 #include "test_cryptodev_zuc_hash_test_vectors.h" 56 #include "test_cryptodev_gcm_test_vectors.h" 57 #include "test_cryptodev_hmac_test_vectors.h" 58 59 static enum rte_cryptodev_type gbl_cryptodev_type; 60 61 struct crypto_testsuite_params { 62 struct rte_mempool *mbuf_pool; 63 struct rte_mempool *large_mbuf_pool; 64 struct rte_mempool *op_mpool; 65 struct rte_cryptodev_config conf; 66 struct rte_cryptodev_qp_conf qp_conf; 67 68 uint8_t valid_devs[RTE_CRYPTO_MAX_DEVS]; 69 uint8_t valid_dev_count; 70 }; 71 72 struct crypto_unittest_params { 73 struct rte_crypto_sym_xform cipher_xform; 74 struct rte_crypto_sym_xform auth_xform; 75 76 struct rte_cryptodev_sym_session *sess; 77 78 struct rte_crypto_op *op; 79 80 struct rte_mbuf *obuf, *ibuf; 81 82 uint8_t *digest; 83 }; 84 85 #define ALIGN_POW2_ROUNDUP(num, align) \ 86 (((num) + (align) - 1) & ~((align) - 1)) 87 88 /* 89 * Forward declarations. 90 */ 91 static int 92 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params( 93 struct crypto_unittest_params *ut_params, uint8_t *cipher_key, 94 uint8_t *hmac_key); 95 96 static int 97 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess, 98 struct crypto_unittest_params *ut_params, 99 struct crypto_testsuite_params *ts_param, 100 const uint8_t *cipher, 101 const uint8_t *digest, 102 const uint8_t *iv); 103 104 static struct rte_mbuf * 105 setup_test_string(struct rte_mempool *mpool, 106 const char *string, size_t len, uint8_t blocksize) 107 { 108 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool); 109 size_t t_len = len - (blocksize ? (len % blocksize) : 0); 110 111 memset(m->buf_addr, 0, m->buf_len); 112 if (m) { 113 char *dst = rte_pktmbuf_append(m, t_len); 114 115 if (!dst) { 116 rte_pktmbuf_free(m); 117 return NULL; 118 } 119 if (string != NULL) 120 rte_memcpy(dst, string, t_len); 121 else 122 memset(dst, 0, t_len); 123 } 124 125 return m; 126 } 127 128 /* Get number of bytes in X bits (rounding up) */ 129 static uint32_t 130 ceil_byte_length(uint32_t num_bits) 131 { 132 if (num_bits % 8) 133 return ((num_bits >> 3) + 1); 134 else 135 return (num_bits >> 3); 136 } 137 138 static struct rte_crypto_op * 139 process_crypto_request(uint8_t dev_id, struct rte_crypto_op *op) 140 { 141 if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) { 142 printf("Error sending packet for encryption"); 143 return NULL; 144 } 145 146 op = NULL; 147 148 while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0) 149 rte_pause(); 150 151 return op; 152 } 153 154 static struct crypto_testsuite_params testsuite_params = { NULL }; 155 static struct crypto_unittest_params unittest_params; 156 157 static int 158 testsuite_setup(void) 159 { 160 struct crypto_testsuite_params *ts_params = &testsuite_params; 161 struct rte_cryptodev_info info; 162 unsigned i, nb_devs, dev_id; 163 int ret; 164 uint16_t qp_id; 165 166 memset(ts_params, 0, sizeof(*ts_params)); 167 168 ts_params->mbuf_pool = rte_mempool_lookup("CRYPTO_MBUFPOOL"); 169 if (ts_params->mbuf_pool == NULL) { 170 /* Not already created so create */ 171 ts_params->mbuf_pool = rte_pktmbuf_pool_create( 172 "CRYPTO_MBUFPOOL", 173 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE, 174 rte_socket_id()); 175 if (ts_params->mbuf_pool == NULL) { 176 RTE_LOG(ERR, USER1, "Can't create CRYPTO_MBUFPOOL\n"); 177 return TEST_FAILED; 178 } 179 } 180 181 ts_params->large_mbuf_pool = rte_mempool_lookup( 182 "CRYPTO_LARGE_MBUFPOOL"); 183 if (ts_params->large_mbuf_pool == NULL) { 184 /* Not already created so create */ 185 ts_params->large_mbuf_pool = rte_pktmbuf_pool_create( 186 "CRYPTO_LARGE_MBUFPOOL", 187 1, 0, 0, UINT16_MAX, 188 rte_socket_id()); 189 if (ts_params->large_mbuf_pool == NULL) { 190 RTE_LOG(ERR, USER1, 191 "Can't create CRYPTO_LARGE_MBUFPOOL\n"); 192 return TEST_FAILED; 193 } 194 } 195 196 ts_params->op_mpool = rte_crypto_op_pool_create( 197 "MBUF_CRYPTO_SYM_OP_POOL", 198 RTE_CRYPTO_OP_TYPE_SYMMETRIC, 199 NUM_MBUFS, MBUF_CACHE_SIZE, 200 DEFAULT_NUM_XFORMS * 201 sizeof(struct rte_crypto_sym_xform), 202 rte_socket_id()); 203 if (ts_params->op_mpool == NULL) { 204 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n"); 205 return TEST_FAILED; 206 } 207 208 /* Create 2 AESNI MB devices if required */ 209 if (gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD) { 210 #ifndef RTE_LIBRTE_PMD_AESNI_MB 211 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_MB must be" 212 " enabled in config file to run this testsuite.\n"); 213 return TEST_FAILED; 214 #endif 215 nb_devs = rte_cryptodev_count_devtype( 216 RTE_CRYPTODEV_AESNI_MB_PMD); 217 if (nb_devs < 2) { 218 for (i = nb_devs; i < 2; i++) { 219 ret = rte_eal_vdev_init( 220 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL); 221 222 TEST_ASSERT(ret == 0, 223 "Failed to create instance %u of" 224 " pmd : %s", 225 i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)); 226 } 227 } 228 } 229 230 /* Create 2 AESNI GCM devices if required */ 231 if (gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_GCM_PMD) { 232 #ifndef RTE_LIBRTE_PMD_AESNI_GCM 233 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_GCM must be" 234 " enabled in config file to run this testsuite.\n"); 235 return TEST_FAILED; 236 #endif 237 nb_devs = rte_cryptodev_count_devtype( 238 RTE_CRYPTODEV_AESNI_GCM_PMD); 239 if (nb_devs < 2) { 240 for (i = nb_devs; i < 2; i++) { 241 TEST_ASSERT_SUCCESS(rte_eal_vdev_init( 242 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD), NULL), 243 "Failed to create instance %u of" 244 " pmd : %s", 245 i, RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD)); 246 } 247 } 248 } 249 250 /* Create 2 SNOW 3G devices if required */ 251 if (gbl_cryptodev_type == RTE_CRYPTODEV_SNOW3G_PMD) { 252 #ifndef RTE_LIBRTE_PMD_SNOW3G 253 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_SNOW3G must be" 254 " enabled in config file to run this testsuite.\n"); 255 return TEST_FAILED; 256 #endif 257 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_SNOW3G_PMD); 258 if (nb_devs < 2) { 259 for (i = nb_devs; i < 2; i++) { 260 TEST_ASSERT_SUCCESS(rte_eal_vdev_init( 261 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD), NULL), 262 "Failed to create instance %u of" 263 " pmd : %s", 264 i, RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD)); 265 } 266 } 267 } 268 269 /* Create 2 KASUMI devices if required */ 270 if (gbl_cryptodev_type == RTE_CRYPTODEV_KASUMI_PMD) { 271 #ifndef RTE_LIBRTE_PMD_KASUMI 272 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_KASUMI must be" 273 " enabled in config file to run this testsuite.\n"); 274 return TEST_FAILED; 275 #endif 276 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_KASUMI_PMD); 277 if (nb_devs < 2) { 278 for (i = nb_devs; i < 2; i++) { 279 TEST_ASSERT_SUCCESS(rte_eal_vdev_init( 280 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD), NULL), 281 "Failed to create instance %u of" 282 " pmd : %s", 283 i, RTE_STR(CRYPTODEV_NAME_KASUMI_PMD)); 284 } 285 } 286 } 287 288 /* Create 2 ZUC devices if required */ 289 if (gbl_cryptodev_type == RTE_CRYPTODEV_ZUC_PMD) { 290 #ifndef RTE_LIBRTE_PMD_ZUC 291 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_ZUC must be" 292 " enabled in config file to run this testsuite.\n"); 293 return TEST_FAILED; 294 #endif 295 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_ZUC_PMD); 296 if (nb_devs < 2) { 297 for (i = nb_devs; i < 2; i++) { 298 TEST_ASSERT_SUCCESS(rte_eal_vdev_init( 299 RTE_STR(CRYPTODEV_NAME_ZUC_PMD), NULL), 300 "Failed to create instance %u of" 301 " pmd : %s", 302 i, RTE_STR(CRYPTODEV_NAME_ZUC_PMD)); 303 } 304 } 305 } 306 307 /* Create 2 NULL devices if required */ 308 if (gbl_cryptodev_type == RTE_CRYPTODEV_NULL_PMD) { 309 #ifndef RTE_LIBRTE_PMD_NULL_CRYPTO 310 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_NULL_CRYPTO must be" 311 " enabled in config file to run this testsuite.\n"); 312 return TEST_FAILED; 313 #endif 314 nb_devs = rte_cryptodev_count_devtype( 315 RTE_CRYPTODEV_NULL_PMD); 316 if (nb_devs < 2) { 317 for (i = nb_devs; i < 2; i++) { 318 int dev_id = rte_eal_vdev_init( 319 RTE_STR(CRYPTODEV_NAME_NULL_PMD), NULL); 320 321 TEST_ASSERT(dev_id >= 0, 322 "Failed to create instance %u of" 323 " pmd : %s", 324 i, RTE_STR(CRYPTODEV_NAME_NULL_PMD)); 325 } 326 } 327 } 328 329 /* Create 2 OPENSSL devices if required */ 330 if (gbl_cryptodev_type == RTE_CRYPTODEV_OPENSSL_PMD) { 331 #ifndef RTE_LIBRTE_PMD_OPENSSL 332 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_OPENSSL must be" 333 " enabled in config file to run this testsuite.\n"); 334 return TEST_FAILED; 335 #endif 336 nb_devs = rte_cryptodev_count_devtype( 337 RTE_CRYPTODEV_OPENSSL_PMD); 338 if (nb_devs < 2) { 339 for (i = nb_devs; i < 2; i++) { 340 ret = rte_eal_vdev_init( 341 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD), 342 NULL); 343 344 TEST_ASSERT(ret == 0, "Failed to create " 345 "instance %u of pmd : %s", i, 346 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)); 347 } 348 } 349 } 350 351 #ifndef RTE_LIBRTE_PMD_QAT 352 if (gbl_cryptodev_type == RTE_CRYPTODEV_QAT_SYM_PMD) { 353 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_QAT must be enabled " 354 "in config file to run this testsuite.\n"); 355 return TEST_FAILED; 356 } 357 #endif 358 359 nb_devs = rte_cryptodev_count(); 360 if (nb_devs < 1) { 361 RTE_LOG(ERR, USER1, "No crypto devices found?\n"); 362 return TEST_FAILED; 363 } 364 365 /* Create list of valid crypto devs */ 366 for (i = 0; i < nb_devs; i++) { 367 rte_cryptodev_info_get(i, &info); 368 if (info.dev_type == gbl_cryptodev_type) 369 ts_params->valid_devs[ts_params->valid_dev_count++] = i; 370 } 371 372 if (ts_params->valid_dev_count < 1) 373 return TEST_FAILED; 374 375 /* Set up all the qps on the first of the valid devices found */ 376 377 dev_id = ts_params->valid_devs[0]; 378 379 rte_cryptodev_info_get(dev_id, &info); 380 381 ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs; 382 ts_params->conf.socket_id = SOCKET_ID_ANY; 383 ts_params->conf.session_mp.nb_objs = info.sym.max_nb_sessions; 384 385 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, 386 &ts_params->conf), 387 "Failed to configure cryptodev %u with %u qps", 388 dev_id, ts_params->conf.nb_queue_pairs); 389 390 ts_params->qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT; 391 392 for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) { 393 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( 394 dev_id, qp_id, &ts_params->qp_conf, 395 rte_cryptodev_socket_id(dev_id)), 396 "Failed to setup queue pair %u on cryptodev %u", 397 qp_id, dev_id); 398 } 399 400 return TEST_SUCCESS; 401 } 402 403 static void 404 testsuite_teardown(void) 405 { 406 struct crypto_testsuite_params *ts_params = &testsuite_params; 407 408 if (ts_params->mbuf_pool != NULL) { 409 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n", 410 rte_mempool_avail_count(ts_params->mbuf_pool)); 411 } 412 413 if (ts_params->op_mpool != NULL) { 414 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n", 415 rte_mempool_avail_count(ts_params->op_mpool)); 416 } 417 418 } 419 420 static int 421 ut_setup(void) 422 { 423 struct crypto_testsuite_params *ts_params = &testsuite_params; 424 struct crypto_unittest_params *ut_params = &unittest_params; 425 426 uint16_t qp_id; 427 428 /* Clear unit test parameters before running test */ 429 memset(ut_params, 0, sizeof(*ut_params)); 430 431 /* Reconfigure device to default parameters */ 432 ts_params->conf.socket_id = SOCKET_ID_ANY; 433 ts_params->conf.session_mp.nb_objs = DEFAULT_NUM_OPS_INFLIGHT; 434 435 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0], 436 &ts_params->conf), 437 "Failed to configure cryptodev %u", 438 ts_params->valid_devs[0]); 439 440 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) { 441 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( 442 ts_params->valid_devs[0], qp_id, 443 &ts_params->qp_conf, 444 rte_cryptodev_socket_id(ts_params->valid_devs[0])), 445 "Failed to setup queue pair %u on cryptodev %u", 446 qp_id, ts_params->valid_devs[0]); 447 } 448 449 450 rte_cryptodev_stats_reset(ts_params->valid_devs[0]); 451 452 /* Start the device */ 453 TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]), 454 "Failed to start cryptodev %u", 455 ts_params->valid_devs[0]); 456 457 return TEST_SUCCESS; 458 } 459 460 static void 461 ut_teardown(void) 462 { 463 struct crypto_testsuite_params *ts_params = &testsuite_params; 464 struct crypto_unittest_params *ut_params = &unittest_params; 465 struct rte_cryptodev_stats stats; 466 467 /* free crypto session structure */ 468 if (ut_params->sess) { 469 rte_cryptodev_sym_session_free(ts_params->valid_devs[0], 470 ut_params->sess); 471 ut_params->sess = NULL; 472 } 473 474 /* free crypto operation structure */ 475 if (ut_params->op) 476 rte_crypto_op_free(ut_params->op); 477 478 /* 479 * free mbuf - both obuf and ibuf are usually the same, 480 * so check if they point at the same address is necessary, 481 * to avoid freeing the mbuf twice. 482 */ 483 if (ut_params->obuf) { 484 rte_pktmbuf_free(ut_params->obuf); 485 if (ut_params->ibuf == ut_params->obuf) 486 ut_params->ibuf = 0; 487 ut_params->obuf = 0; 488 } 489 if (ut_params->ibuf) { 490 rte_pktmbuf_free(ut_params->ibuf); 491 ut_params->ibuf = 0; 492 } 493 494 if (ts_params->mbuf_pool != NULL) 495 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n", 496 rte_mempool_avail_count(ts_params->mbuf_pool)); 497 498 rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats); 499 500 /* Stop the device */ 501 rte_cryptodev_stop(ts_params->valid_devs[0]); 502 } 503 504 static int 505 test_device_configure_invalid_dev_id(void) 506 { 507 struct crypto_testsuite_params *ts_params = &testsuite_params; 508 uint16_t dev_id, num_devs = 0; 509 510 TEST_ASSERT((num_devs = rte_cryptodev_count()) >= 1, 511 "Need at least %d devices for test", 1); 512 513 /* valid dev_id values */ 514 dev_id = ts_params->valid_devs[ts_params->valid_dev_count - 1]; 515 516 /* Stop the device in case it's started so it can be configured */ 517 rte_cryptodev_stop(ts_params->valid_devs[dev_id]); 518 519 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf), 520 "Failed test for rte_cryptodev_configure: " 521 "invalid dev_num %u", dev_id); 522 523 /* invalid dev_id values */ 524 dev_id = num_devs; 525 526 TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf), 527 "Failed test for rte_cryptodev_configure: " 528 "invalid dev_num %u", dev_id); 529 530 dev_id = 0xff; 531 532 TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf), 533 "Failed test for rte_cryptodev_configure:" 534 "invalid dev_num %u", dev_id); 535 536 return TEST_SUCCESS; 537 } 538 539 static int 540 test_device_configure_invalid_queue_pair_ids(void) 541 { 542 struct crypto_testsuite_params *ts_params = &testsuite_params; 543 uint16_t orig_nb_qps = ts_params->conf.nb_queue_pairs; 544 545 /* Stop the device in case it's started so it can be configured */ 546 rte_cryptodev_stop(ts_params->valid_devs[0]); 547 548 /* valid - one queue pairs */ 549 ts_params->conf.nb_queue_pairs = 1; 550 551 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0], 552 &ts_params->conf), 553 "Failed to configure cryptodev: dev_id %u, qp_id %u", 554 ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs); 555 556 557 /* valid - max value queue pairs */ 558 ts_params->conf.nb_queue_pairs = MAX_NUM_QPS_PER_QAT_DEVICE; 559 560 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0], 561 &ts_params->conf), 562 "Failed to configure cryptodev: dev_id %u, qp_id %u", 563 ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs); 564 565 566 /* invalid - zero queue pairs */ 567 ts_params->conf.nb_queue_pairs = 0; 568 569 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0], 570 &ts_params->conf), 571 "Failed test for rte_cryptodev_configure, dev_id %u," 572 " invalid qps: %u", 573 ts_params->valid_devs[0], 574 ts_params->conf.nb_queue_pairs); 575 576 577 /* invalid - max value supported by field queue pairs */ 578 ts_params->conf.nb_queue_pairs = UINT16_MAX; 579 580 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0], 581 &ts_params->conf), 582 "Failed test for rte_cryptodev_configure, dev_id %u," 583 " invalid qps: %u", 584 ts_params->valid_devs[0], 585 ts_params->conf.nb_queue_pairs); 586 587 588 /* invalid - max value + 1 queue pairs */ 589 ts_params->conf.nb_queue_pairs = MAX_NUM_QPS_PER_QAT_DEVICE + 1; 590 591 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0], 592 &ts_params->conf), 593 "Failed test for rte_cryptodev_configure, dev_id %u," 594 " invalid qps: %u", 595 ts_params->valid_devs[0], 596 ts_params->conf.nb_queue_pairs); 597 598 /* revert to original testsuite value */ 599 ts_params->conf.nb_queue_pairs = orig_nb_qps; 600 601 return TEST_SUCCESS; 602 } 603 604 static int 605 test_queue_pair_descriptor_setup(void) 606 { 607 struct crypto_testsuite_params *ts_params = &testsuite_params; 608 struct rte_cryptodev_info dev_info; 609 struct rte_cryptodev_qp_conf qp_conf = { 610 .nb_descriptors = MAX_NUM_OPS_INFLIGHT 611 }; 612 613 uint16_t qp_id; 614 615 /* Stop the device in case it's started so it can be configured */ 616 rte_cryptodev_stop(ts_params->valid_devs[0]); 617 618 619 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 620 621 ts_params->conf.session_mp.nb_objs = dev_info.sym.max_nb_sessions; 622 623 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0], 624 &ts_params->conf), "Failed to configure cryptodev %u", 625 ts_params->valid_devs[0]); 626 627 628 /* 629 * Test various ring sizes on this device. memzones can't be 630 * freed so are re-used if ring is released and re-created. 631 */ 632 qp_conf.nb_descriptors = MIN_NUM_OPS_INFLIGHT; /* min size*/ 633 634 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) { 635 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( 636 ts_params->valid_devs[0], qp_id, &qp_conf, 637 rte_cryptodev_socket_id( 638 ts_params->valid_devs[0])), 639 "Failed test for " 640 "rte_cryptodev_queue_pair_setup: num_inflights " 641 "%u on qp %u on cryptodev %u", 642 qp_conf.nb_descriptors, qp_id, 643 ts_params->valid_devs[0]); 644 } 645 646 qp_conf.nb_descriptors = (uint32_t)(MAX_NUM_OPS_INFLIGHT / 2); 647 648 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) { 649 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( 650 ts_params->valid_devs[0], qp_id, &qp_conf, 651 rte_cryptodev_socket_id( 652 ts_params->valid_devs[0])), 653 "Failed test for" 654 " rte_cryptodev_queue_pair_setup: num_inflights" 655 " %u on qp %u on cryptodev %u", 656 qp_conf.nb_descriptors, qp_id, 657 ts_params->valid_devs[0]); 658 } 659 660 qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; /* valid */ 661 662 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) { 663 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( 664 ts_params->valid_devs[0], qp_id, &qp_conf, 665 rte_cryptodev_socket_id( 666 ts_params->valid_devs[0])), 667 "Failed test for " 668 "rte_cryptodev_queue_pair_setup: num_inflights" 669 " %u on qp %u on cryptodev %u", 670 qp_conf.nb_descriptors, qp_id, 671 ts_params->valid_devs[0]); 672 } 673 674 /* invalid number of descriptors - max supported + 2 */ 675 qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT + 2; 676 677 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) { 678 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup( 679 ts_params->valid_devs[0], qp_id, &qp_conf, 680 rte_cryptodev_socket_id( 681 ts_params->valid_devs[0])), 682 "Unexpectedly passed test for " 683 "rte_cryptodev_queue_pair_setup:" 684 "num_inflights %u on qp %u on cryptodev %u", 685 qp_conf.nb_descriptors, qp_id, 686 ts_params->valid_devs[0]); 687 } 688 689 /* invalid number of descriptors - max value of parameter */ 690 qp_conf.nb_descriptors = UINT32_MAX-1; 691 692 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) { 693 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup( 694 ts_params->valid_devs[0], qp_id, &qp_conf, 695 rte_cryptodev_socket_id( 696 ts_params->valid_devs[0])), 697 "Unexpectedly passed test for " 698 "rte_cryptodev_queue_pair_setup:" 699 "num_inflights %u on qp %u on cryptodev %u", 700 qp_conf.nb_descriptors, qp_id, 701 ts_params->valid_devs[0]); 702 } 703 704 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT; 705 706 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) { 707 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( 708 ts_params->valid_devs[0], qp_id, &qp_conf, 709 rte_cryptodev_socket_id( 710 ts_params->valid_devs[0])), 711 "Failed test for" 712 " rte_cryptodev_queue_pair_setup:" 713 "num_inflights %u on qp %u on cryptodev %u", 714 qp_conf.nb_descriptors, qp_id, 715 ts_params->valid_devs[0]); 716 } 717 718 /* invalid number of descriptors - max supported + 1 */ 719 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT + 1; 720 721 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) { 722 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup( 723 ts_params->valid_devs[0], qp_id, &qp_conf, 724 rte_cryptodev_socket_id( 725 ts_params->valid_devs[0])), 726 "Unexpectedly passed test for " 727 "rte_cryptodev_queue_pair_setup:" 728 "num_inflights %u on qp %u on cryptodev %u", 729 qp_conf.nb_descriptors, qp_id, 730 ts_params->valid_devs[0]); 731 } 732 733 /* test invalid queue pair id */ 734 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT; /*valid */ 735 736 qp_id = DEFAULT_NUM_QPS_PER_QAT_DEVICE; /*invalid */ 737 738 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup( 739 ts_params->valid_devs[0], 740 qp_id, &qp_conf, 741 rte_cryptodev_socket_id(ts_params->valid_devs[0])), 742 "Failed test for rte_cryptodev_queue_pair_setup:" 743 "invalid qp %u on cryptodev %u", 744 qp_id, ts_params->valid_devs[0]); 745 746 qp_id = 0xffff; /*invalid*/ 747 748 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup( 749 ts_params->valid_devs[0], 750 qp_id, &qp_conf, 751 rte_cryptodev_socket_id(ts_params->valid_devs[0])), 752 "Failed test for rte_cryptodev_queue_pair_setup:" 753 "invalid qp %u on cryptodev %u", 754 qp_id, ts_params->valid_devs[0]); 755 756 return TEST_SUCCESS; 757 } 758 759 /* ***** Plaintext data for tests ***** */ 760 761 const char catch_22_quote_1[] = 762 "There was only one catch and that was Catch-22, which " 763 "specified that a concern for one's safety in the face of " 764 "dangers that were real and immediate was the process of a " 765 "rational mind. Orr was crazy and could be grounded. All he " 766 "had to do was ask; and as soon as he did, he would no longer " 767 "be crazy and would have to fly more missions. Orr would be " 768 "crazy to fly more missions and sane if he didn't, but if he " 769 "was sane he had to fly them. If he flew them he was crazy " 770 "and didn't have to; but if he didn't want to he was sane and " 771 "had to. Yossarian was moved very deeply by the absolute " 772 "simplicity of this clause of Catch-22 and let out a " 773 "respectful whistle. \"That's some catch, that Catch-22\", he " 774 "observed. \"It's the best there is,\" Doc Daneeka agreed."; 775 776 const char catch_22_quote[] = 777 "What a lousy earth! He wondered how many people were " 778 "destitute that same night even in his own prosperous country, " 779 "how many homes were shanties, how many husbands were drunk " 780 "and wives socked, and how many children were bullied, abused, " 781 "or abandoned. How many families hungered for food they could " 782 "not afford to buy? How many hearts were broken? How many " 783 "suicides would take place that same night, how many people " 784 "would go insane? How many cockroaches and landlords would " 785 "triumph? How many winners were losers, successes failures, " 786 "and rich men poor men? How many wise guys were stupid? How " 787 "many happy endings were unhappy endings? How many honest men " 788 "were liars, brave men cowards, loyal men traitors, how many " 789 "sainted men were corrupt, how many people in positions of " 790 "trust had sold their souls to bodyguards, how many had never " 791 "had souls? How many straight-and-narrow paths were crooked " 792 "paths? How many best families were worst families and how " 793 "many good people were bad people? When you added them all up " 794 "and then subtracted, you might be left with only the children, " 795 "and perhaps with Albert Einstein and an old violinist or " 796 "sculptor somewhere."; 797 798 #define QUOTE_480_BYTES (480) 799 #define QUOTE_512_BYTES (512) 800 #define QUOTE_768_BYTES (768) 801 #define QUOTE_1024_BYTES (1024) 802 803 804 805 /* ***** SHA1 Hash Tests ***** */ 806 807 #define HMAC_KEY_LENGTH_SHA1 (DIGEST_BYTE_LENGTH_SHA1) 808 809 static uint8_t hmac_sha1_key[] = { 810 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA, 811 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD, 812 0xDE, 0xF4, 0xDE, 0xAD }; 813 814 /* ***** SHA224 Hash Tests ***** */ 815 816 #define HMAC_KEY_LENGTH_SHA224 (DIGEST_BYTE_LENGTH_SHA224) 817 818 819 /* ***** AES-CBC Cipher Tests ***** */ 820 821 #define CIPHER_KEY_LENGTH_AES_CBC (16) 822 #define CIPHER_IV_LENGTH_AES_CBC (CIPHER_KEY_LENGTH_AES_CBC) 823 824 static uint8_t aes_cbc_key[] = { 825 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2, 826 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A }; 827 828 static uint8_t aes_cbc_iv[] = { 829 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 830 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f }; 831 832 833 /* ***** AES-CBC / HMAC-SHA1 Hash Tests ***** */ 834 835 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_ciphertext[] = { 836 0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31, 837 0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76, 838 0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E, 839 0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A, 840 0x3F, 0x6B, 0x5D, 0xDF, 0x52, 0x85, 0x5F, 0x8E, 841 0x42, 0x3C, 0xFB, 0xE9, 0x1A, 0x24, 0xD6, 0x08, 842 0xDD, 0xFD, 0x16, 0xFB, 0xE9, 0x55, 0xEF, 0xF0, 843 0xA0, 0x8D, 0x13, 0xAB, 0x81, 0xC6, 0x90, 0x01, 844 0xB5, 0x18, 0x84, 0xB3, 0xF6, 0xE6, 0x11, 0x57, 845 0xD6, 0x71, 0xC6, 0x3C, 0x3F, 0x2F, 0x33, 0xEE, 846 0x24, 0x42, 0x6E, 0xAC, 0x0B, 0xCA, 0xEC, 0xF9, 847 0x84, 0xF8, 0x22, 0xAA, 0x60, 0xF0, 0x32, 0xA9, 848 0x75, 0x75, 0x3B, 0xCB, 0x70, 0x21, 0x0A, 0x8D, 849 0x0F, 0xE0, 0xC4, 0x78, 0x2B, 0xF8, 0x97, 0xE3, 850 0xE4, 0x26, 0x4B, 0x29, 0xDA, 0x88, 0xCD, 0x46, 851 0xEC, 0xAA, 0xF9, 0x7F, 0xF1, 0x15, 0xEA, 0xC3, 852 0x87, 0xE6, 0x31, 0xF2, 0xCF, 0xDE, 0x4D, 0x80, 853 0x70, 0x91, 0x7E, 0x0C, 0xF7, 0x26, 0x3A, 0x92, 854 0x4F, 0x18, 0x83, 0xC0, 0x8F, 0x59, 0x01, 0xA5, 855 0x88, 0xD1, 0xDB, 0x26, 0x71, 0x27, 0x16, 0xF5, 856 0xEE, 0x10, 0x82, 0xAC, 0x68, 0x26, 0x9B, 0xE2, 857 0x6D, 0xD8, 0x9A, 0x80, 0xDF, 0x04, 0x31, 0xD5, 858 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA, 859 0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76, 860 0x73, 0x02, 0x42, 0xC9, 0x23, 0x18, 0x8E, 0xB4, 861 0x6F, 0xB4, 0xA3, 0x54, 0x6E, 0x88, 0x3B, 0x62, 862 0x7C, 0x02, 0x8D, 0x4C, 0x9F, 0xC8, 0x45, 0xF4, 863 0xC9, 0xDE, 0x4F, 0xEB, 0x22, 0x83, 0x1B, 0xE4, 864 0x49, 0x37, 0xE4, 0xAD, 0xE7, 0xCD, 0x21, 0x54, 865 0xBC, 0x1C, 0xC2, 0x04, 0x97, 0xB4, 0x10, 0x61, 866 0xF0, 0xE4, 0xEF, 0x27, 0x63, 0x3A, 0xDA, 0x91, 867 0x41, 0x25, 0x62, 0x1C, 0x5C, 0xB6, 0x38, 0x4A, 868 0x88, 0x71, 0x59, 0x5A, 0x8D, 0xA0, 0x09, 0xAF, 869 0x72, 0x94, 0xD7, 0x79, 0x5C, 0x60, 0x7C, 0x8F, 870 0x4C, 0xF5, 0xD9, 0xA1, 0x39, 0x6D, 0x81, 0x28, 871 0xEF, 0x13, 0x28, 0xDF, 0xF5, 0x3E, 0xF7, 0x8E, 872 0x09, 0x9C, 0x78, 0x18, 0x79, 0xB8, 0x68, 0xD7, 873 0xA8, 0x29, 0x62, 0xAD, 0xDE, 0xE1, 0x61, 0x76, 874 0x1B, 0x05, 0x16, 0xCD, 0xBF, 0x02, 0x8E, 0xA6, 875 0x43, 0x6E, 0x92, 0x55, 0x4F, 0x60, 0x9C, 0x03, 876 0xB8, 0x4F, 0xA3, 0x02, 0xAC, 0xA8, 0xA7, 0x0C, 877 0x1E, 0xB5, 0x6B, 0xF8, 0xC8, 0x4D, 0xDE, 0xD2, 878 0xB0, 0x29, 0x6E, 0x40, 0xE6, 0xD6, 0xC9, 0xE6, 879 0xB9, 0x0F, 0xB6, 0x63, 0xF5, 0xAA, 0x2B, 0x96, 880 0xA7, 0x16, 0xAC, 0x4E, 0x0A, 0x33, 0x1C, 0xA6, 881 0xE6, 0xBD, 0x8A, 0xCF, 0x40, 0xA9, 0xB2, 0xFA, 882 0x63, 0x27, 0xFD, 0x9B, 0xD9, 0xFC, 0xD5, 0x87, 883 0x8D, 0x4C, 0xB6, 0xA4, 0xCB, 0xE7, 0x74, 0x55, 884 0xF4, 0xFB, 0x41, 0x25, 0xB5, 0x4B, 0x0A, 0x1B, 885 0xB1, 0xD6, 0xB7, 0xD9, 0x47, 0x2A, 0xC3, 0x98, 886 0x6A, 0xC4, 0x03, 0x73, 0x1F, 0x93, 0x6E, 0x53, 887 0x19, 0x25, 0x64, 0x15, 0x83, 0xF9, 0x73, 0x2A, 888 0x74, 0xB4, 0x93, 0x69, 0xC4, 0x72, 0xFC, 0x26, 889 0xA2, 0x9F, 0x43, 0x45, 0xDD, 0xB9, 0xEF, 0x36, 890 0xC8, 0x3A, 0xCD, 0x99, 0x9B, 0x54, 0x1A, 0x36, 891 0xC1, 0x59, 0xF8, 0x98, 0xA8, 0xCC, 0x28, 0x0D, 892 0x73, 0x4C, 0xEE, 0x98, 0xCB, 0x7C, 0x58, 0x7E, 893 0x20, 0x75, 0x1E, 0xB7, 0xC9, 0xF8, 0xF2, 0x0E, 894 0x63, 0x9E, 0x05, 0x78, 0x1A, 0xB6, 0xA8, 0x7A, 895 0xF9, 0x98, 0x6A, 0xA6, 0x46, 0x84, 0x2E, 0xF6, 896 0x4B, 0xDC, 0x9B, 0x8F, 0x9B, 0x8F, 0xEE, 0xB4, 897 0xAA, 0x3F, 0xEE, 0xC0, 0x37, 0x27, 0x76, 0xC7, 898 0x95, 0xBB, 0x26, 0x74, 0x69, 0x12, 0x7F, 0xF1, 899 0xBB, 0xFF, 0xAE, 0xB5, 0x99, 0x6E, 0xCB, 0x0C 900 }; 901 902 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest[] = { 903 0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60, 904 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1, 905 0x18, 0x8c, 0x1d, 0x32 906 }; 907 908 909 /* Multisession Vector context Test */ 910 /*Begin Session 0 */ 911 static uint8_t ms_aes_cbc_key0[] = { 912 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 913 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff 914 }; 915 916 static uint8_t ms_aes_cbc_iv0[] = { 917 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 918 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff 919 }; 920 921 static const uint8_t ms_aes_cbc_cipher0[] = { 922 0x3C, 0xE4, 0xEE, 0x42, 0xB6, 0x9B, 0xC3, 0x38, 923 0x5F, 0xAD, 0x54, 0xDC, 0xA8, 0x32, 0x81, 0xDC, 924 0x7A, 0x6F, 0x85, 0x58, 0x07, 0x35, 0xED, 0xEB, 925 0xAD, 0x79, 0x79, 0x96, 0xD3, 0x0E, 0xA6, 0xD9, 926 0xAA, 0x86, 0xA4, 0x8F, 0xB5, 0xD6, 0x6E, 0x6D, 927 0x0C, 0x91, 0x2F, 0xC4, 0x67, 0x98, 0x0E, 0xC4, 928 0x8D, 0x83, 0x68, 0x69, 0xC4, 0xD3, 0x94, 0x34, 929 0xC4, 0x5D, 0x60, 0x55, 0x22, 0x87, 0x8F, 0x6F, 930 0x17, 0x8E, 0x75, 0xE4, 0x02, 0xF5, 0x1B, 0x99, 931 0xC8, 0x39, 0xA9, 0xAB, 0x23, 0x91, 0x12, 0xED, 932 0x08, 0xE7, 0xD9, 0x25, 0x89, 0x24, 0x4F, 0x8D, 933 0x68, 0xF3, 0x10, 0x39, 0x0A, 0xEE, 0x45, 0x24, 934 0xDF, 0x7A, 0x9D, 0x00, 0x25, 0xE5, 0x35, 0x71, 935 0x4E, 0x40, 0x59, 0x6F, 0x0A, 0x13, 0xB3, 0x72, 936 0x1D, 0x98, 0x63, 0x94, 0x89, 0xA5, 0x39, 0x8E, 937 0xD3, 0x9C, 0x8A, 0x7F, 0x71, 0x2F, 0xC7, 0xCD, 938 0x81, 0x05, 0xDC, 0xC0, 0x8D, 0xCE, 0x6D, 0x18, 939 0x30, 0xC4, 0x72, 0x51, 0xF0, 0x27, 0xC8, 0xF6, 940 0x60, 0x5B, 0x7C, 0xB2, 0xE3, 0x49, 0x0C, 0x29, 941 0xC6, 0x9F, 0x39, 0x57, 0x80, 0x55, 0x24, 0x2C, 942 0x9B, 0x0F, 0x5A, 0xB3, 0x89, 0x55, 0x31, 0x96, 943 0x0D, 0xCD, 0xF6, 0x51, 0x03, 0x2D, 0x89, 0x26, 944 0x74, 0x44, 0xD6, 0xE8, 0xDC, 0xEA, 0x44, 0x55, 945 0x64, 0x71, 0x9C, 0x9F, 0x5D, 0xBA, 0x39, 0x46, 946 0xA8, 0x17, 0xA1, 0x9C, 0x52, 0x9D, 0xBC, 0x6B, 947 0x4A, 0x98, 0xE6, 0xEA, 0x33, 0xEC, 0x58, 0xB4, 948 0x43, 0xF0, 0x32, 0x45, 0xA4, 0xC1, 0x55, 0xB7, 949 0x5D, 0xB5, 0x59, 0xB2, 0xE3, 0x96, 0xFF, 0xA5, 950 0xAF, 0xE1, 0x86, 0x1B, 0x42, 0xE6, 0x3B, 0xA0, 951 0x90, 0x4A, 0xE8, 0x8C, 0x21, 0x7F, 0x36, 0x1E, 952 0x5B, 0x65, 0x25, 0xD1, 0xC1, 0x5A, 0xCA, 0x3D, 953 0x10, 0xED, 0x2D, 0x79, 0xD0, 0x0F, 0x58, 0x44, 954 0x69, 0x81, 0xF5, 0xD4, 0xC9, 0x0F, 0x90, 0x76, 955 0x1F, 0x54, 0xD2, 0xD5, 0x97, 0xCE, 0x2C, 0xE3, 956 0xEF, 0xF4, 0xB7, 0xC6, 0x3A, 0x87, 0x7F, 0x83, 957 0x2A, 0xAF, 0xCD, 0x90, 0x12, 0xA7, 0x7D, 0x85, 958 0x1D, 0x62, 0xD3, 0x85, 0x25, 0x05, 0xDB, 0x45, 959 0x92, 0xA3, 0xF6, 0xA2, 0xA8, 0x41, 0xE4, 0x25, 960 0x86, 0x87, 0x67, 0x24, 0xEC, 0x89, 0x23, 0x2A, 961 0x9B, 0x20, 0x4D, 0x93, 0xEE, 0xE2, 0x2E, 0xC1, 962 0x0B, 0x15, 0x33, 0xCF, 0x00, 0xD1, 0x1A, 0xDA, 963 0x93, 0xFD, 0x28, 0x21, 0x5B, 0xCF, 0xD1, 0xF3, 964 0x5A, 0x81, 0xBA, 0x82, 0x5E, 0x2F, 0x61, 0xB4, 965 0x05, 0x71, 0xB5, 0xF4, 0x39, 0x3C, 0x1F, 0x60, 966 0x00, 0x7A, 0xC4, 0xF8, 0x35, 0x20, 0x6C, 0x3A, 967 0xCC, 0x03, 0x8F, 0x7B, 0xA2, 0xB6, 0x65, 0x8A, 968 0xB6, 0x5F, 0xFD, 0x25, 0xD3, 0x5F, 0x92, 0xF9, 969 0xAE, 0x17, 0x9B, 0x5E, 0x6E, 0x9A, 0xE4, 0x55, 970 0x10, 0x25, 0x07, 0xA4, 0xAF, 0x21, 0x69, 0x13, 971 0xD8, 0xFA, 0x31, 0xED, 0xF7, 0xA7, 0xA7, 0x3B, 972 0xB8, 0x96, 0x8E, 0x10, 0x86, 0x74, 0xD8, 0xB1, 973 0x34, 0x9E, 0x9B, 0x6A, 0x26, 0xA8, 0xD4, 0xD0, 974 0xB5, 0xF6, 0xDE, 0xE7, 0xCA, 0x06, 0xDC, 0xA3, 975 0x6F, 0xEE, 0x6B, 0x1E, 0xB5, 0x30, 0x99, 0x23, 976 0xF9, 0x76, 0xF0, 0xA0, 0xCF, 0x3B, 0x94, 0x7B, 977 0x19, 0x8D, 0xA5, 0x0C, 0x18, 0xA6, 0x1D, 0x07, 978 0x89, 0xBE, 0x5B, 0x61, 0xE5, 0xF1, 0x42, 0xDB, 979 0xD4, 0x2E, 0x02, 0x1F, 0xCE, 0xEF, 0x92, 0xB1, 980 0x1B, 0x56, 0x50, 0xF2, 0x16, 0xE5, 0xE7, 0x4F, 981 0xFD, 0xBB, 0x3E, 0xD2, 0xFC, 0x3C, 0xC6, 0x0F, 982 0xF9, 0x12, 0x4E, 0xCB, 0x1E, 0x0C, 0x15, 0x84, 983 0x2A, 0x14, 0x8A, 0x02, 0xE4, 0x7E, 0x95, 0x5B, 984 0x86, 0xDB, 0x9B, 0x62, 0x5B, 0x19, 0xD2, 0x17, 985 0xFA, 0x13, 0xBB, 0x6B, 0x3F, 0x45, 0x9F, 0xBF 986 }; 987 988 989 static uint8_t ms_hmac_key0[] = { 990 0xFF, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1, 991 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA, 992 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76, 993 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60, 994 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1, 995 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0, 996 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76, 997 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60 998 }; 999 1000 static const uint8_t ms_hmac_digest0[] = { 1001 0x43, 0x52, 0xED, 0x34, 0xAB, 0x36, 0xB2, 0x51, 1002 0xFB, 0xA3, 0xA6, 0x7C, 0x38, 0xFC, 0x42, 0x8F, 1003 0x57, 0x64, 0xAB, 0x81, 0xA7, 0x89, 0xB7, 0x6C, 1004 0xA0, 0xDC, 0xB9, 0x4D, 0xC4, 0x30, 0xF9, 0xD4, 1005 0x10, 0x82, 0x55, 0xD0, 0xAB, 0x32, 0xFB, 0x56, 1006 0x0D, 0xE4, 0x68, 0x3D, 0x76, 0xD0, 0x7B, 0xE4, 1007 0xA6, 0x2C, 0x34, 0x9E, 0x8C, 0x41, 0xF8, 0x23, 1008 0x28, 0x1B, 0x3A, 0x90, 0x26, 0x34, 0x47, 0x90 1009 }; 1010 1011 /* End Session 0 */ 1012 /* Begin session 1 */ 1013 1014 static uint8_t ms_aes_cbc_key1[] = { 1015 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 1016 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff 1017 }; 1018 1019 static uint8_t ms_aes_cbc_iv1[] = { 1020 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 1021 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff 1022 }; 1023 1024 static const uint8_t ms_aes_cbc_cipher1[] = { 1025 0x5A, 0x7A, 0x67, 0x5D, 0xB8, 0xE1, 0xDC, 0x71, 1026 0x39, 0xA8, 0x74, 0x93, 0x9C, 0x4C, 0xFE, 0x23, 1027 0x61, 0xCD, 0xA4, 0xB3, 0xD9, 0xCE, 0x99, 0x09, 1028 0x2A, 0x23, 0xF3, 0x29, 0xBF, 0x4C, 0xB4, 0x6A, 1029 0x1B, 0x6B, 0x73, 0x4D, 0x48, 0x0C, 0xCF, 0x6C, 1030 0x5E, 0x34, 0x9E, 0x7F, 0xBC, 0x8F, 0xCC, 0x8F, 1031 0x75, 0x1D, 0x3D, 0x77, 0x10, 0x76, 0xC8, 0xB9, 1032 0x99, 0x6F, 0xD6, 0x56, 0x75, 0xA9, 0xB2, 0x66, 1033 0xC2, 0x24, 0x2B, 0x9C, 0xFE, 0x40, 0x8E, 0x43, 1034 0x20, 0x97, 0x1B, 0xFA, 0xD0, 0xCF, 0x04, 0xAB, 1035 0xBB, 0xF6, 0x5D, 0xF5, 0xA0, 0x19, 0x7C, 0x23, 1036 0x5D, 0x80, 0x8C, 0x49, 0xF6, 0x76, 0x88, 0x29, 1037 0x27, 0x4C, 0x59, 0x2B, 0x43, 0xA6, 0xB2, 0x26, 1038 0x27, 0x78, 0xBE, 0x1B, 0xE1, 0x4F, 0x5A, 0x1F, 1039 0xFC, 0x68, 0x08, 0xE7, 0xC4, 0xD1, 0x34, 0x68, 1040 0xB7, 0x13, 0x14, 0x41, 0x62, 0x6B, 0x1F, 0x77, 1041 0x0C, 0x68, 0x1D, 0x0D, 0xED, 0x89, 0xAA, 0xD8, 1042 0x97, 0x02, 0xBA, 0x5E, 0xD4, 0x84, 0x25, 0x97, 1043 0x03, 0xA5, 0xA6, 0x13, 0x66, 0x02, 0xF4, 0xC3, 1044 0xF3, 0xD3, 0xCC, 0x95, 0xC3, 0x87, 0x46, 0x90, 1045 0x1F, 0x6E, 0x14, 0xA8, 0x00, 0xF2, 0x6F, 0xD5, 1046 0xA1, 0xAD, 0xD5, 0x40, 0xA2, 0x0F, 0x32, 0x7E, 1047 0x99, 0xA3, 0xF5, 0x53, 0xC3, 0x26, 0xA1, 0x45, 1048 0x01, 0x88, 0x57, 0x84, 0x3E, 0x7B, 0x4E, 0x0B, 1049 0x3C, 0xB5, 0x3E, 0x9E, 0xE9, 0x78, 0x77, 0xC5, 1050 0xC0, 0x89, 0xA8, 0xF8, 0xF1, 0xA5, 0x2D, 0x5D, 1051 0xF9, 0xC6, 0xFB, 0xCB, 0x05, 0x23, 0xBD, 0x6E, 1052 0x5E, 0x14, 0xC6, 0x57, 0x73, 0xCF, 0x98, 0xBD, 1053 0x10, 0x8B, 0x18, 0xA6, 0x01, 0x5B, 0x13, 0xAE, 1054 0x8E, 0xDE, 0x1F, 0xB5, 0xB7, 0x40, 0x6C, 0xC1, 1055 0x1E, 0xA1, 0x19, 0x20, 0x9E, 0x95, 0xE0, 0x2F, 1056 0x1C, 0xF5, 0xD9, 0xD0, 0x2B, 0x1E, 0x82, 0x25, 1057 0x62, 0xB4, 0xEB, 0xA1, 0x1F, 0xCE, 0x44, 0xA1, 1058 0xCB, 0x92, 0x01, 0x6B, 0xE4, 0x26, 0x23, 0xE3, 1059 0xC5, 0x67, 0x35, 0x55, 0xDA, 0xE5, 0x27, 0xEE, 1060 0x8D, 0x12, 0x84, 0xB7, 0xBA, 0xA7, 0x1C, 0xD6, 1061 0x32, 0x3F, 0x67, 0xED, 0xFB, 0x5B, 0x8B, 0x52, 1062 0x46, 0x8C, 0xF9, 0x69, 0xCD, 0xAE, 0x79, 0xAA, 1063 0x37, 0x78, 0x49, 0xEB, 0xC6, 0x8E, 0x76, 0x63, 1064 0x84, 0xFF, 0x9D, 0x22, 0x99, 0x51, 0xB7, 0x5E, 1065 0x83, 0x4C, 0x8B, 0xDF, 0x5A, 0x07, 0xCC, 0xBA, 1066 0x42, 0xA5, 0x98, 0xB6, 0x47, 0x0E, 0x66, 0xEB, 1067 0x23, 0x0E, 0xBA, 0x44, 0xA8, 0xAA, 0x20, 0x71, 1068 0x79, 0x9C, 0x77, 0x5F, 0xF5, 0xFE, 0xEC, 0xEF, 1069 0xC6, 0x64, 0x3D, 0x84, 0xD0, 0x2B, 0xA7, 0x0A, 1070 0xC3, 0x72, 0x5B, 0x9C, 0xFA, 0xA8, 0x87, 0x95, 1071 0x94, 0x11, 0x38, 0xA7, 0x1E, 0x58, 0xE3, 0x73, 1072 0xC6, 0xC9, 0xD1, 0x7B, 0x92, 0xDB, 0x0F, 0x49, 1073 0x74, 0xC2, 0xA2, 0x0E, 0x35, 0x57, 0xAC, 0xDB, 1074 0x9A, 0x1C, 0xCF, 0x5A, 0x32, 0x3E, 0x26, 0x9B, 1075 0xEC, 0xB3, 0xEF, 0x9C, 0xFE, 0xBE, 0x52, 0xAC, 1076 0xB1, 0x29, 0xDD, 0xFD, 0x07, 0xE2, 0xEE, 0xED, 1077 0xE4, 0x46, 0x37, 0xFE, 0xD1, 0xDC, 0xCD, 0x02, 1078 0xF9, 0x31, 0xB0, 0xFB, 0x36, 0xB7, 0x34, 0xA4, 1079 0x76, 0xE8, 0x57, 0xBF, 0x99, 0x92, 0xC7, 0xAF, 1080 0x98, 0x10, 0xE2, 0x70, 0xCA, 0xC9, 0x2B, 0x82, 1081 0x06, 0x96, 0x88, 0x0D, 0xB3, 0xAC, 0x9E, 0x6D, 1082 0x43, 0xBC, 0x5B, 0x31, 0xCF, 0x65, 0x8D, 0xA6, 1083 0xC7, 0xFE, 0x73, 0xE1, 0x54, 0xF7, 0x10, 0xF9, 1084 0x86, 0xF7, 0xDF, 0xA1, 0xA1, 0xD8, 0xAE, 0x35, 1085 0xB3, 0x90, 0xDC, 0x6F, 0x43, 0x7A, 0x8B, 0xE0, 1086 0xFE, 0x8F, 0x33, 0x4D, 0x29, 0x6C, 0x45, 0x53, 1087 0x73, 0xDD, 0x21, 0x0B, 0x85, 0x30, 0xB5, 0xA5, 1088 0xF3, 0x5D, 0xEC, 0x79, 0x61, 0x9D, 0x9E, 0xB3 1089 1090 }; 1091 1092 static uint8_t ms_hmac_key1[] = { 1093 0xFE, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1, 1094 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA, 1095 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76, 1096 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60, 1097 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1, 1098 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0, 1099 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76, 1100 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60 1101 }; 1102 1103 static const uint8_t ms_hmac_digest1[] = { 1104 0xCE, 0x6E, 0x5F, 0x77, 0x96, 0x9A, 0xB1, 0x69, 1105 0x2D, 0x5E, 0xF3, 0x2F, 0x32, 0x10, 0xCB, 0x50, 1106 0x0E, 0x09, 0x56, 0x25, 0x07, 0x34, 0xC9, 0x20, 1107 0xEC, 0x13, 0x43, 0x23, 0x5C, 0x08, 0x8B, 0xCD, 1108 0xDC, 0x86, 0x8C, 0xEE, 0x0A, 0x95, 0x2E, 0xB9, 1109 0x8C, 0x7B, 0x02, 0x7A, 0xD4, 0xE1, 0x49, 0xB4, 1110 0x45, 0xB5, 0x52, 0x37, 0xC6, 0xFF, 0xFE, 0xAA, 1111 0x0A, 0x87, 0xB8, 0x51, 0xF9, 0x2A, 0x01, 0x8F 1112 }; 1113 /* End Session 1 */ 1114 /* Begin Session 2 */ 1115 static uint8_t ms_aes_cbc_key2[] = { 1116 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 1117 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff 1118 }; 1119 1120 static uint8_t ms_aes_cbc_iv2[] = { 1121 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 1122 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff 1123 }; 1124 1125 static const uint8_t ms_aes_cbc_cipher2[] = { 1126 0xBB, 0x3C, 0x68, 0x25, 0xFD, 0xB6, 0xA2, 0x91, 1127 0x20, 0x56, 0xF6, 0x30, 0x35, 0xFC, 0x9E, 0x97, 1128 0xF2, 0x90, 0xFC, 0x7E, 0x3E, 0x0A, 0x75, 0xC8, 1129 0x4C, 0xF2, 0x2D, 0xAC, 0xD3, 0x93, 0xF0, 0xC5, 1130 0x14, 0x88, 0x8A, 0x23, 0xC2, 0x59, 0x9A, 0x98, 1131 0x4B, 0xD5, 0x2C, 0xDA, 0x43, 0xA9, 0x34, 0x69, 1132 0x7C, 0x6D, 0xDB, 0xDC, 0xCB, 0xC0, 0xA0, 0x09, 1133 0xA7, 0x86, 0x16, 0x4B, 0xBF, 0xA8, 0xB6, 0xCF, 1134 0x7F, 0x74, 0x1F, 0x22, 0xF0, 0xF6, 0xBB, 0x44, 1135 0x8B, 0x4C, 0x9E, 0x23, 0xF8, 0x9F, 0xFC, 0x5B, 1136 0x9E, 0x9C, 0x2A, 0x79, 0x30, 0x8F, 0xBF, 0xA9, 1137 0x68, 0xA1, 0x20, 0x71, 0x7C, 0x77, 0x22, 0x34, 1138 0x07, 0xCD, 0xC6, 0xF6, 0x50, 0x0A, 0x08, 0x99, 1139 0x17, 0x98, 0xE3, 0x93, 0x8A, 0xB0, 0xEE, 0xDF, 1140 0xC2, 0xBA, 0x3B, 0x44, 0x73, 0xDF, 0xDD, 0xDC, 1141 0x14, 0x4D, 0x3B, 0xBB, 0x5E, 0x58, 0xC1, 0x26, 1142 0xA7, 0xAE, 0x47, 0xF3, 0x24, 0x6D, 0x4F, 0xD3, 1143 0x6E, 0x3E, 0x33, 0xE6, 0x7F, 0xCA, 0x50, 0xAF, 1144 0x5D, 0x3D, 0xA0, 0xDD, 0xC9, 0xF3, 0x30, 0xD3, 1145 0x6E, 0x8B, 0x2E, 0x12, 0x24, 0x34, 0xF0, 0xD3, 1146 0xC7, 0x8D, 0x23, 0x29, 0xAA, 0x05, 0xE1, 0xFA, 1147 0x2E, 0xF6, 0x8D, 0x37, 0x86, 0xC0, 0x6D, 0x13, 1148 0x2D, 0x98, 0xF3, 0x52, 0x39, 0x22, 0xCE, 0x38, 1149 0xC2, 0x1A, 0x72, 0xED, 0xFB, 0xCC, 0xE4, 0x71, 1150 0x5A, 0x0C, 0x0D, 0x09, 0xF8, 0xE8, 0x1B, 0xBC, 1151 0x53, 0xC8, 0xD8, 0x8F, 0xE5, 0x98, 0x5A, 0xB1, 1152 0x06, 0xA6, 0x5B, 0xE6, 0xA2, 0x88, 0x21, 0x9E, 1153 0x36, 0xC0, 0x34, 0xF9, 0xFB, 0x3B, 0x0A, 0x22, 1154 0x00, 0x00, 0x39, 0x48, 0x8D, 0x23, 0x74, 0x62, 1155 0x72, 0x91, 0xE6, 0x36, 0xAA, 0x77, 0x9C, 0x72, 1156 0x9D, 0xA8, 0xC3, 0xA9, 0xD5, 0x44, 0x72, 0xA6, 1157 0xB9, 0x28, 0x8F, 0x64, 0x4C, 0x8A, 0x64, 0xE6, 1158 0x4E, 0xFA, 0xEF, 0x87, 0xDE, 0x7B, 0x22, 0x44, 1159 0xB0, 0xDF, 0x2E, 0x5F, 0x0B, 0xA5, 0xF2, 0x24, 1160 0x07, 0x5C, 0x2D, 0x39, 0xB7, 0x3D, 0x8A, 0xE5, 1161 0x0E, 0x9D, 0x4E, 0x50, 0xED, 0x03, 0x99, 0x8E, 1162 0xF0, 0x06, 0x55, 0x4E, 0xA2, 0x24, 0xE7, 0x17, 1163 0x46, 0xDF, 0x6C, 0xCD, 0xC6, 0x44, 0xE8, 0xF9, 1164 0xB9, 0x1B, 0x36, 0xF6, 0x7F, 0x10, 0xA4, 0x7D, 1165 0x90, 0xBD, 0xE4, 0xAA, 0xD6, 0x9E, 0x18, 0x9D, 1166 0x22, 0x35, 0xD6, 0x55, 0x54, 0xAA, 0xF7, 0x22, 1167 0xA3, 0x3E, 0xEF, 0xC8, 0xA2, 0x34, 0x8D, 0xA9, 1168 0x37, 0x63, 0xA6, 0xC3, 0x57, 0xCB, 0x0C, 0x49, 1169 0x7D, 0x02, 0xBE, 0xAA, 0x13, 0x75, 0xB7, 0x4E, 1170 0x52, 0x62, 0xA5, 0xC2, 0x33, 0xC7, 0x6C, 0x1B, 1171 0xF6, 0x34, 0xF6, 0x09, 0xA5, 0x0C, 0xC7, 0xA2, 1172 0x61, 0x48, 0x62, 0x7D, 0x17, 0x15, 0xE3, 0x95, 1173 0xC8, 0x63, 0xD2, 0xA4, 0x43, 0xA9, 0x49, 0x07, 1174 0xB2, 0x3B, 0x2B, 0x62, 0x7D, 0xCB, 0x51, 0xB3, 1175 0x25, 0x33, 0x47, 0x0E, 0x14, 0x67, 0xDC, 0x6A, 1176 0x9B, 0x51, 0xAC, 0x9D, 0x8F, 0xA2, 0x2B, 0x57, 1177 0x8C, 0x5C, 0x5F, 0x76, 0x23, 0x92, 0x0F, 0x84, 1178 0x46, 0x0E, 0x40, 0x85, 0x38, 0x60, 0xFA, 0x61, 1179 0x20, 0xC5, 0xE3, 0xF1, 0x70, 0xAC, 0x1B, 0xBF, 1180 0xC4, 0x2B, 0xC5, 0x67, 0xD1, 0x43, 0xC5, 0x17, 1181 0x74, 0x71, 0x69, 0x6F, 0x82, 0x89, 0x19, 0x8A, 1182 0x70, 0x43, 0x92, 0x01, 0xC4, 0x63, 0x7E, 0xB1, 1183 0x59, 0x4E, 0xCD, 0xEA, 0x93, 0xA4, 0x52, 0x53, 1184 0x9B, 0x61, 0x5B, 0xD2, 0x3E, 0x19, 0x39, 0xB7, 1185 0x32, 0xEA, 0x8E, 0xF8, 0x1D, 0x76, 0x5C, 0xB2, 1186 0x73, 0x2D, 0x91, 0xC0, 0x18, 0xED, 0x25, 0x2A, 1187 0x53, 0x64, 0xF0, 0x92, 0x31, 0x55, 0x21, 0xA8, 1188 0x24, 0xA9, 0xD1, 0x02, 0xF6, 0x6C, 0x2B, 0x70, 1189 0xA9, 0x59, 0xC1, 0xD6, 0xC3, 0x57, 0x5B, 0x92 1190 }; 1191 1192 static uint8_t ms_hmac_key2[] = { 1193 0xFC, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1, 1194 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA, 1195 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76, 1196 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60, 1197 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1, 1198 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0, 1199 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76, 1200 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60 1201 }; 1202 1203 static const uint8_t ms_hmac_digest2[] = { 1204 0xA5, 0x0F, 0x9C, 0xFB, 0x08, 0x62, 0x59, 0xFF, 1205 0x80, 0x2F, 0xEB, 0x4B, 0xE1, 0x46, 0x21, 0xD6, 1206 0x02, 0x98, 0xF2, 0x8E, 0xF4, 0xEC, 0xD4, 0x77, 1207 0x86, 0x4C, 0x31, 0x28, 0xC8, 0x25, 0x80, 0x27, 1208 0x3A, 0x72, 0x5D, 0x6A, 0x56, 0x8A, 0xD3, 0x82, 1209 0xB0, 0xEC, 0x31, 0x6D, 0x8B, 0x6B, 0xB4, 0x24, 1210 0xE7, 0x62, 0xC1, 0x52, 0xBC, 0x14, 0x1B, 0x8E, 1211 0xEC, 0x9A, 0xF1, 0x47, 0x80, 0xD2, 0xB0, 0x59 1212 }; 1213 1214 /* End Session 2 */ 1215 1216 1217 static int 1218 test_AES_CBC_HMAC_SHA1_encrypt_digest(void) 1219 { 1220 struct crypto_testsuite_params *ts_params = &testsuite_params; 1221 struct crypto_unittest_params *ut_params = &unittest_params; 1222 1223 /* Generate test mbuf data and space for digest */ 1224 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool, 1225 catch_22_quote, QUOTE_512_BYTES, 0); 1226 1227 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 1228 DIGEST_BYTE_LENGTH_SHA1); 1229 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest"); 1230 1231 /* Setup Cipher Parameters */ 1232 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 1233 ut_params->cipher_xform.next = &ut_params->auth_xform; 1234 1235 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC; 1236 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; 1237 ut_params->cipher_xform.cipher.key.data = aes_cbc_key; 1238 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC; 1239 1240 /* Setup HMAC Parameters */ 1241 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 1242 1243 ut_params->auth_xform.next = NULL; 1244 1245 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; 1246 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC; 1247 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1; 1248 ut_params->auth_xform.auth.key.data = hmac_sha1_key; 1249 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1; 1250 1251 /* Create crypto session*/ 1252 ut_params->sess = rte_cryptodev_sym_session_create( 1253 ts_params->valid_devs[0], 1254 &ut_params->cipher_xform); 1255 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 1256 1257 /* Generate crypto op data structure */ 1258 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 1259 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 1260 TEST_ASSERT_NOT_NULL(ut_params->op, 1261 "Failed to allocate symmetric crypto operation struct"); 1262 1263 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 1264 1265 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 1266 1267 /* set crypto operation source mbuf */ 1268 sym_op->m_src = ut_params->ibuf; 1269 1270 /* Set crypto operation authentication parameters */ 1271 sym_op->auth.digest.data = ut_params->digest; 1272 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( 1273 ut_params->ibuf, QUOTE_512_BYTES); 1274 sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA1; 1275 1276 sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC; 1277 sym_op->auth.data.length = QUOTE_512_BYTES; 1278 1279 /* Set crypto operation cipher parameters */ 1280 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf, 1281 CIPHER_IV_LENGTH_AES_CBC); 1282 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); 1283 sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC; 1284 1285 rte_memcpy(sym_op->cipher.iv.data, aes_cbc_iv, 1286 CIPHER_IV_LENGTH_AES_CBC); 1287 1288 sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC; 1289 sym_op->cipher.data.length = QUOTE_512_BYTES; 1290 1291 /* Process crypto operation */ 1292 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], 1293 ut_params->op), "failed to process sym crypto op"); 1294 1295 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 1296 "crypto op processing failed"); 1297 1298 /* Validate obuf */ 1299 uint8_t *ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src, 1300 uint8_t *, CIPHER_IV_LENGTH_AES_CBC); 1301 1302 TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext, 1303 catch_22_quote_2_512_bytes_AES_CBC_ciphertext, 1304 QUOTE_512_BYTES, 1305 "ciphertext data not as expected"); 1306 1307 uint8_t *digest = ciphertext + QUOTE_512_BYTES; 1308 1309 TEST_ASSERT_BUFFERS_ARE_EQUAL(digest, 1310 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest, 1311 gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD ? 1312 TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 : 1313 DIGEST_BYTE_LENGTH_SHA1, 1314 "Generated digest data not as expected"); 1315 1316 return TEST_SUCCESS; 1317 } 1318 1319 /* ***** AES-CBC / HMAC-SHA512 Hash Tests ***** */ 1320 1321 #define HMAC_KEY_LENGTH_SHA512 (DIGEST_BYTE_LENGTH_SHA512) 1322 1323 static uint8_t hmac_sha512_key[] = { 1324 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1, 1325 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA, 1326 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76, 1327 0x9a, 0xaf, 0x88, 0x1b, 0xb6, 0x8f, 0xf8, 0x60, 1328 0xa2, 0x5a, 0x7f, 0x3f, 0xf4, 0x72, 0x70, 0xf1, 1329 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0, 1330 0x47, 0x3a, 0x75, 0x61, 0x5C, 0xa2, 0x10, 0x76, 1331 0x9a, 0xaf, 0x77, 0x5b, 0xb6, 0x7f, 0xf7, 0x60 }; 1332 1333 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest[] = { 1334 0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8, 1335 0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48, 1336 0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8, 1337 0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70, 1338 0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8, 1339 0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E, 1340 0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D, 1341 0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A }; 1342 1343 1344 1345 static int 1346 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params( 1347 struct crypto_unittest_params *ut_params, 1348 uint8_t *cipher_key, 1349 uint8_t *hmac_key); 1350 1351 static int 1352 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess, 1353 struct crypto_unittest_params *ut_params, 1354 struct crypto_testsuite_params *ts_params, 1355 const uint8_t *cipher, 1356 const uint8_t *digest, 1357 const uint8_t *iv); 1358 1359 1360 static int 1361 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params( 1362 struct crypto_unittest_params *ut_params, 1363 uint8_t *cipher_key, 1364 uint8_t *hmac_key) 1365 { 1366 1367 /* Setup Cipher Parameters */ 1368 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 1369 ut_params->cipher_xform.next = NULL; 1370 1371 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC; 1372 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT; 1373 ut_params->cipher_xform.cipher.key.data = cipher_key; 1374 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC; 1375 1376 /* Setup HMAC Parameters */ 1377 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 1378 ut_params->auth_xform.next = &ut_params->cipher_xform; 1379 1380 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY; 1381 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC; 1382 ut_params->auth_xform.auth.key.data = hmac_key; 1383 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512; 1384 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512; 1385 1386 return TEST_SUCCESS; 1387 } 1388 1389 1390 static int 1391 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess, 1392 struct crypto_unittest_params *ut_params, 1393 struct crypto_testsuite_params *ts_params, 1394 const uint8_t *cipher, 1395 const uint8_t *digest, 1396 const uint8_t *iv) 1397 { 1398 /* Generate test mbuf data and digest */ 1399 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool, 1400 (const char *) 1401 cipher, 1402 QUOTE_512_BYTES, 0); 1403 1404 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 1405 DIGEST_BYTE_LENGTH_SHA512); 1406 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest"); 1407 1408 rte_memcpy(ut_params->digest, 1409 digest, 1410 DIGEST_BYTE_LENGTH_SHA512); 1411 1412 /* Generate Crypto op data structure */ 1413 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 1414 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 1415 TEST_ASSERT_NOT_NULL(ut_params->op, 1416 "Failed to allocate symmetric crypto operation struct"); 1417 1418 rte_crypto_op_attach_sym_session(ut_params->op, sess); 1419 1420 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 1421 1422 /* set crypto operation source mbuf */ 1423 sym_op->m_src = ut_params->ibuf; 1424 1425 sym_op->auth.digest.data = ut_params->digest; 1426 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( 1427 ut_params->ibuf, QUOTE_512_BYTES); 1428 sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA512; 1429 1430 sym_op->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC; 1431 sym_op->auth.data.length = QUOTE_512_BYTES; 1432 1433 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend( 1434 ut_params->ibuf, CIPHER_IV_LENGTH_AES_CBC); 1435 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys_offset( 1436 ut_params->ibuf, 0); 1437 sym_op->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC; 1438 1439 rte_memcpy(sym_op->cipher.iv.data, iv, 1440 CIPHER_IV_LENGTH_AES_CBC); 1441 1442 sym_op->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC; 1443 sym_op->cipher.data.length = QUOTE_512_BYTES; 1444 1445 /* Process crypto operation */ 1446 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], 1447 ut_params->op), "failed to process sym crypto op"); 1448 1449 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 1450 "crypto op processing failed"); 1451 1452 ut_params->obuf = ut_params->op->sym->m_src; 1453 1454 /* Validate obuf */ 1455 TEST_ASSERT_BUFFERS_ARE_EQUAL( 1456 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) + 1457 CIPHER_IV_LENGTH_AES_CBC, catch_22_quote, 1458 QUOTE_512_BYTES, 1459 "Plaintext data not as expected"); 1460 1461 /* Validate obuf */ 1462 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 1463 "Digest verification failed"); 1464 1465 return TEST_SUCCESS; 1466 } 1467 1468 static int 1469 test_AES_cipheronly_mb_all(void) 1470 { 1471 struct crypto_testsuite_params *ts_params = &testsuite_params; 1472 int status; 1473 1474 status = test_blockcipher_all_tests(ts_params->mbuf_pool, 1475 ts_params->op_mpool, ts_params->valid_devs[0], 1476 RTE_CRYPTODEV_AESNI_MB_PMD, 1477 BLKCIPHER_AES_CIPHERONLY_TYPE); 1478 1479 TEST_ASSERT_EQUAL(status, 0, "Test failed"); 1480 1481 return TEST_SUCCESS; 1482 } 1483 1484 static int 1485 test_authonly_mb_all(void) 1486 { 1487 struct crypto_testsuite_params *ts_params = &testsuite_params; 1488 int status; 1489 1490 status = test_blockcipher_all_tests(ts_params->mbuf_pool, 1491 ts_params->op_mpool, ts_params->valid_devs[0], 1492 RTE_CRYPTODEV_AESNI_MB_PMD, 1493 BLKCIPHER_AUTHONLY_TYPE); 1494 1495 TEST_ASSERT_EQUAL(status, 0, "Test failed"); 1496 1497 return TEST_SUCCESS; 1498 } 1499 1500 static int 1501 test_AES_chain_mb_all(void) 1502 { 1503 struct crypto_testsuite_params *ts_params = &testsuite_params; 1504 int status; 1505 1506 status = test_blockcipher_all_tests(ts_params->mbuf_pool, 1507 ts_params->op_mpool, ts_params->valid_devs[0], 1508 RTE_CRYPTODEV_AESNI_MB_PMD, 1509 BLKCIPHER_AES_CHAIN_TYPE); 1510 1511 TEST_ASSERT_EQUAL(status, 0, "Test failed"); 1512 1513 return TEST_SUCCESS; 1514 } 1515 1516 static int 1517 test_AES_chain_openssl_all(void) 1518 { 1519 struct crypto_testsuite_params *ts_params = &testsuite_params; 1520 int status; 1521 1522 status = test_blockcipher_all_tests(ts_params->mbuf_pool, 1523 ts_params->op_mpool, ts_params->valid_devs[0], 1524 RTE_CRYPTODEV_OPENSSL_PMD, 1525 BLKCIPHER_AES_CHAIN_TYPE); 1526 1527 TEST_ASSERT_EQUAL(status, 0, "Test failed"); 1528 1529 return TEST_SUCCESS; 1530 } 1531 1532 static int 1533 test_AES_cipheronly_openssl_all(void) 1534 { 1535 struct crypto_testsuite_params *ts_params = &testsuite_params; 1536 int status; 1537 1538 status = test_blockcipher_all_tests(ts_params->mbuf_pool, 1539 ts_params->op_mpool, ts_params->valid_devs[0], 1540 RTE_CRYPTODEV_OPENSSL_PMD, 1541 BLKCIPHER_AES_CIPHERONLY_TYPE); 1542 1543 TEST_ASSERT_EQUAL(status, 0, "Test failed"); 1544 1545 return TEST_SUCCESS; 1546 } 1547 1548 static int 1549 test_AES_chain_qat_all(void) 1550 { 1551 struct crypto_testsuite_params *ts_params = &testsuite_params; 1552 int status; 1553 1554 status = test_blockcipher_all_tests(ts_params->mbuf_pool, 1555 ts_params->op_mpool, ts_params->valid_devs[0], 1556 RTE_CRYPTODEV_QAT_SYM_PMD, 1557 BLKCIPHER_AES_CHAIN_TYPE); 1558 1559 TEST_ASSERT_EQUAL(status, 0, "Test failed"); 1560 1561 return TEST_SUCCESS; 1562 } 1563 1564 static int 1565 test_AES_cipheronly_qat_all(void) 1566 { 1567 struct crypto_testsuite_params *ts_params = &testsuite_params; 1568 int status; 1569 1570 status = test_blockcipher_all_tests(ts_params->mbuf_pool, 1571 ts_params->op_mpool, ts_params->valid_devs[0], 1572 RTE_CRYPTODEV_QAT_SYM_PMD, 1573 BLKCIPHER_AES_CIPHERONLY_TYPE); 1574 1575 TEST_ASSERT_EQUAL(status, 0, "Test failed"); 1576 1577 return TEST_SUCCESS; 1578 } 1579 1580 static int 1581 test_authonly_openssl_all(void) 1582 { 1583 struct crypto_testsuite_params *ts_params = &testsuite_params; 1584 int status; 1585 1586 status = test_blockcipher_all_tests(ts_params->mbuf_pool, 1587 ts_params->op_mpool, ts_params->valid_devs[0], 1588 RTE_CRYPTODEV_OPENSSL_PMD, 1589 BLKCIPHER_AUTHONLY_TYPE); 1590 1591 TEST_ASSERT_EQUAL(status, 0, "Test failed"); 1592 1593 return TEST_SUCCESS; 1594 } 1595 1596 /* ***** SNOW 3G Tests ***** */ 1597 static int 1598 create_wireless_algo_hash_session(uint8_t dev_id, 1599 const uint8_t *key, const uint8_t key_len, 1600 const uint8_t aad_len, const uint8_t auth_len, 1601 enum rte_crypto_auth_operation op, 1602 enum rte_crypto_auth_algorithm algo) 1603 { 1604 uint8_t hash_key[key_len]; 1605 1606 struct crypto_unittest_params *ut_params = &unittest_params; 1607 1608 memcpy(hash_key, key, key_len); 1609 1610 TEST_HEXDUMP(stdout, "key:", key, key_len); 1611 1612 /* Setup Authentication Parameters */ 1613 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 1614 ut_params->auth_xform.next = NULL; 1615 1616 ut_params->auth_xform.auth.op = op; 1617 ut_params->auth_xform.auth.algo = algo; 1618 ut_params->auth_xform.auth.key.length = key_len; 1619 ut_params->auth_xform.auth.key.data = hash_key; 1620 ut_params->auth_xform.auth.digest_length = auth_len; 1621 ut_params->auth_xform.auth.add_auth_data_length = aad_len; 1622 ut_params->sess = rte_cryptodev_sym_session_create(dev_id, 1623 &ut_params->auth_xform); 1624 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 1625 return 0; 1626 } 1627 1628 static int 1629 create_wireless_algo_cipher_session(uint8_t dev_id, 1630 enum rte_crypto_cipher_operation op, 1631 enum rte_crypto_cipher_algorithm algo, 1632 const uint8_t *key, const uint8_t key_len) 1633 { 1634 uint8_t cipher_key[key_len]; 1635 1636 struct crypto_unittest_params *ut_params = &unittest_params; 1637 1638 memcpy(cipher_key, key, key_len); 1639 1640 /* Setup Cipher Parameters */ 1641 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 1642 ut_params->cipher_xform.next = NULL; 1643 1644 ut_params->cipher_xform.cipher.algo = algo; 1645 ut_params->cipher_xform.cipher.op = op; 1646 ut_params->cipher_xform.cipher.key.data = cipher_key; 1647 ut_params->cipher_xform.cipher.key.length = key_len; 1648 1649 TEST_HEXDUMP(stdout, "key:", key, key_len); 1650 1651 /* Create Crypto session */ 1652 ut_params->sess = rte_cryptodev_sym_session_create(dev_id, 1653 &ut_params-> 1654 cipher_xform); 1655 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 1656 return 0; 1657 } 1658 1659 static int 1660 create_wireless_algo_cipher_operation(const uint8_t *iv, const unsigned iv_len, 1661 const unsigned cipher_len, 1662 const unsigned cipher_offset, 1663 enum rte_crypto_cipher_algorithm algo) 1664 { 1665 struct crypto_testsuite_params *ts_params = &testsuite_params; 1666 struct crypto_unittest_params *ut_params = &unittest_params; 1667 unsigned iv_pad_len = 0; 1668 1669 /* Generate Crypto op data structure */ 1670 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 1671 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 1672 TEST_ASSERT_NOT_NULL(ut_params->op, 1673 "Failed to allocate pktmbuf offload"); 1674 1675 /* Set crypto operation data parameters */ 1676 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 1677 1678 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 1679 1680 /* set crypto operation source mbuf */ 1681 sym_op->m_src = ut_params->ibuf; 1682 1683 /* iv */ 1684 if (algo == RTE_CRYPTO_CIPHER_KASUMI_F8) 1685 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8); 1686 else 1687 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16); 1688 1689 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf 1690 , iv_pad_len); 1691 1692 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv"); 1693 1694 memset(sym_op->cipher.iv.data, 0, iv_pad_len); 1695 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); 1696 sym_op->cipher.iv.length = iv_pad_len; 1697 1698 rte_memcpy(sym_op->cipher.iv.data, iv, iv_len); 1699 sym_op->cipher.data.length = cipher_len; 1700 sym_op->cipher.data.offset = cipher_offset; 1701 return 0; 1702 } 1703 1704 static int 1705 create_wireless_algo_cipher_operation_oop(const uint8_t *iv, const uint8_t iv_len, 1706 const unsigned cipher_len, 1707 const unsigned cipher_offset, 1708 enum rte_crypto_cipher_algorithm algo) 1709 { 1710 struct crypto_testsuite_params *ts_params = &testsuite_params; 1711 struct crypto_unittest_params *ut_params = &unittest_params; 1712 unsigned iv_pad_len = 0; 1713 1714 /* Generate Crypto op data structure */ 1715 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 1716 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 1717 TEST_ASSERT_NOT_NULL(ut_params->op, 1718 "Failed to allocate pktmbuf offload"); 1719 1720 /* Set crypto operation data parameters */ 1721 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 1722 1723 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 1724 1725 /* set crypto operation source mbuf */ 1726 sym_op->m_src = ut_params->ibuf; 1727 sym_op->m_dst = ut_params->obuf; 1728 1729 /* iv */ 1730 if (algo == RTE_CRYPTO_CIPHER_KASUMI_F8) 1731 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8); 1732 else 1733 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16); 1734 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(ut_params->ibuf, 1735 iv_pad_len); 1736 1737 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv"); 1738 1739 /* For OOP operation both buffers must have the same size */ 1740 if (ut_params->obuf) 1741 rte_pktmbuf_prepend(ut_params->obuf, iv_pad_len); 1742 1743 memset(sym_op->cipher.iv.data, 0, iv_pad_len); 1744 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); 1745 sym_op->cipher.iv.length = iv_pad_len; 1746 1747 rte_memcpy(sym_op->cipher.iv.data, iv, iv_len); 1748 sym_op->cipher.data.length = cipher_len; 1749 sym_op->cipher.data.offset = cipher_offset; 1750 return 0; 1751 } 1752 1753 static int 1754 create_wireless_algo_cipher_auth_session(uint8_t dev_id, 1755 enum rte_crypto_cipher_operation cipher_op, 1756 enum rte_crypto_auth_operation auth_op, 1757 enum rte_crypto_auth_algorithm auth_algo, 1758 enum rte_crypto_cipher_algorithm cipher_algo, 1759 const uint8_t *key, const uint8_t key_len, 1760 const uint8_t aad_len, const uint8_t auth_len) 1761 1762 { 1763 uint8_t cipher_auth_key[key_len]; 1764 1765 struct crypto_unittest_params *ut_params = &unittest_params; 1766 1767 memcpy(cipher_auth_key, key, key_len); 1768 1769 /* Setup Authentication Parameters */ 1770 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 1771 ut_params->auth_xform.next = NULL; 1772 1773 ut_params->auth_xform.auth.op = auth_op; 1774 ut_params->auth_xform.auth.algo = auth_algo; 1775 ut_params->auth_xform.auth.key.length = key_len; 1776 /* Hash key = cipher key */ 1777 ut_params->auth_xform.auth.key.data = cipher_auth_key; 1778 ut_params->auth_xform.auth.digest_length = auth_len; 1779 ut_params->auth_xform.auth.add_auth_data_length = aad_len; 1780 1781 /* Setup Cipher Parameters */ 1782 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 1783 ut_params->cipher_xform.next = &ut_params->auth_xform; 1784 1785 ut_params->cipher_xform.cipher.algo = cipher_algo; 1786 ut_params->cipher_xform.cipher.op = cipher_op; 1787 ut_params->cipher_xform.cipher.key.data = cipher_auth_key; 1788 ut_params->cipher_xform.cipher.key.length = key_len; 1789 1790 TEST_HEXDUMP(stdout, "key:", key, key_len); 1791 1792 /* Create Crypto session*/ 1793 ut_params->sess = rte_cryptodev_sym_session_create(dev_id, 1794 &ut_params->cipher_xform); 1795 1796 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 1797 return 0; 1798 } 1799 1800 static int 1801 create_wireless_algo_auth_cipher_session(uint8_t dev_id, 1802 enum rte_crypto_cipher_operation cipher_op, 1803 enum rte_crypto_auth_operation auth_op, 1804 enum rte_crypto_auth_algorithm auth_algo, 1805 enum rte_crypto_cipher_algorithm cipher_algo, 1806 const uint8_t *key, const uint8_t key_len, 1807 const uint8_t aad_len, const uint8_t auth_len) 1808 { 1809 uint8_t auth_cipher_key[key_len]; 1810 1811 struct crypto_unittest_params *ut_params = &unittest_params; 1812 1813 memcpy(auth_cipher_key, key, key_len); 1814 1815 /* Setup Authentication Parameters */ 1816 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 1817 ut_params->auth_xform.auth.op = auth_op; 1818 ut_params->auth_xform.next = &ut_params->cipher_xform; 1819 ut_params->auth_xform.auth.algo = auth_algo; 1820 ut_params->auth_xform.auth.key.length = key_len; 1821 ut_params->auth_xform.auth.key.data = auth_cipher_key; 1822 ut_params->auth_xform.auth.digest_length = auth_len; 1823 ut_params->auth_xform.auth.add_auth_data_length = aad_len; 1824 1825 /* Setup Cipher Parameters */ 1826 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 1827 ut_params->cipher_xform.next = NULL; 1828 ut_params->cipher_xform.cipher.algo = cipher_algo; 1829 ut_params->cipher_xform.cipher.op = cipher_op; 1830 ut_params->cipher_xform.cipher.key.data = auth_cipher_key; 1831 ut_params->cipher_xform.cipher.key.length = key_len; 1832 1833 TEST_HEXDUMP(stdout, "key:", key, key_len); 1834 1835 /* Create Crypto session*/ 1836 ut_params->sess = rte_cryptodev_sym_session_create(dev_id, 1837 &ut_params->auth_xform); 1838 1839 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 1840 1841 return 0; 1842 } 1843 1844 static int 1845 create_wireless_algo_hash_operation(const uint8_t *auth_tag, 1846 const unsigned auth_tag_len, 1847 const uint8_t *aad, const unsigned aad_len, 1848 unsigned data_pad_len, 1849 enum rte_crypto_auth_operation op, 1850 enum rte_crypto_auth_algorithm algo, 1851 const unsigned auth_len, const unsigned auth_offset) 1852 { 1853 struct crypto_testsuite_params *ts_params = &testsuite_params; 1854 1855 struct crypto_unittest_params *ut_params = &unittest_params; 1856 1857 unsigned aad_buffer_len; 1858 1859 /* Generate Crypto op data structure */ 1860 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 1861 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 1862 TEST_ASSERT_NOT_NULL(ut_params->op, 1863 "Failed to allocate pktmbuf offload"); 1864 1865 /* Set crypto operation data parameters */ 1866 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 1867 1868 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 1869 1870 /* set crypto operation source mbuf */ 1871 sym_op->m_src = ut_params->ibuf; 1872 1873 /* aad */ 1874 /* 1875 * Always allocate the aad up to the block size. 1876 * The cryptodev API calls out - 1877 * - the array must be big enough to hold the AAD, plus any 1878 * space to round this up to the nearest multiple of the 1879 * block size (8 bytes for KASUMI and 16 bytes for SNOW 3G). 1880 */ 1881 if (algo == RTE_CRYPTO_AUTH_KASUMI_F9) 1882 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 8); 1883 else 1884 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16); 1885 sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend( 1886 ut_params->ibuf, aad_buffer_len); 1887 TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data, 1888 "no room to prepend aad"); 1889 sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys( 1890 ut_params->ibuf); 1891 sym_op->auth.aad.length = aad_len; 1892 1893 memset(sym_op->auth.aad.data, 0, aad_buffer_len); 1894 rte_memcpy(sym_op->auth.aad.data, aad, aad_len); 1895 1896 TEST_HEXDUMP(stdout, "aad:", 1897 sym_op->auth.aad.data, aad_len); 1898 1899 /* digest */ 1900 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( 1901 ut_params->ibuf, auth_tag_len); 1902 1903 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, 1904 "no room to append auth tag"); 1905 ut_params->digest = sym_op->auth.digest.data; 1906 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( 1907 ut_params->ibuf, data_pad_len + aad_len); 1908 sym_op->auth.digest.length = auth_tag_len; 1909 if (op == RTE_CRYPTO_AUTH_OP_GENERATE) 1910 memset(sym_op->auth.digest.data, 0, auth_tag_len); 1911 else 1912 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len); 1913 1914 TEST_HEXDUMP(stdout, "digest:", 1915 sym_op->auth.digest.data, 1916 sym_op->auth.digest.length); 1917 1918 sym_op->auth.data.length = auth_len; 1919 sym_op->auth.data.offset = auth_offset; 1920 1921 return 0; 1922 } 1923 1924 static int 1925 create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag, 1926 const unsigned auth_tag_len, 1927 const uint8_t *aad, const uint8_t aad_len, 1928 unsigned data_pad_len, 1929 enum rte_crypto_auth_operation op, 1930 enum rte_crypto_auth_algorithm auth_algo, 1931 enum rte_crypto_cipher_algorithm cipher_algo, 1932 const uint8_t *iv, const uint8_t iv_len, 1933 const unsigned cipher_len, const unsigned cipher_offset, 1934 const unsigned auth_len, const unsigned auth_offset) 1935 { 1936 struct crypto_testsuite_params *ts_params = &testsuite_params; 1937 struct crypto_unittest_params *ut_params = &unittest_params; 1938 1939 unsigned iv_pad_len = 0; 1940 unsigned aad_buffer_len; 1941 1942 /* Generate Crypto op data structure */ 1943 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 1944 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 1945 TEST_ASSERT_NOT_NULL(ut_params->op, 1946 "Failed to allocate pktmbuf offload"); 1947 /* Set crypto operation data parameters */ 1948 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 1949 1950 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 1951 1952 /* set crypto operation source mbuf */ 1953 sym_op->m_src = ut_params->ibuf; 1954 1955 /* digest */ 1956 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( 1957 ut_params->ibuf, auth_tag_len); 1958 1959 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, 1960 "no room to append auth tag"); 1961 ut_params->digest = sym_op->auth.digest.data; 1962 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( 1963 ut_params->ibuf, data_pad_len); 1964 sym_op->auth.digest.length = auth_tag_len; 1965 if (op == RTE_CRYPTO_AUTH_OP_GENERATE) 1966 memset(sym_op->auth.digest.data, 0, auth_tag_len); 1967 else 1968 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len); 1969 1970 TEST_HEXDUMP(stdout, "digest:", 1971 sym_op->auth.digest.data, 1972 sym_op->auth.digest.length); 1973 1974 /* aad */ 1975 /* 1976 * Always allocate the aad up to the block size. 1977 * The cryptodev API calls out - 1978 * - the array must be big enough to hold the AAD, plus any 1979 * space to round this up to the nearest multiple of the 1980 * block size (8 bytes for KASUMI and 16 bytes for SNOW 3G). 1981 */ 1982 if (auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9) 1983 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 8); 1984 else 1985 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16); 1986 sym_op->auth.aad.data = 1987 (uint8_t *)rte_pktmbuf_prepend( 1988 ut_params->ibuf, aad_buffer_len); 1989 TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data, 1990 "no room to prepend aad"); 1991 sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys( 1992 ut_params->ibuf); 1993 sym_op->auth.aad.length = aad_len; 1994 memset(sym_op->auth.aad.data, 0, aad_buffer_len); 1995 rte_memcpy(sym_op->auth.aad.data, aad, aad_len); 1996 TEST_HEXDUMP(stdout, "aad:", sym_op->auth.aad.data, aad_len); 1997 1998 /* iv */ 1999 if (cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8) 2000 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8); 2001 else 2002 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16); 2003 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend( 2004 ut_params->ibuf, iv_pad_len); 2005 2006 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv"); 2007 memset(sym_op->cipher.iv.data, 0, iv_pad_len); 2008 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); 2009 sym_op->cipher.iv.length = iv_pad_len; 2010 rte_memcpy(sym_op->cipher.iv.data, iv, iv_len); 2011 sym_op->cipher.data.length = cipher_len; 2012 sym_op->cipher.data.offset = cipher_offset + auth_offset; 2013 sym_op->auth.data.length = auth_len; 2014 sym_op->auth.data.offset = auth_offset + cipher_offset; 2015 2016 return 0; 2017 } 2018 2019 static int 2020 create_wireless_algo_auth_cipher_operation(const unsigned auth_tag_len, 2021 const uint8_t *iv, const uint8_t iv_len, 2022 const uint8_t *aad, const uint8_t aad_len, 2023 unsigned data_pad_len, 2024 const unsigned cipher_len, const unsigned cipher_offset, 2025 const unsigned auth_len, const unsigned auth_offset, 2026 enum rte_crypto_auth_algorithm auth_algo, 2027 enum rte_crypto_cipher_algorithm cipher_algo) 2028 { 2029 struct crypto_testsuite_params *ts_params = &testsuite_params; 2030 struct crypto_unittest_params *ut_params = &unittest_params; 2031 2032 unsigned iv_pad_len = 0; 2033 unsigned aad_buffer_len = 0; 2034 2035 /* Generate Crypto op data structure */ 2036 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 2037 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 2038 TEST_ASSERT_NOT_NULL(ut_params->op, 2039 "Failed to allocate pktmbuf offload"); 2040 2041 /* Set crypto operation data parameters */ 2042 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 2043 2044 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 2045 2046 /* set crypto operation source mbuf */ 2047 sym_op->m_src = ut_params->ibuf; 2048 2049 /* digest */ 2050 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( 2051 ut_params->ibuf, auth_tag_len); 2052 2053 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, 2054 "no room to append auth tag"); 2055 2056 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( 2057 ut_params->ibuf, data_pad_len); 2058 sym_op->auth.digest.length = auth_tag_len; 2059 2060 memset(sym_op->auth.digest.data, 0, auth_tag_len); 2061 2062 TEST_HEXDUMP(stdout, "digest:", 2063 sym_op->auth.digest.data, 2064 sym_op->auth.digest.length); 2065 2066 /* aad */ 2067 /* 2068 * Always allocate the aad up to the block size. 2069 * The cryptodev API calls out - 2070 * - the array must be big enough to hold the AAD, plus any 2071 * space to round this up to the nearest multiple of the 2072 * block size (8 bytes for KASUMI 16 bytes). 2073 */ 2074 if (auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9) 2075 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 8); 2076 else 2077 aad_buffer_len = ALIGN_POW2_ROUNDUP(aad_len, 16); 2078 sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend( 2079 ut_params->ibuf, aad_buffer_len); 2080 TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data, 2081 "no room to prepend aad"); 2082 sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys( 2083 ut_params->ibuf); 2084 sym_op->auth.aad.length = aad_len; 2085 memset(sym_op->auth.aad.data, 0, aad_buffer_len); 2086 rte_memcpy(sym_op->auth.aad.data, aad, aad_len); 2087 TEST_HEXDUMP(stdout, "aad:", 2088 sym_op->auth.aad.data, aad_len); 2089 2090 /* iv */ 2091 if (cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8) 2092 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 8); 2093 else 2094 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16); 2095 2096 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend( 2097 ut_params->ibuf, iv_pad_len); 2098 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv"); 2099 2100 memset(sym_op->cipher.iv.data, 0, iv_pad_len); 2101 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); 2102 sym_op->cipher.iv.length = iv_pad_len; 2103 2104 rte_memcpy(sym_op->cipher.iv.data, iv, iv_len); 2105 2106 sym_op->cipher.data.length = cipher_len; 2107 sym_op->cipher.data.offset = auth_offset + cipher_offset; 2108 2109 sym_op->auth.data.length = auth_len; 2110 sym_op->auth.data.offset = auth_offset + cipher_offset; 2111 2112 return 0; 2113 } 2114 2115 static int 2116 test_snow3g_authentication(const struct snow3g_hash_test_data *tdata) 2117 { 2118 struct crypto_testsuite_params *ts_params = &testsuite_params; 2119 struct crypto_unittest_params *ut_params = &unittest_params; 2120 2121 int retval; 2122 unsigned plaintext_pad_len; 2123 unsigned plaintext_len; 2124 uint8_t *plaintext; 2125 2126 /* Create SNOW 3G session */ 2127 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0], 2128 tdata->key.data, tdata->key.len, 2129 tdata->aad.len, tdata->digest.len, 2130 RTE_CRYPTO_AUTH_OP_GENERATE, 2131 RTE_CRYPTO_AUTH_SNOW3G_UIA2); 2132 if (retval < 0) 2133 return retval; 2134 2135 /* alloc mbuf and set payload */ 2136 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 2137 2138 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 2139 rte_pktmbuf_tailroom(ut_params->ibuf)); 2140 2141 plaintext_len = ceil_byte_length(tdata->plaintext.len); 2142 /* Append data which is padded to a multiple of */ 2143 /* the algorithms block size */ 2144 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); 2145 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 2146 plaintext_pad_len); 2147 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 2148 2149 /* Create SNOW 3G operation */ 2150 retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len, 2151 tdata->aad.data, tdata->aad.len, 2152 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE, 2153 RTE_CRYPTO_AUTH_SNOW3G_UIA2, 2154 tdata->validAuthLenInBits.len, 2155 tdata->validAuthOffsetLenInBits.len); 2156 if (retval < 0) 2157 return retval; 2158 2159 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 2160 ut_params->op); 2161 ut_params->obuf = ut_params->op->sym->m_src; 2162 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 2163 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 2164 + plaintext_pad_len + tdata->aad.len; 2165 2166 /* Validate obuf */ 2167 TEST_ASSERT_BUFFERS_ARE_EQUAL( 2168 ut_params->digest, 2169 tdata->digest.data, 2170 DIGEST_BYTE_LENGTH_SNOW3G_UIA2, 2171 "SNOW 3G Generated auth tag not as expected"); 2172 2173 return 0; 2174 } 2175 2176 static int 2177 test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata) 2178 { 2179 struct crypto_testsuite_params *ts_params = &testsuite_params; 2180 struct crypto_unittest_params *ut_params = &unittest_params; 2181 2182 int retval; 2183 unsigned plaintext_pad_len; 2184 unsigned plaintext_len; 2185 uint8_t *plaintext; 2186 2187 /* Create SNOW 3G session */ 2188 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0], 2189 tdata->key.data, tdata->key.len, 2190 tdata->aad.len, tdata->digest.len, 2191 RTE_CRYPTO_AUTH_OP_VERIFY, 2192 RTE_CRYPTO_AUTH_SNOW3G_UIA2); 2193 if (retval < 0) 2194 return retval; 2195 /* alloc mbuf and set payload */ 2196 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 2197 2198 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 2199 rte_pktmbuf_tailroom(ut_params->ibuf)); 2200 2201 plaintext_len = ceil_byte_length(tdata->plaintext.len); 2202 /* Append data which is padded to a multiple of */ 2203 /* the algorithms block size */ 2204 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); 2205 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 2206 plaintext_pad_len); 2207 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 2208 2209 /* Create SNOW 3G operation */ 2210 retval = create_wireless_algo_hash_operation(tdata->digest.data, 2211 tdata->digest.len, 2212 tdata->aad.data, tdata->aad.len, 2213 plaintext_pad_len, 2214 RTE_CRYPTO_AUTH_OP_VERIFY, 2215 RTE_CRYPTO_AUTH_SNOW3G_UIA2, 2216 tdata->validAuthLenInBits.len, 2217 tdata->validAuthOffsetLenInBits.len); 2218 if (retval < 0) 2219 return retval; 2220 2221 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 2222 ut_params->op); 2223 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 2224 ut_params->obuf = ut_params->op->sym->m_src; 2225 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 2226 + plaintext_pad_len + tdata->aad.len; 2227 2228 /* Validate obuf */ 2229 if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS) 2230 return 0; 2231 else 2232 return -1; 2233 2234 return 0; 2235 } 2236 2237 static int 2238 test_kasumi_authentication(const struct kasumi_hash_test_data *tdata) 2239 { 2240 struct crypto_testsuite_params *ts_params = &testsuite_params; 2241 struct crypto_unittest_params *ut_params = &unittest_params; 2242 2243 int retval; 2244 unsigned plaintext_pad_len; 2245 unsigned plaintext_len; 2246 uint8_t *plaintext; 2247 2248 /* Create KASUMI session */ 2249 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0], 2250 tdata->key.data, tdata->key.len, 2251 tdata->aad.len, tdata->digest.len, 2252 RTE_CRYPTO_AUTH_OP_GENERATE, 2253 RTE_CRYPTO_AUTH_KASUMI_F9); 2254 if (retval < 0) 2255 return retval; 2256 2257 /* alloc mbuf and set payload */ 2258 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 2259 2260 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 2261 rte_pktmbuf_tailroom(ut_params->ibuf)); 2262 2263 plaintext_len = ceil_byte_length(tdata->plaintext.len); 2264 /* Append data which is padded to a multiple of */ 2265 /* the algorithms block size */ 2266 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); 2267 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 2268 plaintext_pad_len); 2269 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 2270 2271 /* Create KASUMI operation */ 2272 retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len, 2273 tdata->aad.data, tdata->aad.len, 2274 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE, 2275 RTE_CRYPTO_AUTH_KASUMI_F9, 2276 tdata->validAuthLenInBits.len, 2277 tdata->validAuthOffsetLenInBits.len); 2278 if (retval < 0) 2279 return retval; 2280 2281 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 2282 ut_params->op); 2283 ut_params->obuf = ut_params->op->sym->m_src; 2284 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 2285 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 2286 + plaintext_pad_len + ALIGN_POW2_ROUNDUP(tdata->aad.len, 8); 2287 2288 /* Validate obuf */ 2289 TEST_ASSERT_BUFFERS_ARE_EQUAL( 2290 ut_params->digest, 2291 tdata->digest.data, 2292 DIGEST_BYTE_LENGTH_KASUMI_F9, 2293 "KASUMI Generated auth tag not as expected"); 2294 2295 return 0; 2296 } 2297 2298 static int 2299 test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata) 2300 { 2301 struct crypto_testsuite_params *ts_params = &testsuite_params; 2302 struct crypto_unittest_params *ut_params = &unittest_params; 2303 2304 int retval; 2305 unsigned plaintext_pad_len; 2306 unsigned plaintext_len; 2307 uint8_t *plaintext; 2308 2309 /* Create KASUMI session */ 2310 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0], 2311 tdata->key.data, tdata->key.len, 2312 tdata->aad.len, tdata->digest.len, 2313 RTE_CRYPTO_AUTH_OP_VERIFY, 2314 RTE_CRYPTO_AUTH_KASUMI_F9); 2315 if (retval < 0) 2316 return retval; 2317 /* alloc mbuf and set payload */ 2318 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 2319 2320 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 2321 rte_pktmbuf_tailroom(ut_params->ibuf)); 2322 2323 plaintext_len = ceil_byte_length(tdata->plaintext.len); 2324 /* Append data which is padded to a multiple */ 2325 /* of the algorithms block size */ 2326 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); 2327 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 2328 plaintext_pad_len); 2329 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 2330 2331 /* Create KASUMI operation */ 2332 retval = create_wireless_algo_hash_operation(tdata->digest.data, 2333 tdata->digest.len, 2334 tdata->aad.data, tdata->aad.len, 2335 plaintext_pad_len, 2336 RTE_CRYPTO_AUTH_OP_VERIFY, 2337 RTE_CRYPTO_AUTH_KASUMI_F9, 2338 tdata->validAuthLenInBits.len, 2339 tdata->validAuthOffsetLenInBits.len); 2340 if (retval < 0) 2341 return retval; 2342 2343 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 2344 ut_params->op); 2345 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 2346 ut_params->obuf = ut_params->op->sym->m_src; 2347 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 2348 + plaintext_pad_len + tdata->aad.len; 2349 2350 /* Validate obuf */ 2351 if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS) 2352 return 0; 2353 else 2354 return -1; 2355 2356 return 0; 2357 } 2358 2359 static int 2360 test_snow3g_hash_generate_test_case_1(void) 2361 { 2362 return test_snow3g_authentication(&snow3g_hash_test_case_1); 2363 } 2364 2365 static int 2366 test_snow3g_hash_generate_test_case_2(void) 2367 { 2368 return test_snow3g_authentication(&snow3g_hash_test_case_2); 2369 } 2370 2371 static int 2372 test_snow3g_hash_generate_test_case_3(void) 2373 { 2374 return test_snow3g_authentication(&snow3g_hash_test_case_3); 2375 } 2376 2377 static int 2378 test_snow3g_hash_generate_test_case_4(void) 2379 { 2380 return test_snow3g_authentication(&snow3g_hash_test_case_4); 2381 } 2382 2383 static int 2384 test_snow3g_hash_generate_test_case_5(void) 2385 { 2386 return test_snow3g_authentication(&snow3g_hash_test_case_5); 2387 } 2388 2389 static int 2390 test_snow3g_hash_generate_test_case_6(void) 2391 { 2392 return test_snow3g_authentication(&snow3g_hash_test_case_6); 2393 } 2394 2395 static int 2396 test_snow3g_hash_verify_test_case_1(void) 2397 { 2398 return test_snow3g_authentication_verify(&snow3g_hash_test_case_1); 2399 2400 } 2401 2402 static int 2403 test_snow3g_hash_verify_test_case_2(void) 2404 { 2405 return test_snow3g_authentication_verify(&snow3g_hash_test_case_2); 2406 } 2407 2408 static int 2409 test_snow3g_hash_verify_test_case_3(void) 2410 { 2411 return test_snow3g_authentication_verify(&snow3g_hash_test_case_3); 2412 } 2413 2414 static int 2415 test_snow3g_hash_verify_test_case_4(void) 2416 { 2417 return test_snow3g_authentication_verify(&snow3g_hash_test_case_4); 2418 } 2419 2420 static int 2421 test_snow3g_hash_verify_test_case_5(void) 2422 { 2423 return test_snow3g_authentication_verify(&snow3g_hash_test_case_5); 2424 } 2425 2426 static int 2427 test_snow3g_hash_verify_test_case_6(void) 2428 { 2429 return test_snow3g_authentication_verify(&snow3g_hash_test_case_6); 2430 } 2431 2432 static int 2433 test_kasumi_hash_generate_test_case_1(void) 2434 { 2435 return test_kasumi_authentication(&kasumi_hash_test_case_1); 2436 } 2437 2438 static int 2439 test_kasumi_hash_generate_test_case_2(void) 2440 { 2441 return test_kasumi_authentication(&kasumi_hash_test_case_2); 2442 } 2443 2444 static int 2445 test_kasumi_hash_generate_test_case_3(void) 2446 { 2447 return test_kasumi_authentication(&kasumi_hash_test_case_3); 2448 } 2449 2450 static int 2451 test_kasumi_hash_generate_test_case_4(void) 2452 { 2453 return test_kasumi_authentication(&kasumi_hash_test_case_4); 2454 } 2455 2456 static int 2457 test_kasumi_hash_generate_test_case_5(void) 2458 { 2459 return test_kasumi_authentication(&kasumi_hash_test_case_5); 2460 } 2461 2462 static int 2463 test_kasumi_hash_generate_test_case_6(void) 2464 { 2465 return test_kasumi_authentication(&kasumi_hash_test_case_6); 2466 } 2467 2468 static int 2469 test_kasumi_hash_verify_test_case_1(void) 2470 { 2471 return test_kasumi_authentication_verify(&kasumi_hash_test_case_1); 2472 } 2473 2474 static int 2475 test_kasumi_hash_verify_test_case_2(void) 2476 { 2477 return test_kasumi_authentication_verify(&kasumi_hash_test_case_2); 2478 } 2479 2480 static int 2481 test_kasumi_hash_verify_test_case_3(void) 2482 { 2483 return test_kasumi_authentication_verify(&kasumi_hash_test_case_3); 2484 } 2485 2486 static int 2487 test_kasumi_hash_verify_test_case_4(void) 2488 { 2489 return test_kasumi_authentication_verify(&kasumi_hash_test_case_4); 2490 } 2491 2492 static int 2493 test_kasumi_hash_verify_test_case_5(void) 2494 { 2495 return test_kasumi_authentication_verify(&kasumi_hash_test_case_5); 2496 } 2497 2498 static int 2499 test_kasumi_encryption(const struct kasumi_test_data *tdata) 2500 { 2501 struct crypto_testsuite_params *ts_params = &testsuite_params; 2502 struct crypto_unittest_params *ut_params = &unittest_params; 2503 2504 int retval; 2505 uint8_t *plaintext, *ciphertext; 2506 unsigned plaintext_pad_len; 2507 unsigned plaintext_len; 2508 2509 /* Create KASUMI session */ 2510 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], 2511 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 2512 RTE_CRYPTO_CIPHER_KASUMI_F8, 2513 tdata->key.data, tdata->key.len); 2514 if (retval < 0) 2515 return retval; 2516 2517 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 2518 2519 /* Clear mbuf payload */ 2520 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 2521 rte_pktmbuf_tailroom(ut_params->ibuf)); 2522 2523 plaintext_len = ceil_byte_length(tdata->plaintext.len); 2524 /* Append data which is padded to a multiple */ 2525 /* of the algorithms block size */ 2526 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); 2527 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 2528 plaintext_pad_len); 2529 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 2530 2531 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len); 2532 2533 /* Create KASUMI operation */ 2534 retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len, 2535 tdata->plaintext.len, 2536 tdata->validCipherOffsetLenInBits.len, 2537 RTE_CRYPTO_CIPHER_KASUMI_F8); 2538 if (retval < 0) 2539 return retval; 2540 2541 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 2542 ut_params->op); 2543 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 2544 2545 ut_params->obuf = ut_params->op->sym->m_dst; 2546 if (ut_params->obuf) 2547 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 2548 + tdata->iv.len; 2549 else 2550 ciphertext = plaintext; 2551 2552 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len); 2553 2554 /* Validate obuf */ 2555 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 2556 ciphertext, 2557 tdata->ciphertext.data, 2558 tdata->validCipherLenInBits.len, 2559 "KASUMI Ciphertext data not as expected"); 2560 return 0; 2561 } 2562 2563 static int 2564 test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata) 2565 { 2566 struct crypto_testsuite_params *ts_params = &testsuite_params; 2567 struct crypto_unittest_params *ut_params = &unittest_params; 2568 2569 int retval; 2570 2571 unsigned int plaintext_pad_len; 2572 unsigned int plaintext_len; 2573 2574 uint8_t buffer[10000]; 2575 const uint8_t *ciphertext; 2576 2577 struct rte_cryptodev_info dev_info; 2578 2579 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 2580 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_MBUF_SCATTER_GATHER)) { 2581 printf("Device doesn't support scatter-gather. " 2582 "Test Skipped.\n"); 2583 return 0; 2584 } 2585 2586 /* Create KASUMI session */ 2587 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], 2588 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 2589 RTE_CRYPTO_CIPHER_KASUMI_F8, 2590 tdata->key.data, tdata->key.len); 2591 if (retval < 0) 2592 return retval; 2593 2594 plaintext_len = ceil_byte_length(tdata->plaintext.len); 2595 2596 2597 /* Append data which is padded to a multiple */ 2598 /* of the algorithms block size */ 2599 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); 2600 2601 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool, 2602 plaintext_pad_len, 10, 0); 2603 2604 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data); 2605 2606 /* Create KASUMI operation */ 2607 retval = create_wireless_algo_cipher_operation(tdata->iv.data, 2608 tdata->iv.len, 2609 tdata->plaintext.len, 2610 tdata->validCipherOffsetLenInBits.len, 2611 RTE_CRYPTO_CIPHER_KASUMI_F8); 2612 if (retval < 0) 2613 return retval; 2614 2615 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 2616 ut_params->op); 2617 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 2618 2619 ut_params->obuf = ut_params->op->sym->m_dst; 2620 2621 if (ut_params->obuf) 2622 ciphertext = rte_pktmbuf_read(ut_params->obuf, tdata->iv.len, 2623 plaintext_len, buffer); 2624 else 2625 ciphertext = rte_pktmbuf_read(ut_params->ibuf, tdata->iv.len, 2626 plaintext_len, buffer); 2627 2628 /* Validate obuf */ 2629 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len); 2630 2631 /* Validate obuf */ 2632 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 2633 ciphertext, 2634 tdata->ciphertext.data, 2635 tdata->validCipherLenInBits.len, 2636 "KASUMI Ciphertext data not as expected"); 2637 return 0; 2638 } 2639 2640 static int 2641 test_kasumi_encryption_oop(const struct kasumi_test_data *tdata) 2642 { 2643 struct crypto_testsuite_params *ts_params = &testsuite_params; 2644 struct crypto_unittest_params *ut_params = &unittest_params; 2645 2646 int retval; 2647 uint8_t *plaintext, *ciphertext; 2648 unsigned plaintext_pad_len; 2649 unsigned plaintext_len; 2650 2651 /* Create KASUMI session */ 2652 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], 2653 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 2654 RTE_CRYPTO_CIPHER_KASUMI_F8, 2655 tdata->key.data, tdata->key.len); 2656 if (retval < 0) 2657 return retval; 2658 2659 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 2660 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 2661 2662 /* Clear mbuf payload */ 2663 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 2664 rte_pktmbuf_tailroom(ut_params->ibuf)); 2665 2666 plaintext_len = ceil_byte_length(tdata->plaintext.len); 2667 /* Append data which is padded to a multiple */ 2668 /* of the algorithms block size */ 2669 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); 2670 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 2671 plaintext_pad_len); 2672 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len); 2673 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 2674 2675 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len); 2676 2677 /* Create KASUMI operation */ 2678 retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data, 2679 tdata->iv.len, 2680 tdata->plaintext.len, 2681 tdata->validCipherOffsetLenInBits.len, 2682 RTE_CRYPTO_CIPHER_KASUMI_F8); 2683 if (retval < 0) 2684 return retval; 2685 2686 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 2687 ut_params->op); 2688 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 2689 2690 ut_params->obuf = ut_params->op->sym->m_dst; 2691 if (ut_params->obuf) 2692 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 2693 + tdata->iv.len; 2694 else 2695 ciphertext = plaintext; 2696 2697 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len); 2698 2699 /* Validate obuf */ 2700 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 2701 ciphertext, 2702 tdata->ciphertext.data, 2703 tdata->validCipherLenInBits.len, 2704 "KASUMI Ciphertext data not as expected"); 2705 return 0; 2706 } 2707 2708 static int 2709 test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata) 2710 { 2711 struct crypto_testsuite_params *ts_params = &testsuite_params; 2712 struct crypto_unittest_params *ut_params = &unittest_params; 2713 2714 int retval; 2715 unsigned int plaintext_pad_len; 2716 unsigned int plaintext_len; 2717 2718 const uint8_t *ciphertext; 2719 uint8_t buffer[2048]; 2720 2721 struct rte_cryptodev_info dev_info; 2722 2723 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 2724 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_MBUF_SCATTER_GATHER)) { 2725 printf("Device doesn't support scatter-gather. " 2726 "Test Skipped.\n"); 2727 return 0; 2728 } 2729 2730 /* Create KASUMI session */ 2731 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], 2732 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 2733 RTE_CRYPTO_CIPHER_KASUMI_F8, 2734 tdata->key.data, tdata->key.len); 2735 if (retval < 0) 2736 return retval; 2737 2738 plaintext_len = ceil_byte_length(tdata->plaintext.len); 2739 /* Append data which is padded to a multiple */ 2740 /* of the algorithms block size */ 2741 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); 2742 2743 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool, 2744 plaintext_pad_len, 10, 0); 2745 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool, 2746 plaintext_pad_len, 3, 0); 2747 2748 /* Append data which is padded to a multiple */ 2749 /* of the algorithms block size */ 2750 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data); 2751 2752 /* Create KASUMI operation */ 2753 retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data, 2754 tdata->iv.len, 2755 tdata->plaintext.len, 2756 tdata->validCipherOffsetLenInBits.len, 2757 RTE_CRYPTO_CIPHER_KASUMI_F8); 2758 if (retval < 0) 2759 return retval; 2760 2761 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 2762 ut_params->op); 2763 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 2764 2765 ut_params->obuf = ut_params->op->sym->m_dst; 2766 if (ut_params->obuf) 2767 ciphertext = rte_pktmbuf_read(ut_params->obuf, tdata->iv.len, 2768 plaintext_pad_len, buffer); 2769 else 2770 ciphertext = rte_pktmbuf_read(ut_params->ibuf, tdata->iv.len, 2771 plaintext_pad_len, buffer); 2772 2773 /* Validate obuf */ 2774 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 2775 ciphertext, 2776 tdata->ciphertext.data, 2777 tdata->validCipherLenInBits.len, 2778 "KASUMI Ciphertext data not as expected"); 2779 return 0; 2780 } 2781 2782 2783 static int 2784 test_kasumi_decryption_oop(const struct kasumi_test_data *tdata) 2785 { 2786 struct crypto_testsuite_params *ts_params = &testsuite_params; 2787 struct crypto_unittest_params *ut_params = &unittest_params; 2788 2789 int retval; 2790 uint8_t *ciphertext, *plaintext; 2791 unsigned ciphertext_pad_len; 2792 unsigned ciphertext_len; 2793 2794 /* Create KASUMI session */ 2795 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], 2796 RTE_CRYPTO_CIPHER_OP_DECRYPT, 2797 RTE_CRYPTO_CIPHER_KASUMI_F8, 2798 tdata->key.data, tdata->key.len); 2799 if (retval < 0) 2800 return retval; 2801 2802 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 2803 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 2804 2805 /* Clear mbuf payload */ 2806 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 2807 rte_pktmbuf_tailroom(ut_params->ibuf)); 2808 2809 ciphertext_len = ceil_byte_length(tdata->ciphertext.len); 2810 /* Append data which is padded to a multiple */ 2811 /* of the algorithms block size */ 2812 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8); 2813 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 2814 ciphertext_pad_len); 2815 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len); 2816 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len); 2817 2818 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len); 2819 2820 /* Create KASUMI operation */ 2821 retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data, 2822 tdata->iv.len, 2823 tdata->ciphertext.len, 2824 tdata->validCipherOffsetLenInBits.len, 2825 RTE_CRYPTO_CIPHER_KASUMI_F8); 2826 if (retval < 0) 2827 return retval; 2828 2829 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 2830 ut_params->op); 2831 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 2832 2833 ut_params->obuf = ut_params->op->sym->m_dst; 2834 if (ut_params->obuf) 2835 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 2836 + tdata->iv.len; 2837 else 2838 plaintext = ciphertext; 2839 2840 TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len); 2841 2842 /* Validate obuf */ 2843 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 2844 plaintext, 2845 tdata->plaintext.data, 2846 tdata->validCipherLenInBits.len, 2847 "KASUMI Plaintext data not as expected"); 2848 return 0; 2849 } 2850 2851 static int 2852 test_kasumi_decryption(const struct kasumi_test_data *tdata) 2853 { 2854 struct crypto_testsuite_params *ts_params = &testsuite_params; 2855 struct crypto_unittest_params *ut_params = &unittest_params; 2856 2857 int retval; 2858 uint8_t *ciphertext, *plaintext; 2859 unsigned ciphertext_pad_len; 2860 unsigned ciphertext_len; 2861 2862 /* Create KASUMI session */ 2863 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], 2864 RTE_CRYPTO_CIPHER_OP_DECRYPT, 2865 RTE_CRYPTO_CIPHER_KASUMI_F8, 2866 tdata->key.data, tdata->key.len); 2867 if (retval < 0) 2868 return retval; 2869 2870 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 2871 2872 /* Clear mbuf payload */ 2873 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 2874 rte_pktmbuf_tailroom(ut_params->ibuf)); 2875 2876 ciphertext_len = ceil_byte_length(tdata->ciphertext.len); 2877 /* Append data which is padded to a multiple */ 2878 /* of the algorithms block size */ 2879 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8); 2880 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 2881 ciphertext_pad_len); 2882 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len); 2883 2884 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len); 2885 2886 /* Create KASUMI operation */ 2887 retval = create_wireless_algo_cipher_operation(tdata->iv.data, 2888 tdata->iv.len, 2889 tdata->ciphertext.len, 2890 tdata->validCipherOffsetLenInBits.len, 2891 RTE_CRYPTO_CIPHER_KASUMI_F8); 2892 if (retval < 0) 2893 return retval; 2894 2895 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 2896 ut_params->op); 2897 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 2898 2899 ut_params->obuf = ut_params->op->sym->m_dst; 2900 if (ut_params->obuf) 2901 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 2902 + tdata->iv.len; 2903 else 2904 plaintext = ciphertext; 2905 2906 TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len); 2907 2908 /* Validate obuf */ 2909 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 2910 plaintext, 2911 tdata->plaintext.data, 2912 tdata->validCipherLenInBits.len, 2913 "KASUMI Plaintext data not as expected"); 2914 return 0; 2915 } 2916 2917 static int 2918 test_snow3g_encryption(const struct snow3g_test_data *tdata) 2919 { 2920 struct crypto_testsuite_params *ts_params = &testsuite_params; 2921 struct crypto_unittest_params *ut_params = &unittest_params; 2922 2923 int retval; 2924 uint8_t *plaintext, *ciphertext; 2925 unsigned plaintext_pad_len; 2926 unsigned plaintext_len; 2927 2928 /* Create SNOW 3G session */ 2929 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], 2930 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 2931 RTE_CRYPTO_CIPHER_SNOW3G_UEA2, 2932 tdata->key.data, tdata->key.len); 2933 if (retval < 0) 2934 return retval; 2935 2936 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 2937 2938 /* Clear mbuf payload */ 2939 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 2940 rte_pktmbuf_tailroom(ut_params->ibuf)); 2941 2942 plaintext_len = ceil_byte_length(tdata->plaintext.len); 2943 /* Append data which is padded to a multiple of */ 2944 /* the algorithms block size */ 2945 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); 2946 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 2947 plaintext_pad_len); 2948 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 2949 2950 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len); 2951 2952 /* Create SNOW 3G operation */ 2953 retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len, 2954 tdata->validCipherLenInBits.len, 2955 tdata->validCipherOffsetLenInBits.len, 2956 RTE_CRYPTO_CIPHER_SNOW3G_UEA2); 2957 if (retval < 0) 2958 return retval; 2959 2960 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 2961 ut_params->op); 2962 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 2963 2964 ut_params->obuf = ut_params->op->sym->m_dst; 2965 if (ut_params->obuf) 2966 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 2967 + tdata->iv.len; 2968 else 2969 ciphertext = plaintext; 2970 2971 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len); 2972 2973 /* Validate obuf */ 2974 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 2975 ciphertext, 2976 tdata->ciphertext.data, 2977 tdata->validDataLenInBits.len, 2978 "SNOW 3G Ciphertext data not as expected"); 2979 return 0; 2980 } 2981 2982 2983 static int 2984 test_snow3g_encryption_oop(const struct snow3g_test_data *tdata) 2985 { 2986 struct crypto_testsuite_params *ts_params = &testsuite_params; 2987 struct crypto_unittest_params *ut_params = &unittest_params; 2988 uint8_t *plaintext, *ciphertext; 2989 2990 int retval; 2991 unsigned plaintext_pad_len; 2992 unsigned plaintext_len; 2993 2994 /* Create SNOW 3G session */ 2995 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], 2996 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 2997 RTE_CRYPTO_CIPHER_SNOW3G_UEA2, 2998 tdata->key.data, tdata->key.len); 2999 if (retval < 0) 3000 return retval; 3001 3002 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 3003 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 3004 3005 TEST_ASSERT_NOT_NULL(ut_params->ibuf, 3006 "Failed to allocate input buffer in mempool"); 3007 TEST_ASSERT_NOT_NULL(ut_params->obuf, 3008 "Failed to allocate output buffer in mempool"); 3009 3010 /* Clear mbuf payload */ 3011 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 3012 rte_pktmbuf_tailroom(ut_params->ibuf)); 3013 3014 plaintext_len = ceil_byte_length(tdata->plaintext.len); 3015 /* Append data which is padded to a multiple of */ 3016 /* the algorithms block size */ 3017 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); 3018 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 3019 plaintext_pad_len); 3020 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len); 3021 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 3022 3023 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len); 3024 3025 /* Create SNOW 3G operation */ 3026 retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data, 3027 tdata->iv.len, 3028 tdata->validCipherLenInBits.len, 3029 tdata->validCipherOffsetLenInBits.len, 3030 RTE_CRYPTO_CIPHER_SNOW3G_UEA2); 3031 if (retval < 0) 3032 return retval; 3033 3034 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 3035 ut_params->op); 3036 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 3037 3038 ut_params->obuf = ut_params->op->sym->m_dst; 3039 if (ut_params->obuf) 3040 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 3041 + tdata->iv.len; 3042 else 3043 ciphertext = plaintext; 3044 3045 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len); 3046 3047 /* Validate obuf */ 3048 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 3049 ciphertext, 3050 tdata->ciphertext.data, 3051 tdata->validDataLenInBits.len, 3052 "SNOW 3G Ciphertext data not as expected"); 3053 return 0; 3054 } 3055 3056 static int 3057 test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata) 3058 { 3059 struct crypto_testsuite_params *ts_params = &testsuite_params; 3060 struct crypto_unittest_params *ut_params = &unittest_params; 3061 3062 int retval; 3063 unsigned int plaintext_pad_len; 3064 unsigned int plaintext_len; 3065 uint8_t buffer[10000]; 3066 const uint8_t *ciphertext; 3067 3068 struct rte_cryptodev_info dev_info; 3069 3070 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 3071 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_MBUF_SCATTER_GATHER)) { 3072 printf("Device doesn't support scatter-gather. " 3073 "Test Skipped.\n"); 3074 return 0; 3075 } 3076 3077 /* Create SNOW 3G session */ 3078 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], 3079 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 3080 RTE_CRYPTO_CIPHER_SNOW3G_UEA2, 3081 tdata->key.data, tdata->key.len); 3082 if (retval < 0) 3083 return retval; 3084 3085 plaintext_len = ceil_byte_length(tdata->plaintext.len); 3086 /* Append data which is padded to a multiple of */ 3087 /* the algorithms block size */ 3088 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); 3089 3090 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool, 3091 plaintext_pad_len, 10, 0); 3092 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool, 3093 plaintext_pad_len, 3, 0); 3094 3095 TEST_ASSERT_NOT_NULL(ut_params->ibuf, 3096 "Failed to allocate input buffer in mempool"); 3097 TEST_ASSERT_NOT_NULL(ut_params->obuf, 3098 "Failed to allocate output buffer in mempool"); 3099 3100 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data); 3101 3102 /* Create SNOW 3G operation */ 3103 retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data, 3104 tdata->iv.len, 3105 tdata->validCipherLenInBits.len, 3106 tdata->validCipherOffsetLenInBits.len, 3107 RTE_CRYPTO_CIPHER_SNOW3G_UEA2); 3108 if (retval < 0) 3109 return retval; 3110 3111 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 3112 ut_params->op); 3113 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 3114 3115 ut_params->obuf = ut_params->op->sym->m_dst; 3116 if (ut_params->obuf) 3117 ciphertext = rte_pktmbuf_read(ut_params->obuf, tdata->iv.len, 3118 plaintext_len, buffer); 3119 else 3120 ciphertext = rte_pktmbuf_read(ut_params->ibuf, tdata->iv.len, 3121 plaintext_len, buffer); 3122 3123 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len); 3124 3125 /* Validate obuf */ 3126 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 3127 ciphertext, 3128 tdata->ciphertext.data, 3129 tdata->validDataLenInBits.len, 3130 "SNOW 3G Ciphertext data not as expected"); 3131 3132 return 0; 3133 } 3134 3135 /* Shift right a buffer by "offset" bits, "offset" < 8 */ 3136 static void 3137 buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset) 3138 { 3139 uint8_t curr_byte, prev_byte; 3140 uint32_t length_in_bytes = ceil_byte_length(length + offset); 3141 uint8_t lower_byte_mask = (1 << offset) - 1; 3142 unsigned i; 3143 3144 prev_byte = buffer[0]; 3145 buffer[0] >>= offset; 3146 3147 for (i = 1; i < length_in_bytes; i++) { 3148 curr_byte = buffer[i]; 3149 buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) | 3150 (curr_byte >> offset); 3151 prev_byte = curr_byte; 3152 } 3153 } 3154 3155 static int 3156 test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata) 3157 { 3158 struct crypto_testsuite_params *ts_params = &testsuite_params; 3159 struct crypto_unittest_params *ut_params = &unittest_params; 3160 uint8_t *plaintext, *ciphertext; 3161 int retval; 3162 uint32_t plaintext_len; 3163 uint32_t plaintext_pad_len; 3164 uint8_t extra_offset = 4; 3165 uint8_t *expected_ciphertext_shifted; 3166 3167 /* Create SNOW 3G session */ 3168 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], 3169 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 3170 RTE_CRYPTO_CIPHER_SNOW3G_UEA2, 3171 tdata->key.data, tdata->key.len); 3172 if (retval < 0) 3173 return retval; 3174 3175 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 3176 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 3177 3178 TEST_ASSERT_NOT_NULL(ut_params->ibuf, 3179 "Failed to allocate input buffer in mempool"); 3180 TEST_ASSERT_NOT_NULL(ut_params->obuf, 3181 "Failed to allocate output buffer in mempool"); 3182 3183 /* Clear mbuf payload */ 3184 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 3185 rte_pktmbuf_tailroom(ut_params->ibuf)); 3186 3187 plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset); 3188 /* 3189 * Append data which is padded to a 3190 * multiple of the algorithms block size 3191 */ 3192 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); 3193 3194 plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf, 3195 plaintext_pad_len); 3196 3197 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len); 3198 3199 memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3)); 3200 buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset); 3201 3202 #ifdef RTE_APP_TEST_DEBUG 3203 rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len); 3204 #endif 3205 /* Create SNOW 3G operation */ 3206 retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data, 3207 tdata->iv.len, 3208 tdata->validCipherLenInBits.len, 3209 tdata->validCipherOffsetLenInBits.len + 3210 extra_offset, 3211 RTE_CRYPTO_CIPHER_SNOW3G_UEA2); 3212 if (retval < 0) 3213 return retval; 3214 3215 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 3216 ut_params->op); 3217 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 3218 3219 ut_params->obuf = ut_params->op->sym->m_dst; 3220 if (ut_params->obuf) 3221 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 3222 + tdata->iv.len; 3223 else 3224 ciphertext = plaintext; 3225 3226 #ifdef RTE_APP_TEST_DEBUG 3227 rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len); 3228 #endif 3229 3230 expected_ciphertext_shifted = rte_malloc(NULL, 3231 ceil_byte_length(plaintext_len + extra_offset), 0); 3232 3233 TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted, 3234 "failed to reserve memory for ciphertext shifted\n"); 3235 3236 memcpy(expected_ciphertext_shifted, tdata->ciphertext.data, 3237 ceil_byte_length(tdata->ciphertext.len)); 3238 buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len, 3239 extra_offset); 3240 /* Validate obuf */ 3241 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET( 3242 ciphertext, 3243 expected_ciphertext_shifted, 3244 tdata->validDataLenInBits.len, 3245 extra_offset, 3246 "SNOW 3G Ciphertext data not as expected"); 3247 return 0; 3248 } 3249 3250 static int test_snow3g_decryption(const struct snow3g_test_data *tdata) 3251 { 3252 struct crypto_testsuite_params *ts_params = &testsuite_params; 3253 struct crypto_unittest_params *ut_params = &unittest_params; 3254 3255 int retval; 3256 3257 uint8_t *plaintext, *ciphertext; 3258 unsigned ciphertext_pad_len; 3259 unsigned ciphertext_len; 3260 3261 /* Create SNOW 3G session */ 3262 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], 3263 RTE_CRYPTO_CIPHER_OP_DECRYPT, 3264 RTE_CRYPTO_CIPHER_SNOW3G_UEA2, 3265 tdata->key.data, tdata->key.len); 3266 if (retval < 0) 3267 return retval; 3268 3269 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 3270 3271 /* Clear mbuf payload */ 3272 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 3273 rte_pktmbuf_tailroom(ut_params->ibuf)); 3274 3275 ciphertext_len = ceil_byte_length(tdata->ciphertext.len); 3276 /* Append data which is padded to a multiple of */ 3277 /* the algorithms block size */ 3278 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16); 3279 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 3280 ciphertext_pad_len); 3281 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len); 3282 3283 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len); 3284 3285 /* Create SNOW 3G operation */ 3286 retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len, 3287 tdata->validCipherLenInBits.len, 3288 tdata->validCipherOffsetLenInBits.len, 3289 RTE_CRYPTO_CIPHER_SNOW3G_UEA2); 3290 if (retval < 0) 3291 return retval; 3292 3293 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 3294 ut_params->op); 3295 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 3296 ut_params->obuf = ut_params->op->sym->m_dst; 3297 if (ut_params->obuf) 3298 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 3299 + tdata->iv.len; 3300 else 3301 plaintext = ciphertext; 3302 3303 TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len); 3304 3305 /* Validate obuf */ 3306 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext, 3307 tdata->plaintext.data, 3308 tdata->validDataLenInBits.len, 3309 "SNOW 3G Plaintext data not as expected"); 3310 return 0; 3311 } 3312 3313 static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata) 3314 { 3315 struct crypto_testsuite_params *ts_params = &testsuite_params; 3316 struct crypto_unittest_params *ut_params = &unittest_params; 3317 3318 int retval; 3319 3320 uint8_t *plaintext, *ciphertext; 3321 unsigned ciphertext_pad_len; 3322 unsigned ciphertext_len; 3323 3324 /* Create SNOW 3G session */ 3325 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], 3326 RTE_CRYPTO_CIPHER_OP_DECRYPT, 3327 RTE_CRYPTO_CIPHER_SNOW3G_UEA2, 3328 tdata->key.data, tdata->key.len); 3329 if (retval < 0) 3330 return retval; 3331 3332 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 3333 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 3334 3335 TEST_ASSERT_NOT_NULL(ut_params->ibuf, 3336 "Failed to allocate input buffer"); 3337 TEST_ASSERT_NOT_NULL(ut_params->obuf, 3338 "Failed to allocate output buffer"); 3339 3340 /* Clear mbuf payload */ 3341 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 3342 rte_pktmbuf_tailroom(ut_params->ibuf)); 3343 3344 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0, 3345 rte_pktmbuf_tailroom(ut_params->obuf)); 3346 3347 ciphertext_len = ceil_byte_length(tdata->ciphertext.len); 3348 /* Append data which is padded to a multiple of */ 3349 /* the algorithms block size */ 3350 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16); 3351 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 3352 ciphertext_pad_len); 3353 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len); 3354 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len); 3355 3356 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len); 3357 3358 /* Create SNOW 3G operation */ 3359 retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data, 3360 tdata->iv.len, 3361 tdata->validCipherLenInBits.len, 3362 tdata->validCipherOffsetLenInBits.len, 3363 RTE_CRYPTO_CIPHER_SNOW3G_UEA2); 3364 if (retval < 0) 3365 return retval; 3366 3367 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 3368 ut_params->op); 3369 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 3370 ut_params->obuf = ut_params->op->sym->m_dst; 3371 if (ut_params->obuf) 3372 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 3373 + tdata->iv.len; 3374 else 3375 plaintext = ciphertext; 3376 3377 TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len); 3378 3379 /* Validate obuf */ 3380 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext, 3381 tdata->plaintext.data, 3382 tdata->validDataLenInBits.len, 3383 "SNOW 3G Plaintext data not as expected"); 3384 return 0; 3385 } 3386 3387 static int 3388 test_snow3g_cipher_auth(const struct snow3g_test_data *tdata) 3389 { 3390 struct crypto_testsuite_params *ts_params = &testsuite_params; 3391 struct crypto_unittest_params *ut_params = &unittest_params; 3392 3393 int retval; 3394 3395 uint8_t *plaintext, *ciphertext; 3396 unsigned plaintext_pad_len; 3397 unsigned plaintext_len; 3398 3399 /* Create SNOW 3G session */ 3400 retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0], 3401 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 3402 RTE_CRYPTO_AUTH_OP_GENERATE, 3403 RTE_CRYPTO_AUTH_SNOW3G_UIA2, 3404 RTE_CRYPTO_CIPHER_SNOW3G_UEA2, 3405 tdata->key.data, tdata->key.len, 3406 tdata->aad.len, tdata->digest.len); 3407 if (retval < 0) 3408 return retval; 3409 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 3410 3411 /* clear mbuf payload */ 3412 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 3413 rte_pktmbuf_tailroom(ut_params->ibuf)); 3414 3415 plaintext_len = ceil_byte_length(tdata->plaintext.len); 3416 /* Append data which is padded to a multiple of */ 3417 /* the algorithms block size */ 3418 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); 3419 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 3420 plaintext_pad_len); 3421 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 3422 3423 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len); 3424 3425 /* Create SNOW 3G operation */ 3426 retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data, 3427 tdata->digest.len, tdata->aad.data, 3428 tdata->aad.len, /*tdata->plaintext.len,*/ 3429 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE, 3430 RTE_CRYPTO_AUTH_SNOW3G_UIA2, 3431 RTE_CRYPTO_CIPHER_SNOW3G_UEA2, 3432 tdata->iv.data, tdata->iv.len, 3433 tdata->validCipherLenInBits.len, 3434 tdata->validCipherOffsetLenInBits.len, 3435 tdata->validAuthLenInBits.len, 3436 tdata->validAuthOffsetLenInBits.len 3437 ); 3438 if (retval < 0) 3439 return retval; 3440 3441 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 3442 ut_params->op); 3443 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 3444 ut_params->obuf = ut_params->op->sym->m_src; 3445 if (ut_params->obuf) 3446 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 3447 + tdata->iv.len + tdata->aad.len; 3448 else 3449 ciphertext = plaintext; 3450 3451 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len); 3452 /* Validate obuf */ 3453 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 3454 ciphertext, 3455 tdata->ciphertext.data, 3456 tdata->validDataLenInBits.len, 3457 "SNOW 3G Ciphertext data not as expected"); 3458 3459 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 3460 + plaintext_pad_len + tdata->aad.len + tdata->iv.len; 3461 3462 /* Validate obuf */ 3463 TEST_ASSERT_BUFFERS_ARE_EQUAL( 3464 ut_params->digest, 3465 tdata->digest.data, 3466 DIGEST_BYTE_LENGTH_SNOW3G_UIA2, 3467 "SNOW 3G Generated auth tag not as expected"); 3468 return 0; 3469 } 3470 static int 3471 test_snow3g_auth_cipher(const struct snow3g_test_data *tdata) 3472 { 3473 struct crypto_testsuite_params *ts_params = &testsuite_params; 3474 struct crypto_unittest_params *ut_params = &unittest_params; 3475 3476 int retval; 3477 3478 uint8_t *plaintext, *ciphertext; 3479 unsigned plaintext_pad_len; 3480 unsigned plaintext_len; 3481 3482 /* Create SNOW 3G session */ 3483 retval = create_wireless_algo_auth_cipher_session(ts_params->valid_devs[0], 3484 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 3485 RTE_CRYPTO_AUTH_OP_GENERATE, 3486 RTE_CRYPTO_AUTH_SNOW3G_UIA2, 3487 RTE_CRYPTO_CIPHER_SNOW3G_UEA2, 3488 tdata->key.data, tdata->key.len, 3489 tdata->aad.len, tdata->digest.len); 3490 if (retval < 0) 3491 return retval; 3492 3493 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 3494 3495 /* clear mbuf payload */ 3496 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 3497 rte_pktmbuf_tailroom(ut_params->ibuf)); 3498 3499 plaintext_len = ceil_byte_length(tdata->plaintext.len); 3500 /* Append data which is padded to a multiple of */ 3501 /* the algorithms block size */ 3502 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); 3503 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 3504 plaintext_pad_len); 3505 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 3506 3507 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len); 3508 3509 /* Create SNOW 3G operation */ 3510 retval = create_wireless_algo_auth_cipher_operation( 3511 tdata->digest.len, 3512 tdata->iv.data, tdata->iv.len, 3513 tdata->aad.data, tdata->aad.len, 3514 plaintext_pad_len, 3515 tdata->validCipherLenInBits.len, 3516 tdata->validCipherOffsetLenInBits.len, 3517 tdata->validAuthLenInBits.len, 3518 tdata->validAuthOffsetLenInBits.len, 3519 RTE_CRYPTO_AUTH_SNOW3G_UIA2, 3520 RTE_CRYPTO_CIPHER_SNOW3G_UEA2 3521 ); 3522 3523 if (retval < 0) 3524 return retval; 3525 3526 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 3527 ut_params->op); 3528 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 3529 ut_params->obuf = ut_params->op->sym->m_src; 3530 if (ut_params->obuf) 3531 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 3532 + tdata->aad.len + tdata->iv.len; 3533 else 3534 ciphertext = plaintext; 3535 3536 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 3537 + plaintext_pad_len + tdata->aad.len + tdata->iv.len; 3538 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len); 3539 3540 /* Validate obuf */ 3541 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 3542 ciphertext, 3543 tdata->ciphertext.data, 3544 tdata->validDataLenInBits.len, 3545 "SNOW 3G Ciphertext data not as expected"); 3546 3547 /* Validate obuf */ 3548 TEST_ASSERT_BUFFERS_ARE_EQUAL( 3549 ut_params->digest, 3550 tdata->digest.data, 3551 DIGEST_BYTE_LENGTH_SNOW3G_UIA2, 3552 "SNOW 3G Generated auth tag not as expected"); 3553 return 0; 3554 } 3555 3556 static int 3557 test_kasumi_auth_cipher(const struct kasumi_test_data *tdata) 3558 { 3559 struct crypto_testsuite_params *ts_params = &testsuite_params; 3560 struct crypto_unittest_params *ut_params = &unittest_params; 3561 3562 int retval; 3563 3564 uint8_t *plaintext, *ciphertext; 3565 unsigned plaintext_pad_len; 3566 unsigned plaintext_len; 3567 3568 /* Create KASUMI session */ 3569 retval = create_wireless_algo_auth_cipher_session( 3570 ts_params->valid_devs[0], 3571 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 3572 RTE_CRYPTO_AUTH_OP_GENERATE, 3573 RTE_CRYPTO_AUTH_KASUMI_F9, 3574 RTE_CRYPTO_CIPHER_KASUMI_F8, 3575 tdata->key.data, tdata->key.len, 3576 tdata->aad.len, tdata->digest.len); 3577 if (retval < 0) 3578 return retval; 3579 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 3580 3581 /* clear mbuf payload */ 3582 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 3583 rte_pktmbuf_tailroom(ut_params->ibuf)); 3584 3585 plaintext_len = ceil_byte_length(tdata->plaintext.len); 3586 /* Append data which is padded to a multiple of */ 3587 /* the algorithms block size */ 3588 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); 3589 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 3590 plaintext_pad_len); 3591 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 3592 3593 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len); 3594 3595 /* Create KASUMI operation */ 3596 retval = create_wireless_algo_auth_cipher_operation(tdata->digest.len, 3597 tdata->iv.data, tdata->iv.len, 3598 tdata->aad.data, tdata->aad.len, 3599 plaintext_pad_len, 3600 tdata->validCipherLenInBits.len, 3601 tdata->validCipherOffsetLenInBits.len, 3602 tdata->validAuthLenInBits.len, 3603 tdata->validAuthOffsetLenInBits.len, 3604 RTE_CRYPTO_AUTH_KASUMI_F9, 3605 RTE_CRYPTO_CIPHER_KASUMI_F8 3606 ); 3607 3608 if (retval < 0) 3609 return retval; 3610 3611 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 3612 ut_params->op); 3613 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 3614 ut_params->obuf = ut_params->op->sym->m_src; 3615 if (ut_params->obuf) 3616 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 3617 + tdata->iv.len + tdata->aad.len; 3618 else 3619 ciphertext = plaintext; 3620 3621 /* Validate obuf */ 3622 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 3623 ciphertext, 3624 tdata->ciphertext.data, 3625 tdata->validCipherLenInBits.len, 3626 "KASUMI Ciphertext data not as expected"); 3627 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 3628 + plaintext_pad_len + tdata->aad.len + tdata->iv.len; 3629 3630 /* Validate obuf */ 3631 TEST_ASSERT_BUFFERS_ARE_EQUAL( 3632 ut_params->digest, 3633 tdata->digest.data, 3634 DIGEST_BYTE_LENGTH_KASUMI_F9, 3635 "KASUMI Generated auth tag not as expected"); 3636 return 0; 3637 } 3638 3639 static int 3640 test_kasumi_cipher_auth(const struct kasumi_test_data *tdata) 3641 { 3642 struct crypto_testsuite_params *ts_params = &testsuite_params; 3643 struct crypto_unittest_params *ut_params = &unittest_params; 3644 3645 int retval; 3646 3647 uint8_t *plaintext, *ciphertext; 3648 unsigned plaintext_pad_len; 3649 unsigned plaintext_len; 3650 3651 /* Create KASUMI session */ 3652 retval = create_wireless_algo_cipher_auth_session( 3653 ts_params->valid_devs[0], 3654 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 3655 RTE_CRYPTO_AUTH_OP_GENERATE, 3656 RTE_CRYPTO_AUTH_KASUMI_F9, 3657 RTE_CRYPTO_CIPHER_KASUMI_F8, 3658 tdata->key.data, tdata->key.len, 3659 tdata->aad.len, tdata->digest.len); 3660 if (retval < 0) 3661 return retval; 3662 3663 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 3664 3665 /* clear mbuf payload */ 3666 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 3667 rte_pktmbuf_tailroom(ut_params->ibuf)); 3668 3669 plaintext_len = ceil_byte_length(tdata->plaintext.len); 3670 /* Append data which is padded to a multiple of */ 3671 /* the algorithms block size */ 3672 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); 3673 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 3674 plaintext_pad_len); 3675 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 3676 3677 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len); 3678 3679 /* Create KASUMI operation */ 3680 retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data, 3681 tdata->digest.len, tdata->aad.data, 3682 tdata->aad.len, 3683 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE, 3684 RTE_CRYPTO_AUTH_KASUMI_F9, 3685 RTE_CRYPTO_CIPHER_KASUMI_F8, 3686 tdata->iv.data, tdata->iv.len, 3687 tdata->validCipherLenInBits.len, 3688 tdata->validCipherOffsetLenInBits.len, 3689 tdata->validAuthLenInBits.len, 3690 tdata->validAuthOffsetLenInBits.len 3691 ); 3692 if (retval < 0) 3693 return retval; 3694 3695 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 3696 ut_params->op); 3697 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 3698 ut_params->obuf = ut_params->op->sym->m_src; 3699 if (ut_params->obuf) 3700 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 3701 + tdata->aad.len + tdata->iv.len; 3702 else 3703 ciphertext = plaintext; 3704 3705 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 3706 + plaintext_pad_len + tdata->aad.len + tdata->iv.len; 3707 3708 /* Validate obuf */ 3709 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 3710 ciphertext, 3711 tdata->ciphertext.data, 3712 tdata->validCipherLenInBits.len, 3713 "KASUMI Ciphertext data not as expected"); 3714 3715 /* Validate obuf */ 3716 TEST_ASSERT_BUFFERS_ARE_EQUAL( 3717 ut_params->digest, 3718 tdata->digest.data, 3719 DIGEST_BYTE_LENGTH_SNOW3G_UIA2, 3720 "KASUMI Generated auth tag not as expected"); 3721 return 0; 3722 } 3723 3724 static int 3725 test_zuc_encryption(const struct zuc_test_data *tdata) 3726 { 3727 struct crypto_testsuite_params *ts_params = &testsuite_params; 3728 struct crypto_unittest_params *ut_params = &unittest_params; 3729 3730 int retval; 3731 uint8_t *plaintext, *ciphertext; 3732 unsigned plaintext_pad_len; 3733 unsigned plaintext_len; 3734 3735 /* Create ZUC session */ 3736 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], 3737 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 3738 RTE_CRYPTO_CIPHER_ZUC_EEA3, 3739 tdata->key.data, tdata->key.len); 3740 if (retval < 0) 3741 return retval; 3742 3743 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 3744 3745 /* Clear mbuf payload */ 3746 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 3747 rte_pktmbuf_tailroom(ut_params->ibuf)); 3748 3749 plaintext_len = ceil_byte_length(tdata->plaintext.len); 3750 /* Append data which is padded to a multiple */ 3751 /* of the algorithms block size */ 3752 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); 3753 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 3754 plaintext_pad_len); 3755 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 3756 3757 TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len); 3758 3759 /* Create ZUC operation */ 3760 retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len, 3761 tdata->plaintext.len, 3762 tdata->validCipherOffsetLenInBits.len, 3763 RTE_CRYPTO_CIPHER_ZUC_EEA3); 3764 if (retval < 0) 3765 return retval; 3766 3767 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 3768 ut_params->op); 3769 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 3770 3771 ut_params->obuf = ut_params->op->sym->m_dst; 3772 if (ut_params->obuf) 3773 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 3774 + tdata->iv.len; 3775 else 3776 ciphertext = plaintext; 3777 3778 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len); 3779 3780 /* Validate obuf */ 3781 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 3782 ciphertext, 3783 tdata->ciphertext.data, 3784 tdata->validCipherLenInBits.len, 3785 "ZUC Ciphertext data not as expected"); 3786 return 0; 3787 } 3788 3789 static int 3790 test_zuc_encryption_sgl(const struct zuc_test_data *tdata) 3791 { 3792 struct crypto_testsuite_params *ts_params = &testsuite_params; 3793 struct crypto_unittest_params *ut_params = &unittest_params; 3794 3795 int retval; 3796 3797 unsigned int plaintext_pad_len; 3798 unsigned int plaintext_len; 3799 const uint8_t *ciphertext; 3800 uint8_t ciphertext_buffer[2048]; 3801 struct rte_cryptodev_info dev_info; 3802 3803 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 3804 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_MBUF_SCATTER_GATHER)) { 3805 printf("Device doesn't support scatter-gather. " 3806 "Test Skipped.\n"); 3807 return 0; 3808 } 3809 3810 plaintext_len = ceil_byte_length(tdata->plaintext.len); 3811 3812 /* Append data which is padded to a multiple */ 3813 /* of the algorithms block size */ 3814 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); 3815 3816 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool, 3817 plaintext_pad_len, 10, 0); 3818 3819 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, 3820 tdata->plaintext.data); 3821 3822 /* Create ZUC session */ 3823 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], 3824 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 3825 RTE_CRYPTO_CIPHER_ZUC_EEA3, 3826 tdata->key.data, tdata->key.len); 3827 if (retval < 0) 3828 return retval; 3829 3830 /* Clear mbuf payload */ 3831 3832 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data); 3833 3834 /* Create ZUC operation */ 3835 retval = create_wireless_algo_cipher_operation(tdata->iv.data, 3836 tdata->iv.len, tdata->plaintext.len, 3837 tdata->validCipherOffsetLenInBits.len, 3838 RTE_CRYPTO_CIPHER_ZUC_EEA3); 3839 if (retval < 0) 3840 return retval; 3841 3842 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 3843 ut_params->op); 3844 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 3845 3846 ut_params->obuf = ut_params->op->sym->m_dst; 3847 if (ut_params->obuf) 3848 ciphertext = rte_pktmbuf_read(ut_params->obuf, 3849 tdata->iv.len, plaintext_len, ciphertext_buffer); 3850 else 3851 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 3852 tdata->iv.len, plaintext_len, ciphertext_buffer); 3853 3854 /* Validate obuf */ 3855 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len); 3856 3857 /* Validate obuf */ 3858 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 3859 ciphertext, 3860 tdata->ciphertext.data, 3861 tdata->validCipherLenInBits.len, 3862 "ZUC Ciphertext data not as expected"); 3863 3864 return 0; 3865 } 3866 3867 static int 3868 test_zuc_authentication(const struct zuc_hash_test_data *tdata) 3869 { 3870 struct crypto_testsuite_params *ts_params = &testsuite_params; 3871 struct crypto_unittest_params *ut_params = &unittest_params; 3872 3873 int retval; 3874 unsigned plaintext_pad_len; 3875 unsigned plaintext_len; 3876 uint8_t *plaintext; 3877 3878 /* Create ZUC session */ 3879 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0], 3880 tdata->key.data, tdata->key.len, 3881 tdata->aad.len, tdata->digest.len, 3882 RTE_CRYPTO_AUTH_OP_GENERATE, 3883 RTE_CRYPTO_AUTH_ZUC_EIA3); 3884 if (retval < 0) 3885 return retval; 3886 3887 /* alloc mbuf and set payload */ 3888 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 3889 3890 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 3891 rte_pktmbuf_tailroom(ut_params->ibuf)); 3892 3893 plaintext_len = ceil_byte_length(tdata->plaintext.len); 3894 /* Append data which is padded to a multiple of */ 3895 /* the algorithms block size */ 3896 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); 3897 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 3898 plaintext_pad_len); 3899 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 3900 3901 /* Create ZUC operation */ 3902 retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len, 3903 tdata->aad.data, tdata->aad.len, 3904 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE, 3905 RTE_CRYPTO_AUTH_ZUC_EIA3, 3906 tdata->validAuthLenInBits.len, 3907 tdata->validAuthOffsetLenInBits.len); 3908 if (retval < 0) 3909 return retval; 3910 3911 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 3912 ut_params->op); 3913 ut_params->obuf = ut_params->op->sym->m_src; 3914 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 3915 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 3916 + plaintext_pad_len + ALIGN_POW2_ROUNDUP(tdata->aad.len, 8); 3917 3918 /* Validate obuf */ 3919 TEST_ASSERT_BUFFERS_ARE_EQUAL( 3920 ut_params->digest, 3921 tdata->digest.data, 3922 DIGEST_BYTE_LENGTH_KASUMI_F9, 3923 "ZUC Generated auth tag not as expected"); 3924 3925 return 0; 3926 } 3927 3928 static int 3929 test_kasumi_encryption_test_case_1(void) 3930 { 3931 return test_kasumi_encryption(&kasumi_test_case_1); 3932 } 3933 3934 static int 3935 test_kasumi_encryption_test_case_1_sgl(void) 3936 { 3937 return test_kasumi_encryption_sgl(&kasumi_test_case_1); 3938 } 3939 3940 static int 3941 test_kasumi_encryption_test_case_1_oop(void) 3942 { 3943 return test_kasumi_encryption_oop(&kasumi_test_case_1); 3944 } 3945 3946 static int 3947 test_kasumi_encryption_test_case_1_oop_sgl(void) 3948 { 3949 return test_kasumi_encryption_oop_sgl(&kasumi_test_case_1); 3950 } 3951 3952 static int 3953 test_kasumi_encryption_test_case_2(void) 3954 { 3955 return test_kasumi_encryption(&kasumi_test_case_2); 3956 } 3957 3958 static int 3959 test_kasumi_encryption_test_case_3(void) 3960 { 3961 return test_kasumi_encryption(&kasumi_test_case_3); 3962 } 3963 3964 static int 3965 test_kasumi_encryption_test_case_4(void) 3966 { 3967 return test_kasumi_encryption(&kasumi_test_case_4); 3968 } 3969 3970 static int 3971 test_kasumi_encryption_test_case_5(void) 3972 { 3973 return test_kasumi_encryption(&kasumi_test_case_5); 3974 } 3975 3976 static int 3977 test_kasumi_decryption_test_case_1(void) 3978 { 3979 return test_kasumi_decryption(&kasumi_test_case_1); 3980 } 3981 3982 static int 3983 test_kasumi_decryption_test_case_1_oop(void) 3984 { 3985 return test_kasumi_decryption_oop(&kasumi_test_case_1); 3986 } 3987 3988 static int 3989 test_kasumi_decryption_test_case_2(void) 3990 { 3991 return test_kasumi_decryption(&kasumi_test_case_2); 3992 } 3993 3994 static int 3995 test_kasumi_decryption_test_case_3(void) 3996 { 3997 return test_kasumi_decryption(&kasumi_test_case_3); 3998 } 3999 4000 static int 4001 test_kasumi_decryption_test_case_4(void) 4002 { 4003 return test_kasumi_decryption(&kasumi_test_case_4); 4004 } 4005 4006 static int 4007 test_kasumi_decryption_test_case_5(void) 4008 { 4009 return test_kasumi_decryption(&kasumi_test_case_5); 4010 } 4011 static int 4012 test_snow3g_encryption_test_case_1(void) 4013 { 4014 return test_snow3g_encryption(&snow3g_test_case_1); 4015 } 4016 4017 static int 4018 test_snow3g_encryption_test_case_1_oop(void) 4019 { 4020 return test_snow3g_encryption_oop(&snow3g_test_case_1); 4021 } 4022 4023 static int 4024 test_snow3g_encryption_test_case_1_oop_sgl(void) 4025 { 4026 return test_snow3g_encryption_oop_sgl(&snow3g_test_case_1); 4027 } 4028 4029 4030 static int 4031 test_snow3g_encryption_test_case_1_offset_oop(void) 4032 { 4033 return test_snow3g_encryption_offset_oop(&snow3g_test_case_1); 4034 } 4035 4036 static int 4037 test_snow3g_encryption_test_case_2(void) 4038 { 4039 return test_snow3g_encryption(&snow3g_test_case_2); 4040 } 4041 4042 static int 4043 test_snow3g_encryption_test_case_3(void) 4044 { 4045 return test_snow3g_encryption(&snow3g_test_case_3); 4046 } 4047 4048 static int 4049 test_snow3g_encryption_test_case_4(void) 4050 { 4051 return test_snow3g_encryption(&snow3g_test_case_4); 4052 } 4053 4054 static int 4055 test_snow3g_encryption_test_case_5(void) 4056 { 4057 return test_snow3g_encryption(&snow3g_test_case_5); 4058 } 4059 4060 static int 4061 test_snow3g_decryption_test_case_1(void) 4062 { 4063 return test_snow3g_decryption(&snow3g_test_case_1); 4064 } 4065 4066 static int 4067 test_snow3g_decryption_test_case_1_oop(void) 4068 { 4069 return test_snow3g_decryption_oop(&snow3g_test_case_1); 4070 } 4071 4072 static int 4073 test_snow3g_decryption_test_case_2(void) 4074 { 4075 return test_snow3g_decryption(&snow3g_test_case_2); 4076 } 4077 4078 static int 4079 test_snow3g_decryption_test_case_3(void) 4080 { 4081 return test_snow3g_decryption(&snow3g_test_case_3); 4082 } 4083 4084 static int 4085 test_snow3g_decryption_test_case_4(void) 4086 { 4087 return test_snow3g_decryption(&snow3g_test_case_4); 4088 } 4089 4090 static int 4091 test_snow3g_decryption_test_case_5(void) 4092 { 4093 return test_snow3g_decryption(&snow3g_test_case_5); 4094 } 4095 static int 4096 test_snow3g_cipher_auth_test_case_1(void) 4097 { 4098 return test_snow3g_cipher_auth(&snow3g_test_case_3); 4099 } 4100 4101 static int 4102 test_snow3g_auth_cipher_test_case_1(void) 4103 { 4104 return test_snow3g_auth_cipher(&snow3g_test_case_6); 4105 } 4106 4107 static int 4108 test_kasumi_auth_cipher_test_case_1(void) 4109 { 4110 return test_kasumi_auth_cipher(&kasumi_test_case_3); 4111 } 4112 4113 static int 4114 test_kasumi_cipher_auth_test_case_1(void) 4115 { 4116 return test_kasumi_cipher_auth(&kasumi_test_case_6); 4117 } 4118 4119 static int 4120 test_zuc_encryption_test_case_1(void) 4121 { 4122 return test_zuc_encryption(&zuc_test_case_1); 4123 } 4124 4125 static int 4126 test_zuc_encryption_test_case_2(void) 4127 { 4128 return test_zuc_encryption(&zuc_test_case_2); 4129 } 4130 4131 static int 4132 test_zuc_encryption_test_case_3(void) 4133 { 4134 return test_zuc_encryption(&zuc_test_case_3); 4135 } 4136 4137 static int 4138 test_zuc_encryption_test_case_4(void) 4139 { 4140 return test_zuc_encryption(&zuc_test_case_4); 4141 } 4142 4143 static int 4144 test_zuc_encryption_test_case_5(void) 4145 { 4146 return test_zuc_encryption(&zuc_test_case_5); 4147 } 4148 4149 static int 4150 test_zuc_encryption_test_case_6_sgl(void) 4151 { 4152 return test_zuc_encryption_sgl(&zuc_test_case_1); 4153 } 4154 4155 static int 4156 test_zuc_hash_generate_test_case_1(void) 4157 { 4158 return test_zuc_authentication(&zuc_hash_test_case_1); 4159 } 4160 4161 static int 4162 test_zuc_hash_generate_test_case_2(void) 4163 { 4164 return test_zuc_authentication(&zuc_hash_test_case_2); 4165 } 4166 4167 static int 4168 test_zuc_hash_generate_test_case_3(void) 4169 { 4170 return test_zuc_authentication(&zuc_hash_test_case_3); 4171 } 4172 4173 static int 4174 test_zuc_hash_generate_test_case_4(void) 4175 { 4176 return test_zuc_authentication(&zuc_hash_test_case_4); 4177 } 4178 4179 static int 4180 test_zuc_hash_generate_test_case_5(void) 4181 { 4182 return test_zuc_authentication(&zuc_hash_test_case_5); 4183 } 4184 4185 static int 4186 test_3DES_chain_qat_all(void) 4187 { 4188 struct crypto_testsuite_params *ts_params = &testsuite_params; 4189 int status; 4190 4191 status = test_blockcipher_all_tests(ts_params->mbuf_pool, 4192 ts_params->op_mpool, ts_params->valid_devs[0], 4193 RTE_CRYPTODEV_QAT_SYM_PMD, 4194 BLKCIPHER_3DES_CHAIN_TYPE); 4195 4196 TEST_ASSERT_EQUAL(status, 0, "Test failed"); 4197 4198 return TEST_SUCCESS; 4199 } 4200 4201 static int 4202 test_DES_cipheronly_qat_all(void) 4203 { 4204 struct crypto_testsuite_params *ts_params = &testsuite_params; 4205 int status; 4206 4207 status = test_blockcipher_all_tests(ts_params->mbuf_pool, 4208 ts_params->op_mpool, ts_params->valid_devs[0], 4209 RTE_CRYPTODEV_QAT_SYM_PMD, 4210 BLKCIPHER_DES_CIPHERONLY_TYPE); 4211 4212 TEST_ASSERT_EQUAL(status, 0, "Test failed"); 4213 4214 return TEST_SUCCESS; 4215 } 4216 4217 static int 4218 test_3DES_cipheronly_qat_all(void) 4219 { 4220 struct crypto_testsuite_params *ts_params = &testsuite_params; 4221 int status; 4222 4223 status = test_blockcipher_all_tests(ts_params->mbuf_pool, 4224 ts_params->op_mpool, ts_params->valid_devs[0], 4225 RTE_CRYPTODEV_QAT_SYM_PMD, 4226 BLKCIPHER_3DES_CIPHERONLY_TYPE); 4227 4228 TEST_ASSERT_EQUAL(status, 0, "Test failed"); 4229 4230 return TEST_SUCCESS; 4231 } 4232 4233 static int 4234 test_3DES_chain_openssl_all(void) 4235 { 4236 struct crypto_testsuite_params *ts_params = &testsuite_params; 4237 int status; 4238 4239 status = test_blockcipher_all_tests(ts_params->mbuf_pool, 4240 ts_params->op_mpool, ts_params->valid_devs[0], 4241 RTE_CRYPTODEV_OPENSSL_PMD, 4242 BLKCIPHER_3DES_CHAIN_TYPE); 4243 4244 TEST_ASSERT_EQUAL(status, 0, "Test failed"); 4245 4246 return TEST_SUCCESS; 4247 } 4248 4249 static int 4250 test_3DES_cipheronly_openssl_all(void) 4251 { 4252 struct crypto_testsuite_params *ts_params = &testsuite_params; 4253 int status; 4254 4255 status = test_blockcipher_all_tests(ts_params->mbuf_pool, 4256 ts_params->op_mpool, ts_params->valid_devs[0], 4257 RTE_CRYPTODEV_OPENSSL_PMD, 4258 BLKCIPHER_3DES_CIPHERONLY_TYPE); 4259 4260 TEST_ASSERT_EQUAL(status, 0, "Test failed"); 4261 4262 return TEST_SUCCESS; 4263 } 4264 4265 /* ***** AES-GCM Tests ***** */ 4266 4267 static int 4268 create_gcm_session(uint8_t dev_id, enum rte_crypto_cipher_operation op, 4269 const uint8_t *key, const uint8_t key_len, 4270 const uint8_t aad_len, const uint8_t auth_len, 4271 enum rte_crypto_auth_operation auth_op) 4272 { 4273 uint8_t cipher_key[key_len]; 4274 4275 struct crypto_unittest_params *ut_params = &unittest_params; 4276 4277 memcpy(cipher_key, key, key_len); 4278 4279 /* Setup Cipher Parameters */ 4280 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 4281 ut_params->cipher_xform.next = NULL; 4282 4283 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_GCM; 4284 ut_params->auth_xform.auth.op = auth_op; 4285 ut_params->cipher_xform.cipher.op = op; 4286 ut_params->cipher_xform.cipher.key.data = cipher_key; 4287 ut_params->cipher_xform.cipher.key.length = key_len; 4288 4289 TEST_HEXDUMP(stdout, "key:", key, key_len); 4290 4291 /* Setup Authentication Parameters */ 4292 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 4293 ut_params->auth_xform.next = NULL; 4294 4295 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GCM; 4296 4297 ut_params->auth_xform.auth.digest_length = auth_len; 4298 ut_params->auth_xform.auth.add_auth_data_length = aad_len; 4299 ut_params->auth_xform.auth.key.length = 0; 4300 ut_params->auth_xform.auth.key.data = NULL; 4301 4302 if (op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) { 4303 ut_params->cipher_xform.next = &ut_params->auth_xform; 4304 4305 /* Create Crypto session*/ 4306 ut_params->sess = rte_cryptodev_sym_session_create(dev_id, 4307 &ut_params->cipher_xform); 4308 } else {/* Create Crypto session*/ 4309 ut_params->auth_xform.next = &ut_params->cipher_xform; 4310 ut_params->sess = rte_cryptodev_sym_session_create(dev_id, 4311 &ut_params->auth_xform); 4312 } 4313 4314 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 4315 4316 return 0; 4317 } 4318 4319 static int 4320 create_gcm_xforms(struct rte_crypto_op *op, 4321 enum rte_crypto_cipher_operation cipher_op, 4322 uint8_t *key, const uint8_t key_len, 4323 const uint8_t aad_len, const uint8_t auth_len, 4324 enum rte_crypto_auth_operation auth_op) 4325 { 4326 TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 2), 4327 "failed to allocate space for crypto transforms"); 4328 4329 struct rte_crypto_sym_op *sym_op = op->sym; 4330 4331 /* Setup Cipher Parameters */ 4332 sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_CIPHER; 4333 sym_op->xform->cipher.algo = RTE_CRYPTO_CIPHER_AES_GCM; 4334 sym_op->xform->cipher.op = cipher_op; 4335 sym_op->xform->cipher.key.data = key; 4336 sym_op->xform->cipher.key.length = key_len; 4337 4338 TEST_HEXDUMP(stdout, "key:", key, key_len); 4339 4340 /* Setup Authentication Parameters */ 4341 sym_op->xform->next->type = RTE_CRYPTO_SYM_XFORM_AUTH; 4342 sym_op->xform->next->auth.algo = RTE_CRYPTO_AUTH_AES_GCM; 4343 sym_op->xform->next->auth.op = auth_op; 4344 sym_op->xform->next->auth.digest_length = auth_len; 4345 sym_op->xform->next->auth.add_auth_data_length = aad_len; 4346 sym_op->xform->next->auth.key.length = 0; 4347 sym_op->xform->next->auth.key.data = NULL; 4348 sym_op->xform->next->next = NULL; 4349 4350 return 0; 4351 } 4352 4353 static int 4354 create_gcm_operation(enum rte_crypto_cipher_operation op, 4355 const struct gcm_test_data *tdata) 4356 { 4357 struct crypto_testsuite_params *ts_params = &testsuite_params; 4358 struct crypto_unittest_params *ut_params = &unittest_params; 4359 4360 uint8_t *plaintext, *ciphertext; 4361 unsigned int iv_pad_len, aad_pad_len, plaintext_pad_len; 4362 4363 /* Generate Crypto op data structure */ 4364 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 4365 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 4366 TEST_ASSERT_NOT_NULL(ut_params->op, 4367 "Failed to allocate symmetric crypto operation struct"); 4368 4369 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 4370 4371 /* Append aad data */ 4372 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16); 4373 sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 4374 aad_pad_len); 4375 TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data, 4376 "no room to append aad"); 4377 4378 sym_op->auth.aad.length = tdata->aad.len; 4379 sym_op->auth.aad.phys_addr = 4380 rte_pktmbuf_mtophys(ut_params->ibuf); 4381 memcpy(sym_op->auth.aad.data, tdata->aad.data, tdata->aad.len); 4382 TEST_HEXDUMP(stdout, "aad:", sym_op->auth.aad.data, 4383 sym_op->auth.aad.length); 4384 4385 /* Prepend iv */ 4386 iv_pad_len = RTE_ALIGN_CEIL(tdata->iv.len, 16); 4387 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend( 4388 ut_params->ibuf, iv_pad_len); 4389 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv"); 4390 4391 memset(sym_op->cipher.iv.data, 0, iv_pad_len); 4392 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); 4393 sym_op->cipher.iv.length = tdata->iv.len; 4394 4395 rte_memcpy(sym_op->cipher.iv.data, tdata->iv.data, tdata->iv.len); 4396 TEST_HEXDUMP(stdout, "iv:", sym_op->cipher.iv.data, 4397 sym_op->cipher.iv.length); 4398 4399 /* Append plaintext/ciphertext */ 4400 if (op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) { 4401 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16); 4402 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 4403 plaintext_pad_len); 4404 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext"); 4405 4406 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len); 4407 TEST_HEXDUMP(stdout, "plaintext:", plaintext, 4408 tdata->plaintext.len); 4409 4410 if (ut_params->obuf) { 4411 ciphertext = (uint8_t *)rte_pktmbuf_append( 4412 ut_params->obuf, 4413 plaintext_pad_len + aad_pad_len + 4414 iv_pad_len); 4415 TEST_ASSERT_NOT_NULL(ciphertext, 4416 "no room to append ciphertext"); 4417 4418 memset(ciphertext + aad_pad_len + iv_pad_len, 0, 4419 tdata->ciphertext.len); 4420 } 4421 } else { 4422 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16); 4423 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 4424 plaintext_pad_len); 4425 TEST_ASSERT_NOT_NULL(ciphertext, 4426 "no room to append ciphertext"); 4427 4428 memcpy(ciphertext, tdata->ciphertext.data, 4429 tdata->ciphertext.len); 4430 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, 4431 tdata->ciphertext.len); 4432 4433 if (ut_params->obuf) { 4434 plaintext = (uint8_t *)rte_pktmbuf_append( 4435 ut_params->obuf, 4436 plaintext_pad_len + aad_pad_len + 4437 iv_pad_len); 4438 TEST_ASSERT_NOT_NULL(plaintext, 4439 "no room to append plaintext"); 4440 4441 memset(plaintext + aad_pad_len + iv_pad_len, 0, 4442 tdata->plaintext.len); 4443 } 4444 } 4445 4446 /* Append digest data */ 4447 if (op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) { 4448 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( 4449 ut_params->obuf ? ut_params->obuf : 4450 ut_params->ibuf, 4451 tdata->auth_tag.len); 4452 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, 4453 "no room to append digest"); 4454 memset(sym_op->auth.digest.data, 0, tdata->auth_tag.len); 4455 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( 4456 ut_params->obuf ? ut_params->obuf : 4457 ut_params->ibuf, 4458 plaintext_pad_len + 4459 aad_pad_len + iv_pad_len); 4460 sym_op->auth.digest.length = tdata->auth_tag.len; 4461 } else { 4462 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( 4463 ut_params->ibuf, tdata->auth_tag.len); 4464 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, 4465 "no room to append digest"); 4466 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( 4467 ut_params->ibuf, 4468 plaintext_pad_len + aad_pad_len + iv_pad_len); 4469 sym_op->auth.digest.length = tdata->auth_tag.len; 4470 4471 rte_memcpy(sym_op->auth.digest.data, tdata->auth_tag.data, 4472 tdata->auth_tag.len); 4473 TEST_HEXDUMP(stdout, "digest:", 4474 sym_op->auth.digest.data, 4475 sym_op->auth.digest.length); 4476 } 4477 4478 sym_op->cipher.data.length = tdata->plaintext.len; 4479 sym_op->cipher.data.offset = aad_pad_len + iv_pad_len; 4480 4481 sym_op->auth.data.length = tdata->plaintext.len; 4482 sym_op->auth.data.offset = aad_pad_len + iv_pad_len; 4483 4484 return 0; 4485 } 4486 4487 static int 4488 test_mb_AES_GCM_authenticated_encryption(const struct gcm_test_data *tdata) 4489 { 4490 struct crypto_testsuite_params *ts_params = &testsuite_params; 4491 struct crypto_unittest_params *ut_params = &unittest_params; 4492 4493 int retval; 4494 uint8_t *ciphertext, *auth_tag; 4495 uint16_t plaintext_pad_len; 4496 uint32_t i; 4497 4498 /* Create GCM session */ 4499 retval = create_gcm_session(ts_params->valid_devs[0], 4500 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 4501 tdata->key.data, tdata->key.len, 4502 tdata->aad.len, tdata->auth_tag.len, 4503 RTE_CRYPTO_AUTH_OP_GENERATE); 4504 if (retval < 0) 4505 return retval; 4506 4507 if (tdata->aad.len > MBUF_SIZE) { 4508 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool); 4509 /* Populate full size of add data */ 4510 for (i = 32; i < GCM_MAX_AAD_LENGTH; i += 32) 4511 memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32); 4512 } else 4513 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 4514 4515 /* clear mbuf payload */ 4516 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 4517 rte_pktmbuf_tailroom(ut_params->ibuf)); 4518 4519 /* Create GCM operation */ 4520 retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_ENCRYPT, tdata); 4521 if (retval < 0) 4522 return retval; 4523 4524 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 4525 4526 ut_params->op->sym->m_src = ut_params->ibuf; 4527 4528 /* Process crypto operation */ 4529 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], 4530 ut_params->op), "failed to process sym crypto op"); 4531 4532 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 4533 "crypto op processing failed"); 4534 4535 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16); 4536 4537 if (ut_params->op->sym->m_dst) { 4538 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst, 4539 uint8_t *); 4540 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst, 4541 uint8_t *, plaintext_pad_len); 4542 } else { 4543 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src, 4544 uint8_t *, 4545 ut_params->op->sym->cipher.data.offset); 4546 auth_tag = ciphertext + plaintext_pad_len; 4547 } 4548 4549 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len); 4550 TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->auth_tag.len); 4551 4552 /* Validate obuf */ 4553 TEST_ASSERT_BUFFERS_ARE_EQUAL( 4554 ciphertext, 4555 tdata->ciphertext.data, 4556 tdata->ciphertext.len, 4557 "GCM Ciphertext data not as expected"); 4558 4559 TEST_ASSERT_BUFFERS_ARE_EQUAL( 4560 auth_tag, 4561 tdata->auth_tag.data, 4562 tdata->auth_tag.len, 4563 "GCM Generated auth tag not as expected"); 4564 4565 return 0; 4566 4567 } 4568 4569 static int 4570 test_mb_AES_GCM_authenticated_encryption_test_case_1(void) 4571 { 4572 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_1); 4573 } 4574 4575 static int 4576 test_mb_AES_GCM_authenticated_encryption_test_case_2(void) 4577 { 4578 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_2); 4579 } 4580 4581 static int 4582 test_mb_AES_GCM_authenticated_encryption_test_case_3(void) 4583 { 4584 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_3); 4585 } 4586 4587 static int 4588 test_mb_AES_GCM_authenticated_encryption_test_case_4(void) 4589 { 4590 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_4); 4591 } 4592 4593 static int 4594 test_mb_AES_GCM_authenticated_encryption_test_case_5(void) 4595 { 4596 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_5); 4597 } 4598 4599 static int 4600 test_mb_AES_GCM_authenticated_encryption_test_case_6(void) 4601 { 4602 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_6); 4603 } 4604 4605 static int 4606 test_mb_AES_GCM_authenticated_encryption_test_case_7(void) 4607 { 4608 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_7); 4609 } 4610 4611 static int 4612 test_mb_AES_GCM_auth_encryption_test_case_256_1(void) 4613 { 4614 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_1); 4615 } 4616 4617 static int 4618 test_mb_AES_GCM_auth_encryption_test_case_256_2(void) 4619 { 4620 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_2); 4621 } 4622 4623 static int 4624 test_mb_AES_GCM_auth_encryption_test_case_256_3(void) 4625 { 4626 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_3); 4627 } 4628 4629 static int 4630 test_mb_AES_GCM_auth_encryption_test_case_256_4(void) 4631 { 4632 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_4); 4633 } 4634 4635 static int 4636 test_mb_AES_GCM_auth_encryption_test_case_256_5(void) 4637 { 4638 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_5); 4639 } 4640 4641 static int 4642 test_mb_AES_GCM_auth_encryption_test_case_256_6(void) 4643 { 4644 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_6); 4645 } 4646 4647 static int 4648 test_mb_AES_GCM_auth_encryption_test_case_256_7(void) 4649 { 4650 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_7); 4651 } 4652 4653 static int 4654 test_mb_AES_GCM_auth_encryption_test_case_aad_1(void) 4655 { 4656 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_aad_1); 4657 } 4658 4659 static int 4660 test_mb_AES_GCM_auth_encryption_test_case_aad_2(void) 4661 { 4662 return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_aad_2); 4663 } 4664 4665 static int 4666 test_mb_AES_GCM_authenticated_decryption(const struct gcm_test_data *tdata) 4667 { 4668 struct crypto_testsuite_params *ts_params = &testsuite_params; 4669 struct crypto_unittest_params *ut_params = &unittest_params; 4670 4671 int retval; 4672 uint8_t *plaintext; 4673 uint32_t i; 4674 4675 /* Create GCM session */ 4676 retval = create_gcm_session(ts_params->valid_devs[0], 4677 RTE_CRYPTO_CIPHER_OP_DECRYPT, 4678 tdata->key.data, tdata->key.len, 4679 tdata->aad.len, tdata->auth_tag.len, 4680 RTE_CRYPTO_AUTH_OP_VERIFY); 4681 if (retval < 0) 4682 return retval; 4683 4684 /* alloc mbuf and set payload */ 4685 if (tdata->aad.len > MBUF_SIZE) { 4686 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool); 4687 /* Populate full size of add data */ 4688 for (i = 32; i < GCM_MAX_AAD_LENGTH; i += 32) 4689 memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32); 4690 } else 4691 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 4692 4693 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 4694 rte_pktmbuf_tailroom(ut_params->ibuf)); 4695 4696 /* Create GCM operation */ 4697 retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_DECRYPT, tdata); 4698 if (retval < 0) 4699 return retval; 4700 4701 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 4702 4703 ut_params->op->sym->m_src = ut_params->ibuf; 4704 4705 /* Process crypto operation */ 4706 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], 4707 ut_params->op), "failed to process sym crypto op"); 4708 4709 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 4710 "crypto op processing failed"); 4711 4712 if (ut_params->op->sym->m_dst) 4713 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst, 4714 uint8_t *); 4715 else 4716 plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src, 4717 uint8_t *, 4718 ut_params->op->sym->cipher.data.offset); 4719 4720 TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->ciphertext.len); 4721 4722 /* Validate obuf */ 4723 TEST_ASSERT_BUFFERS_ARE_EQUAL( 4724 plaintext, 4725 tdata->plaintext.data, 4726 tdata->plaintext.len, 4727 "GCM plaintext data not as expected"); 4728 4729 TEST_ASSERT_EQUAL(ut_params->op->status, 4730 RTE_CRYPTO_OP_STATUS_SUCCESS, 4731 "GCM authentication failed"); 4732 return 0; 4733 } 4734 4735 static int 4736 test_mb_AES_GCM_authenticated_decryption_test_case_1(void) 4737 { 4738 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_1); 4739 } 4740 4741 static int 4742 test_mb_AES_GCM_authenticated_decryption_test_case_2(void) 4743 { 4744 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_2); 4745 } 4746 4747 static int 4748 test_mb_AES_GCM_authenticated_decryption_test_case_3(void) 4749 { 4750 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_3); 4751 } 4752 4753 static int 4754 test_mb_AES_GCM_authenticated_decryption_test_case_4(void) 4755 { 4756 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_4); 4757 } 4758 4759 static int 4760 test_mb_AES_GCM_authenticated_decryption_test_case_5(void) 4761 { 4762 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_5); 4763 } 4764 4765 static int 4766 test_mb_AES_GCM_authenticated_decryption_test_case_6(void) 4767 { 4768 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_6); 4769 } 4770 4771 static int 4772 test_mb_AES_GCM_authenticated_decryption_test_case_7(void) 4773 { 4774 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_7); 4775 } 4776 4777 static int 4778 test_mb_AES_GCM_auth_decryption_test_case_256_1(void) 4779 { 4780 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_1); 4781 } 4782 4783 static int 4784 test_mb_AES_GCM_auth_decryption_test_case_256_2(void) 4785 { 4786 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_2); 4787 } 4788 4789 static int 4790 test_mb_AES_GCM_auth_decryption_test_case_256_3(void) 4791 { 4792 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_3); 4793 } 4794 4795 static int 4796 test_mb_AES_GCM_auth_decryption_test_case_256_4(void) 4797 { 4798 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_4); 4799 } 4800 4801 static int 4802 test_mb_AES_GCM_auth_decryption_test_case_256_5(void) 4803 { 4804 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_5); 4805 } 4806 4807 static int 4808 test_mb_AES_GCM_auth_decryption_test_case_256_6(void) 4809 { 4810 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_6); 4811 } 4812 4813 static int 4814 test_mb_AES_GCM_auth_decryption_test_case_256_7(void) 4815 { 4816 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_7); 4817 } 4818 4819 static int 4820 test_mb_AES_GCM_auth_decryption_test_case_aad_1(void) 4821 { 4822 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_aad_1); 4823 } 4824 4825 static int 4826 test_mb_AES_GCM_auth_decryption_test_case_aad_2(void) 4827 { 4828 return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_aad_2); 4829 } 4830 4831 static int 4832 test_AES_GCM_authenticated_encryption_oop(const struct gcm_test_data *tdata) 4833 { 4834 struct crypto_testsuite_params *ts_params = &testsuite_params; 4835 struct crypto_unittest_params *ut_params = &unittest_params; 4836 4837 int retval; 4838 uint8_t *ciphertext, *auth_tag; 4839 uint16_t plaintext_pad_len; 4840 4841 /* Create GCM session */ 4842 retval = create_gcm_session(ts_params->valid_devs[0], 4843 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 4844 tdata->key.data, tdata->key.len, 4845 tdata->aad.len, tdata->auth_tag.len, 4846 RTE_CRYPTO_AUTH_OP_GENERATE); 4847 if (retval < 0) 4848 return retval; 4849 4850 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 4851 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 4852 4853 /* clear mbuf payload */ 4854 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 4855 rte_pktmbuf_tailroom(ut_params->ibuf)); 4856 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0, 4857 rte_pktmbuf_tailroom(ut_params->obuf)); 4858 4859 /* Create GCM operation */ 4860 retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_ENCRYPT, tdata); 4861 if (retval < 0) 4862 return retval; 4863 4864 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 4865 4866 ut_params->op->sym->m_src = ut_params->ibuf; 4867 ut_params->op->sym->m_dst = ut_params->obuf; 4868 4869 /* Process crypto operation */ 4870 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], 4871 ut_params->op), "failed to process sym crypto op"); 4872 4873 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 4874 "crypto op processing failed"); 4875 4876 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16); 4877 4878 ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *, 4879 ut_params->op->sym->cipher.data.offset); 4880 auth_tag = ciphertext + plaintext_pad_len; 4881 4882 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len); 4883 TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->auth_tag.len); 4884 4885 /* Validate obuf */ 4886 TEST_ASSERT_BUFFERS_ARE_EQUAL( 4887 ciphertext, 4888 tdata->ciphertext.data, 4889 tdata->ciphertext.len, 4890 "GCM Ciphertext data not as expected"); 4891 4892 TEST_ASSERT_BUFFERS_ARE_EQUAL( 4893 auth_tag, 4894 tdata->auth_tag.data, 4895 tdata->auth_tag.len, 4896 "GCM Generated auth tag not as expected"); 4897 4898 return 0; 4899 4900 } 4901 4902 static int 4903 test_mb_AES_GCM_authenticated_encryption_oop(void) 4904 { 4905 return test_AES_GCM_authenticated_encryption_oop(&gcm_test_case_5); 4906 } 4907 4908 static int 4909 test_AES_GCM_authenticated_decryption_oop(const struct gcm_test_data *tdata) 4910 { 4911 struct crypto_testsuite_params *ts_params = &testsuite_params; 4912 struct crypto_unittest_params *ut_params = &unittest_params; 4913 4914 int retval; 4915 uint8_t *plaintext; 4916 4917 /* Create GCM session */ 4918 retval = create_gcm_session(ts_params->valid_devs[0], 4919 RTE_CRYPTO_CIPHER_OP_DECRYPT, 4920 tdata->key.data, tdata->key.len, 4921 tdata->aad.len, tdata->auth_tag.len, 4922 RTE_CRYPTO_AUTH_OP_VERIFY); 4923 if (retval < 0) 4924 return retval; 4925 4926 /* alloc mbuf and set payload */ 4927 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 4928 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 4929 4930 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 4931 rte_pktmbuf_tailroom(ut_params->ibuf)); 4932 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0, 4933 rte_pktmbuf_tailroom(ut_params->obuf)); 4934 4935 /* Create GCM operation */ 4936 retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_DECRYPT, tdata); 4937 if (retval < 0) 4938 return retval; 4939 4940 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 4941 4942 ut_params->op->sym->m_src = ut_params->ibuf; 4943 ut_params->op->sym->m_dst = ut_params->obuf; 4944 4945 /* Process crypto operation */ 4946 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], 4947 ut_params->op), "failed to process sym crypto op"); 4948 4949 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 4950 "crypto op processing failed"); 4951 4952 plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *, 4953 ut_params->op->sym->cipher.data.offset); 4954 4955 TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->ciphertext.len); 4956 4957 /* Validate obuf */ 4958 TEST_ASSERT_BUFFERS_ARE_EQUAL( 4959 plaintext, 4960 tdata->plaintext.data, 4961 tdata->plaintext.len, 4962 "GCM plaintext data not as expected"); 4963 4964 TEST_ASSERT_EQUAL(ut_params->op->status, 4965 RTE_CRYPTO_OP_STATUS_SUCCESS, 4966 "GCM authentication failed"); 4967 return 0; 4968 } 4969 4970 static int 4971 test_mb_AES_GCM_authenticated_decryption_oop(void) 4972 { 4973 return test_AES_GCM_authenticated_decryption_oop(&gcm_test_case_5); 4974 } 4975 4976 static int 4977 test_AES_GCM_authenticated_encryption_sessionless( 4978 const struct gcm_test_data *tdata) 4979 { 4980 struct crypto_testsuite_params *ts_params = &testsuite_params; 4981 struct crypto_unittest_params *ut_params = &unittest_params; 4982 4983 int retval; 4984 uint8_t *ciphertext, *auth_tag; 4985 uint16_t plaintext_pad_len; 4986 uint8_t key[tdata->key.len + 1]; 4987 4988 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 4989 4990 /* clear mbuf payload */ 4991 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 4992 rte_pktmbuf_tailroom(ut_params->ibuf)); 4993 4994 /* Create GCM operation */ 4995 retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_ENCRYPT, tdata); 4996 if (retval < 0) 4997 return retval; 4998 4999 /* Create GCM xforms */ 5000 memcpy(key, tdata->key.data, tdata->key.len); 5001 retval = create_gcm_xforms(ut_params->op, 5002 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 5003 key, tdata->key.len, 5004 tdata->aad.len, tdata->auth_tag.len, 5005 RTE_CRYPTO_AUTH_OP_GENERATE); 5006 if (retval < 0) 5007 return retval; 5008 5009 ut_params->op->sym->m_src = ut_params->ibuf; 5010 5011 TEST_ASSERT_EQUAL(ut_params->op->sym->sess_type, 5012 RTE_CRYPTO_SYM_OP_SESSIONLESS, 5013 "crypto op session type not sessionless"); 5014 5015 /* Process crypto operation */ 5016 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], 5017 ut_params->op), "failed to process sym crypto op"); 5018 5019 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process"); 5020 5021 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 5022 "crypto op status not success"); 5023 5024 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16); 5025 5026 ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *, 5027 ut_params->op->sym->cipher.data.offset); 5028 auth_tag = ciphertext + plaintext_pad_len; 5029 5030 TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len); 5031 TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->auth_tag.len); 5032 5033 /* Validate obuf */ 5034 TEST_ASSERT_BUFFERS_ARE_EQUAL( 5035 ciphertext, 5036 tdata->ciphertext.data, 5037 tdata->ciphertext.len, 5038 "GCM Ciphertext data not as expected"); 5039 5040 TEST_ASSERT_BUFFERS_ARE_EQUAL( 5041 auth_tag, 5042 tdata->auth_tag.data, 5043 tdata->auth_tag.len, 5044 "GCM Generated auth tag not as expected"); 5045 5046 return 0; 5047 5048 } 5049 5050 static int 5051 test_mb_AES_GCM_authenticated_encryption_sessionless(void) 5052 { 5053 return test_AES_GCM_authenticated_encryption_sessionless( 5054 &gcm_test_case_5); 5055 } 5056 5057 static int 5058 test_AES_GCM_authenticated_decryption_sessionless( 5059 const struct gcm_test_data *tdata) 5060 { 5061 struct crypto_testsuite_params *ts_params = &testsuite_params; 5062 struct crypto_unittest_params *ut_params = &unittest_params; 5063 5064 int retval; 5065 uint8_t *plaintext; 5066 uint8_t key[tdata->key.len + 1]; 5067 5068 /* alloc mbuf and set payload */ 5069 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 5070 5071 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 5072 rte_pktmbuf_tailroom(ut_params->ibuf)); 5073 5074 /* Create GCM operation */ 5075 retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_DECRYPT, tdata); 5076 if (retval < 0) 5077 return retval; 5078 5079 /* Create GCM xforms */ 5080 memcpy(key, tdata->key.data, tdata->key.len); 5081 retval = create_gcm_xforms(ut_params->op, 5082 RTE_CRYPTO_CIPHER_OP_DECRYPT, 5083 key, tdata->key.len, 5084 tdata->aad.len, tdata->auth_tag.len, 5085 RTE_CRYPTO_AUTH_OP_VERIFY); 5086 if (retval < 0) 5087 return retval; 5088 5089 ut_params->op->sym->m_src = ut_params->ibuf; 5090 5091 TEST_ASSERT_EQUAL(ut_params->op->sym->sess_type, 5092 RTE_CRYPTO_SYM_OP_SESSIONLESS, 5093 "crypto op session type not sessionless"); 5094 5095 /* Process crypto operation */ 5096 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], 5097 ut_params->op), "failed to process sym crypto op"); 5098 5099 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process"); 5100 5101 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 5102 "crypto op status not success"); 5103 5104 plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *, 5105 ut_params->op->sym->cipher.data.offset); 5106 5107 TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->ciphertext.len); 5108 5109 /* Validate obuf */ 5110 TEST_ASSERT_BUFFERS_ARE_EQUAL( 5111 plaintext, 5112 tdata->plaintext.data, 5113 tdata->plaintext.len, 5114 "GCM plaintext data not as expected"); 5115 5116 TEST_ASSERT_EQUAL(ut_params->op->status, 5117 RTE_CRYPTO_OP_STATUS_SUCCESS, 5118 "GCM authentication failed"); 5119 return 0; 5120 } 5121 5122 static int 5123 test_mb_AES_GCM_authenticated_decryption_sessionless(void) 5124 { 5125 return test_AES_GCM_authenticated_decryption_sessionless( 5126 &gcm_test_case_5); 5127 } 5128 5129 static int 5130 test_stats(void) 5131 { 5132 struct crypto_testsuite_params *ts_params = &testsuite_params; 5133 struct rte_cryptodev_stats stats; 5134 struct rte_cryptodev *dev; 5135 cryptodev_stats_get_t temp_pfn; 5136 5137 rte_cryptodev_stats_reset(ts_params->valid_devs[0]); 5138 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600, 5139 &stats) == -ENODEV), 5140 "rte_cryptodev_stats_get invalid dev failed"); 5141 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0), 5142 "rte_cryptodev_stats_get invalid Param failed"); 5143 dev = &rte_cryptodevs[ts_params->valid_devs[0]]; 5144 temp_pfn = dev->dev_ops->stats_get; 5145 dev->dev_ops->stats_get = (cryptodev_stats_get_t)0; 5146 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats) 5147 == -ENOTSUP), 5148 "rte_cryptodev_stats_get invalid Param failed"); 5149 dev->dev_ops->stats_get = temp_pfn; 5150 5151 /* Test expected values */ 5152 ut_setup(); 5153 test_AES_CBC_HMAC_SHA1_encrypt_digest(); 5154 ut_teardown(); 5155 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0], 5156 &stats), 5157 "rte_cryptodev_stats_get failed"); 5158 TEST_ASSERT((stats.enqueued_count == 1), 5159 "rte_cryptodev_stats_get returned unexpected enqueued stat"); 5160 TEST_ASSERT((stats.dequeued_count == 1), 5161 "rte_cryptodev_stats_get returned unexpected enqueued stat"); 5162 TEST_ASSERT((stats.enqueue_err_count == 0), 5163 "rte_cryptodev_stats_get returned unexpected enqueued stat"); 5164 TEST_ASSERT((stats.dequeue_err_count == 0), 5165 "rte_cryptodev_stats_get returned unexpected enqueued stat"); 5166 5167 /* invalid device but should ignore and not reset device stats*/ 5168 rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300); 5169 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0], 5170 &stats), 5171 "rte_cryptodev_stats_get failed"); 5172 TEST_ASSERT((stats.enqueued_count == 1), 5173 "rte_cryptodev_stats_get returned unexpected enqueued stat"); 5174 5175 /* check that a valid reset clears stats */ 5176 rte_cryptodev_stats_reset(ts_params->valid_devs[0]); 5177 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0], 5178 &stats), 5179 "rte_cryptodev_stats_get failed"); 5180 TEST_ASSERT((stats.enqueued_count == 0), 5181 "rte_cryptodev_stats_get returned unexpected enqueued stat"); 5182 TEST_ASSERT((stats.dequeued_count == 0), 5183 "rte_cryptodev_stats_get returned unexpected enqueued stat"); 5184 5185 return TEST_SUCCESS; 5186 } 5187 5188 static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params, 5189 struct crypto_unittest_params *ut_params, 5190 enum rte_crypto_auth_operation op, 5191 const struct HMAC_MD5_vector *test_case) 5192 { 5193 uint8_t key[64]; 5194 5195 memcpy(key, test_case->key.data, test_case->key.len); 5196 5197 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 5198 ut_params->auth_xform.next = NULL; 5199 ut_params->auth_xform.auth.op = op; 5200 5201 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC; 5202 5203 ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN; 5204 ut_params->auth_xform.auth.add_auth_data_length = 0; 5205 ut_params->auth_xform.auth.key.length = test_case->key.len; 5206 ut_params->auth_xform.auth.key.data = key; 5207 5208 ut_params->sess = rte_cryptodev_sym_session_create( 5209 ts_params->valid_devs[0], &ut_params->auth_xform); 5210 5211 if (ut_params->sess == NULL) 5212 return TEST_FAILED; 5213 5214 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 5215 5216 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 5217 rte_pktmbuf_tailroom(ut_params->ibuf)); 5218 5219 return 0; 5220 } 5221 5222 static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params, 5223 const struct HMAC_MD5_vector *test_case, 5224 uint8_t **plaintext) 5225 { 5226 uint16_t plaintext_pad_len; 5227 5228 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 5229 5230 plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len, 5231 16); 5232 5233 *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 5234 plaintext_pad_len); 5235 memcpy(*plaintext, test_case->plaintext.data, 5236 test_case->plaintext.len); 5237 5238 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( 5239 ut_params->ibuf, MD5_DIGEST_LEN); 5240 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, 5241 "no room to append digest"); 5242 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( 5243 ut_params->ibuf, plaintext_pad_len); 5244 sym_op->auth.digest.length = MD5_DIGEST_LEN; 5245 5246 if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) { 5247 rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data, 5248 test_case->auth_tag.len); 5249 } 5250 5251 sym_op->auth.data.offset = 0; 5252 sym_op->auth.data.length = test_case->plaintext.len; 5253 5254 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 5255 ut_params->op->sym->m_src = ut_params->ibuf; 5256 5257 return 0; 5258 } 5259 5260 static int 5261 test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case) 5262 { 5263 uint16_t plaintext_pad_len; 5264 uint8_t *plaintext, *auth_tag; 5265 5266 struct crypto_testsuite_params *ts_params = &testsuite_params; 5267 struct crypto_unittest_params *ut_params = &unittest_params; 5268 5269 if (MD5_HMAC_create_session(ts_params, ut_params, 5270 RTE_CRYPTO_AUTH_OP_GENERATE, test_case)) 5271 return TEST_FAILED; 5272 5273 /* Generate Crypto op data structure */ 5274 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 5275 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 5276 TEST_ASSERT_NOT_NULL(ut_params->op, 5277 "Failed to allocate symmetric crypto operation struct"); 5278 5279 plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len, 5280 16); 5281 5282 if (MD5_HMAC_create_op(ut_params, test_case, &plaintext)) 5283 return TEST_FAILED; 5284 5285 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], 5286 ut_params->op), "failed to process sym crypto op"); 5287 5288 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 5289 "crypto op processing failed"); 5290 5291 if (ut_params->op->sym->m_dst) { 5292 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst, 5293 uint8_t *, plaintext_pad_len); 5294 } else { 5295 auth_tag = plaintext + plaintext_pad_len; 5296 } 5297 5298 TEST_ASSERT_BUFFERS_ARE_EQUAL( 5299 auth_tag, 5300 test_case->auth_tag.data, 5301 test_case->auth_tag.len, 5302 "HMAC_MD5 generated tag not as expected"); 5303 5304 return TEST_SUCCESS; 5305 } 5306 5307 static int 5308 test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case) 5309 { 5310 uint8_t *plaintext; 5311 5312 struct crypto_testsuite_params *ts_params = &testsuite_params; 5313 struct crypto_unittest_params *ut_params = &unittest_params; 5314 5315 if (MD5_HMAC_create_session(ts_params, ut_params, 5316 RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) { 5317 return TEST_FAILED; 5318 } 5319 5320 /* Generate Crypto op data structure */ 5321 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 5322 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 5323 TEST_ASSERT_NOT_NULL(ut_params->op, 5324 "Failed to allocate symmetric crypto operation struct"); 5325 5326 if (MD5_HMAC_create_op(ut_params, test_case, &plaintext)) 5327 return TEST_FAILED; 5328 5329 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], 5330 ut_params->op), "failed to process sym crypto op"); 5331 5332 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 5333 "HMAC_MD5 crypto op processing failed"); 5334 5335 return TEST_SUCCESS; 5336 } 5337 5338 static int 5339 test_MD5_HMAC_generate_case_1(void) 5340 { 5341 return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1); 5342 } 5343 5344 static int 5345 test_MD5_HMAC_verify_case_1(void) 5346 { 5347 return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1); 5348 } 5349 5350 static int 5351 test_MD5_HMAC_generate_case_2(void) 5352 { 5353 return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2); 5354 } 5355 5356 static int 5357 test_MD5_HMAC_verify_case_2(void) 5358 { 5359 return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2); 5360 } 5361 5362 static int 5363 test_multi_session(void) 5364 { 5365 struct crypto_testsuite_params *ts_params = &testsuite_params; 5366 struct crypto_unittest_params *ut_params = &unittest_params; 5367 5368 struct rte_cryptodev_info dev_info; 5369 struct rte_cryptodev_sym_session **sessions; 5370 5371 uint16_t i; 5372 5373 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params, 5374 aes_cbc_key, hmac_sha512_key); 5375 5376 5377 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 5378 5379 sessions = rte_malloc(NULL, 5380 (sizeof(struct rte_cryptodev_sym_session *) * 5381 dev_info.sym.max_nb_sessions) + 1, 0); 5382 5383 /* Create multiple crypto sessions*/ 5384 for (i = 0; i < dev_info.sym.max_nb_sessions; i++) { 5385 sessions[i] = rte_cryptodev_sym_session_create( 5386 ts_params->valid_devs[0], 5387 &ut_params->auth_xform); 5388 TEST_ASSERT_NOT_NULL(sessions[i], 5389 "Session creation failed at session number %u", 5390 i); 5391 5392 /* Attempt to send a request on each session */ 5393 TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform( 5394 sessions[i], 5395 ut_params, 5396 ts_params, 5397 catch_22_quote_2_512_bytes_AES_CBC_ciphertext, 5398 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest, 5399 aes_cbc_iv), 5400 "Failed to perform decrypt on request number %u.", i); 5401 /* free crypto operation structure */ 5402 if (ut_params->op) 5403 rte_crypto_op_free(ut_params->op); 5404 5405 /* 5406 * free mbuf - both obuf and ibuf are usually the same, 5407 * so check if they point at the same address is necessary, 5408 * to avoid freeing the mbuf twice. 5409 */ 5410 if (ut_params->obuf) { 5411 rte_pktmbuf_free(ut_params->obuf); 5412 if (ut_params->ibuf == ut_params->obuf) 5413 ut_params->ibuf = 0; 5414 ut_params->obuf = 0; 5415 } 5416 if (ut_params->ibuf) { 5417 rte_pktmbuf_free(ut_params->ibuf); 5418 ut_params->ibuf = 0; 5419 } 5420 } 5421 5422 /* Next session create should fail */ 5423 sessions[i] = rte_cryptodev_sym_session_create(ts_params->valid_devs[0], 5424 &ut_params->auth_xform); 5425 TEST_ASSERT_NULL(sessions[i], 5426 "Session creation succeeded unexpectedly!"); 5427 5428 for (i = 0; i < dev_info.sym.max_nb_sessions; i++) 5429 rte_cryptodev_sym_session_free(ts_params->valid_devs[0], 5430 sessions[i]); 5431 5432 rte_free(sessions); 5433 5434 return TEST_SUCCESS; 5435 } 5436 5437 struct multi_session_params { 5438 struct crypto_unittest_params ut_params; 5439 uint8_t *cipher_key; 5440 uint8_t *hmac_key; 5441 const uint8_t *cipher; 5442 const uint8_t *digest; 5443 uint8_t *iv; 5444 }; 5445 5446 #define MB_SESSION_NUMBER 3 5447 5448 static int 5449 test_multi_session_random_usage(void) 5450 { 5451 struct crypto_testsuite_params *ts_params = &testsuite_params; 5452 struct rte_cryptodev_info dev_info; 5453 struct rte_cryptodev_sym_session **sessions; 5454 uint32_t i, j; 5455 struct multi_session_params ut_paramz[] = { 5456 5457 { 5458 .cipher_key = ms_aes_cbc_key0, 5459 .hmac_key = ms_hmac_key0, 5460 .cipher = ms_aes_cbc_cipher0, 5461 .digest = ms_hmac_digest0, 5462 .iv = ms_aes_cbc_iv0 5463 }, 5464 { 5465 .cipher_key = ms_aes_cbc_key1, 5466 .hmac_key = ms_hmac_key1, 5467 .cipher = ms_aes_cbc_cipher1, 5468 .digest = ms_hmac_digest1, 5469 .iv = ms_aes_cbc_iv1 5470 }, 5471 { 5472 .cipher_key = ms_aes_cbc_key2, 5473 .hmac_key = ms_hmac_key2, 5474 .cipher = ms_aes_cbc_cipher2, 5475 .digest = ms_hmac_digest2, 5476 .iv = ms_aes_cbc_iv2 5477 }, 5478 5479 }; 5480 5481 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 5482 5483 sessions = rte_malloc(NULL, 5484 (sizeof(struct rte_cryptodev_sym_session *) 5485 * dev_info.sym.max_nb_sessions) + 1, 0); 5486 5487 for (i = 0; i < MB_SESSION_NUMBER; i++) { 5488 rte_memcpy(&ut_paramz[i].ut_params, &testsuite_params, 5489 sizeof(struct crypto_unittest_params)); 5490 5491 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params( 5492 &ut_paramz[i].ut_params, 5493 ut_paramz[i].cipher_key, ut_paramz[i].hmac_key); 5494 5495 /* Create multiple crypto sessions*/ 5496 sessions[i] = rte_cryptodev_sym_session_create( 5497 ts_params->valid_devs[0], 5498 &ut_paramz[i].ut_params.auth_xform); 5499 5500 TEST_ASSERT_NOT_NULL(sessions[i], 5501 "Session creation failed at session number %u", 5502 i); 5503 5504 } 5505 5506 srand(time(NULL)); 5507 for (i = 0; i < 40000; i++) { 5508 5509 j = rand() % MB_SESSION_NUMBER; 5510 5511 TEST_ASSERT_SUCCESS( 5512 test_AES_CBC_HMAC_SHA512_decrypt_perform( 5513 sessions[j], 5514 &ut_paramz[j].ut_params, 5515 ts_params, ut_paramz[j].cipher, 5516 ut_paramz[j].digest, 5517 ut_paramz[j].iv), 5518 "Failed to perform decrypt on request number %u.", i); 5519 5520 if (ut_paramz[j].ut_params.op) 5521 rte_crypto_op_free(ut_paramz[j].ut_params.op); 5522 5523 /* 5524 * free mbuf - both obuf and ibuf are usually the same, 5525 * so check if they point at the same address is necessary, 5526 * to avoid freeing the mbuf twice. 5527 */ 5528 if (ut_paramz[j].ut_params.obuf) { 5529 rte_pktmbuf_free(ut_paramz[j].ut_params.obuf); 5530 if (ut_paramz[j].ut_params.ibuf 5531 == ut_paramz[j].ut_params.obuf) 5532 ut_paramz[j].ut_params.ibuf = 0; 5533 ut_paramz[j].ut_params.obuf = 0; 5534 } 5535 if (ut_paramz[j].ut_params.ibuf) { 5536 rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf); 5537 ut_paramz[j].ut_params.ibuf = 0; 5538 } 5539 } 5540 5541 for (i = 0; i < MB_SESSION_NUMBER; i++) 5542 rte_cryptodev_sym_session_free(ts_params->valid_devs[0], 5543 sessions[i]); 5544 5545 rte_free(sessions); 5546 5547 return TEST_SUCCESS; 5548 } 5549 5550 static int 5551 test_null_cipher_only_operation(void) 5552 { 5553 struct crypto_testsuite_params *ts_params = &testsuite_params; 5554 struct crypto_unittest_params *ut_params = &unittest_params; 5555 5556 /* Generate test mbuf data and space for digest */ 5557 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool, 5558 catch_22_quote, QUOTE_512_BYTES, 0); 5559 5560 /* Setup Cipher Parameters */ 5561 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 5562 ut_params->cipher_xform.next = NULL; 5563 5564 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL; 5565 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; 5566 5567 /* Create Crypto session*/ 5568 ut_params->sess = rte_cryptodev_sym_session_create( 5569 ts_params->valid_devs[0], &ut_params->cipher_xform); 5570 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 5571 5572 /* Generate Crypto op data structure */ 5573 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 5574 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 5575 TEST_ASSERT_NOT_NULL(ut_params->op, 5576 "Failed to allocate symmetric crypto operation struct"); 5577 5578 /* Set crypto operation data parameters */ 5579 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 5580 5581 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 5582 5583 /* set crypto operation source mbuf */ 5584 sym_op->m_src = ut_params->ibuf; 5585 5586 sym_op->cipher.data.offset = 0; 5587 sym_op->cipher.data.length = QUOTE_512_BYTES; 5588 5589 /* Process crypto operation */ 5590 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 5591 ut_params->op); 5592 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned"); 5593 5594 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 5595 "crypto operation processing failed"); 5596 5597 /* Validate obuf */ 5598 TEST_ASSERT_BUFFERS_ARE_EQUAL( 5599 rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *), 5600 catch_22_quote, 5601 QUOTE_512_BYTES, 5602 "Ciphertext data not as expected"); 5603 5604 return TEST_SUCCESS; 5605 } 5606 5607 static int 5608 test_null_auth_only_operation(void) 5609 { 5610 struct crypto_testsuite_params *ts_params = &testsuite_params; 5611 struct crypto_unittest_params *ut_params = &unittest_params; 5612 5613 /* Generate test mbuf data and space for digest */ 5614 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool, 5615 catch_22_quote, QUOTE_512_BYTES, 0); 5616 5617 /* Setup HMAC Parameters */ 5618 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 5619 ut_params->auth_xform.next = NULL; 5620 5621 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL; 5622 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; 5623 5624 /* Create Crypto session*/ 5625 ut_params->sess = rte_cryptodev_sym_session_create( 5626 ts_params->valid_devs[0], &ut_params->auth_xform); 5627 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 5628 5629 /* Generate Crypto op data structure */ 5630 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 5631 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 5632 TEST_ASSERT_NOT_NULL(ut_params->op, 5633 "Failed to allocate symmetric crypto operation struct"); 5634 5635 /* Set crypto operation data parameters */ 5636 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 5637 5638 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 5639 5640 sym_op->m_src = ut_params->ibuf; 5641 5642 sym_op->auth.data.offset = 0; 5643 sym_op->auth.data.length = QUOTE_512_BYTES; 5644 5645 /* Process crypto operation */ 5646 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 5647 ut_params->op); 5648 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned"); 5649 5650 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 5651 "crypto operation processing failed"); 5652 5653 return TEST_SUCCESS; 5654 } 5655 5656 static int 5657 test_null_cipher_auth_operation(void) 5658 { 5659 struct crypto_testsuite_params *ts_params = &testsuite_params; 5660 struct crypto_unittest_params *ut_params = &unittest_params; 5661 5662 /* Generate test mbuf data and space for digest */ 5663 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool, 5664 catch_22_quote, QUOTE_512_BYTES, 0); 5665 5666 /* Setup Cipher Parameters */ 5667 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 5668 ut_params->cipher_xform.next = &ut_params->auth_xform; 5669 5670 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL; 5671 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; 5672 5673 /* Setup HMAC Parameters */ 5674 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 5675 ut_params->auth_xform.next = NULL; 5676 5677 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL; 5678 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; 5679 5680 /* Create Crypto session*/ 5681 ut_params->sess = rte_cryptodev_sym_session_create( 5682 ts_params->valid_devs[0], &ut_params->cipher_xform); 5683 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 5684 5685 /* Generate Crypto op data structure */ 5686 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 5687 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 5688 TEST_ASSERT_NOT_NULL(ut_params->op, 5689 "Failed to allocate symmetric crypto operation struct"); 5690 5691 /* Set crypto operation data parameters */ 5692 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 5693 5694 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 5695 5696 sym_op->m_src = ut_params->ibuf; 5697 5698 sym_op->cipher.data.offset = 0; 5699 sym_op->cipher.data.length = QUOTE_512_BYTES; 5700 5701 sym_op->auth.data.offset = 0; 5702 sym_op->auth.data.length = QUOTE_512_BYTES; 5703 5704 /* Process crypto operation */ 5705 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 5706 ut_params->op); 5707 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned"); 5708 5709 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 5710 "crypto operation processing failed"); 5711 5712 /* Validate obuf */ 5713 TEST_ASSERT_BUFFERS_ARE_EQUAL( 5714 rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *), 5715 catch_22_quote, 5716 QUOTE_512_BYTES, 5717 "Ciphertext data not as expected"); 5718 5719 return TEST_SUCCESS; 5720 } 5721 5722 static int 5723 test_null_auth_cipher_operation(void) 5724 { 5725 struct crypto_testsuite_params *ts_params = &testsuite_params; 5726 struct crypto_unittest_params *ut_params = &unittest_params; 5727 5728 /* Generate test mbuf data and space for digest */ 5729 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool, 5730 catch_22_quote, QUOTE_512_BYTES, 0); 5731 5732 /* Setup Cipher Parameters */ 5733 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 5734 ut_params->cipher_xform.next = NULL; 5735 5736 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL; 5737 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; 5738 5739 /* Setup HMAC Parameters */ 5740 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 5741 ut_params->auth_xform.next = &ut_params->cipher_xform; 5742 5743 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL; 5744 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; 5745 5746 /* Create Crypto session*/ 5747 ut_params->sess = rte_cryptodev_sym_session_create( 5748 ts_params->valid_devs[0], &ut_params->cipher_xform); 5749 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 5750 5751 /* Generate Crypto op data structure */ 5752 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 5753 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 5754 TEST_ASSERT_NOT_NULL(ut_params->op, 5755 "Failed to allocate symmetric crypto operation struct"); 5756 5757 /* Set crypto operation data parameters */ 5758 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 5759 5760 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 5761 5762 sym_op->m_src = ut_params->ibuf; 5763 5764 sym_op->cipher.data.offset = 0; 5765 sym_op->cipher.data.length = QUOTE_512_BYTES; 5766 5767 sym_op->auth.data.offset = 0; 5768 sym_op->auth.data.length = QUOTE_512_BYTES; 5769 5770 /* Process crypto operation */ 5771 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 5772 ut_params->op); 5773 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned"); 5774 5775 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 5776 "crypto operation processing failed"); 5777 5778 /* Validate obuf */ 5779 TEST_ASSERT_BUFFERS_ARE_EQUAL( 5780 rte_pktmbuf_mtod(ut_params->op->sym->m_src, uint8_t *), 5781 catch_22_quote, 5782 QUOTE_512_BYTES, 5783 "Ciphertext data not as expected"); 5784 5785 return TEST_SUCCESS; 5786 } 5787 5788 5789 static int 5790 test_null_invalid_operation(void) 5791 { 5792 struct crypto_testsuite_params *ts_params = &testsuite_params; 5793 struct crypto_unittest_params *ut_params = &unittest_params; 5794 5795 /* Setup Cipher Parameters */ 5796 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 5797 ut_params->cipher_xform.next = NULL; 5798 5799 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC; 5800 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; 5801 5802 /* Create Crypto session*/ 5803 ut_params->sess = rte_cryptodev_sym_session_create( 5804 ts_params->valid_devs[0], &ut_params->cipher_xform); 5805 TEST_ASSERT_NULL(ut_params->sess, 5806 "Session creation succeeded unexpectedly"); 5807 5808 5809 /* Setup HMAC Parameters */ 5810 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 5811 ut_params->auth_xform.next = NULL; 5812 5813 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC; 5814 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; 5815 5816 /* Create Crypto session*/ 5817 ut_params->sess = rte_cryptodev_sym_session_create( 5818 ts_params->valid_devs[0], &ut_params->auth_xform); 5819 TEST_ASSERT_NULL(ut_params->sess, 5820 "Session creation succeeded unexpectedly"); 5821 5822 return TEST_SUCCESS; 5823 } 5824 5825 5826 #define NULL_BURST_LENGTH (32) 5827 5828 static int 5829 test_null_burst_operation(void) 5830 { 5831 struct crypto_testsuite_params *ts_params = &testsuite_params; 5832 struct crypto_unittest_params *ut_params = &unittest_params; 5833 5834 unsigned i, burst_len = NULL_BURST_LENGTH; 5835 5836 struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL }; 5837 struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL }; 5838 5839 /* Setup Cipher Parameters */ 5840 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 5841 ut_params->cipher_xform.next = &ut_params->auth_xform; 5842 5843 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL; 5844 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; 5845 5846 /* Setup HMAC Parameters */ 5847 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 5848 ut_params->auth_xform.next = NULL; 5849 5850 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL; 5851 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; 5852 5853 /* Create Crypto session*/ 5854 ut_params->sess = rte_cryptodev_sym_session_create( 5855 ts_params->valid_devs[0], &ut_params->cipher_xform); 5856 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 5857 5858 TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool, 5859 RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len), 5860 burst_len, "failed to generate burst of crypto ops"); 5861 5862 /* Generate an operation for each mbuf in burst */ 5863 for (i = 0; i < burst_len; i++) { 5864 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool); 5865 5866 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf"); 5867 5868 unsigned *data = (unsigned *)rte_pktmbuf_append(m, 5869 sizeof(unsigned)); 5870 *data = i; 5871 5872 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess); 5873 5874 burst[i]->sym->m_src = m; 5875 } 5876 5877 /* Process crypto operation */ 5878 TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0], 5879 0, burst, burst_len), 5880 burst_len, 5881 "Error enqueuing burst"); 5882 5883 TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0], 5884 0, burst_dequeued, burst_len), 5885 burst_len, 5886 "Error dequeuing burst"); 5887 5888 5889 for (i = 0; i < burst_len; i++) { 5890 TEST_ASSERT_EQUAL( 5891 *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *), 5892 *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src, 5893 uint32_t *), 5894 "data not as expected"); 5895 5896 rte_pktmbuf_free(burst[i]->sym->m_src); 5897 rte_crypto_op_free(burst[i]); 5898 } 5899 5900 return TEST_SUCCESS; 5901 } 5902 5903 static void 5904 generate_gmac_large_plaintext(uint8_t *data) 5905 { 5906 uint16_t i; 5907 5908 for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32) 5909 memcpy(&data[i], &data[0], 32); 5910 } 5911 5912 static int 5913 create_gmac_operation(enum rte_crypto_auth_operation op, 5914 const struct gmac_test_data *tdata) 5915 { 5916 struct crypto_testsuite_params *ts_params = &testsuite_params; 5917 struct crypto_unittest_params *ut_params = &unittest_params; 5918 struct rte_crypto_sym_op *sym_op; 5919 5920 unsigned iv_pad_len; 5921 unsigned aad_pad_len; 5922 5923 iv_pad_len = RTE_ALIGN_CEIL(tdata->iv.len, 16); 5924 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16); 5925 5926 /* 5927 * Runtime generate the large plain text instead of use hard code 5928 * plain text vector. It is done to avoid create huge source file 5929 * with the test vector. 5930 */ 5931 if (tdata->aad.len == GMAC_LARGE_PLAINTEXT_LENGTH) 5932 generate_gmac_large_plaintext(tdata->aad.data); 5933 5934 /* Generate Crypto op data structure */ 5935 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 5936 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 5937 TEST_ASSERT_NOT_NULL(ut_params->op, 5938 "Failed to allocate symmetric crypto operation struct"); 5939 5940 sym_op = ut_params->op->sym; 5941 sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 5942 aad_pad_len); 5943 TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data, 5944 "no room to append aad"); 5945 5946 sym_op->auth.aad.length = tdata->aad.len; 5947 sym_op->auth.aad.phys_addr = 5948 rte_pktmbuf_mtophys(ut_params->ibuf); 5949 memcpy(sym_op->auth.aad.data, tdata->aad.data, tdata->aad.len); 5950 5951 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( 5952 ut_params->ibuf, tdata->gmac_tag.len); 5953 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, 5954 "no room to append digest"); 5955 5956 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( 5957 ut_params->ibuf, aad_pad_len); 5958 sym_op->auth.digest.length = tdata->gmac_tag.len; 5959 5960 if (op == RTE_CRYPTO_AUTH_OP_VERIFY) { 5961 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data, 5962 tdata->gmac_tag.len); 5963 TEST_HEXDUMP(stdout, "digest:", 5964 sym_op->auth.digest.data, 5965 sym_op->auth.digest.length); 5966 } 5967 5968 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend( 5969 ut_params->ibuf, iv_pad_len); 5970 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv"); 5971 5972 memset(sym_op->cipher.iv.data, 0, iv_pad_len); 5973 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); 5974 sym_op->cipher.iv.length = tdata->iv.len; 5975 5976 rte_memcpy(sym_op->cipher.iv.data, tdata->iv.data, tdata->iv.len); 5977 5978 TEST_HEXDUMP(stdout, "iv:", sym_op->cipher.iv.data, iv_pad_len); 5979 5980 sym_op->cipher.data.length = 0; 5981 sym_op->cipher.data.offset = 0; 5982 5983 sym_op->auth.data.offset = 0; 5984 sym_op->auth.data.length = 0; 5985 5986 return 0; 5987 } 5988 5989 static int create_gmac_session(uint8_t dev_id, 5990 enum rte_crypto_cipher_operation op, 5991 const struct gmac_test_data *tdata, 5992 enum rte_crypto_auth_operation auth_op) 5993 { 5994 uint8_t cipher_key[tdata->key.len]; 5995 5996 struct crypto_unittest_params *ut_params = &unittest_params; 5997 5998 memcpy(cipher_key, tdata->key.data, tdata->key.len); 5999 6000 /* For GMAC we setup cipher parameters */ 6001 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 6002 ut_params->cipher_xform.next = NULL; 6003 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_GCM; 6004 ut_params->cipher_xform.cipher.op = op; 6005 ut_params->cipher_xform.cipher.key.data = cipher_key; 6006 ut_params->cipher_xform.cipher.key.length = tdata->key.len; 6007 6008 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 6009 ut_params->auth_xform.next = NULL; 6010 6011 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC; 6012 ut_params->auth_xform.auth.op = auth_op; 6013 ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len; 6014 ut_params->auth_xform.auth.add_auth_data_length = 0; 6015 ut_params->auth_xform.auth.key.length = 0; 6016 ut_params->auth_xform.auth.key.data = NULL; 6017 6018 ut_params->cipher_xform.next = &ut_params->auth_xform; 6019 6020 ut_params->sess = rte_cryptodev_sym_session_create(dev_id, 6021 &ut_params->cipher_xform); 6022 6023 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 6024 6025 return 0; 6026 } 6027 6028 static int 6029 test_AES_GMAC_authentication(const struct gmac_test_data *tdata) 6030 { 6031 struct crypto_testsuite_params *ts_params = &testsuite_params; 6032 struct crypto_unittest_params *ut_params = &unittest_params; 6033 6034 int retval; 6035 6036 uint8_t *auth_tag, *p; 6037 uint16_t aad_pad_len; 6038 6039 TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0, 6040 "No GMAC length in the source data"); 6041 6042 retval = create_gmac_session(ts_params->valid_devs[0], 6043 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 6044 tdata, RTE_CRYPTO_AUTH_OP_GENERATE); 6045 6046 if (retval < 0) 6047 return retval; 6048 6049 if (tdata->aad.len > MBUF_SIZE) 6050 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool); 6051 else 6052 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 6053 TEST_ASSERT_NOT_NULL(ut_params->ibuf, 6054 "Failed to allocate input buffer in mempool"); 6055 6056 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 6057 rte_pktmbuf_tailroom(ut_params->ibuf)); 6058 6059 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16); 6060 6061 p = rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *); 6062 6063 retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE, 6064 tdata); 6065 6066 if (retval < 0) 6067 return retval; 6068 6069 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 6070 6071 ut_params->op->sym->m_src = ut_params->ibuf; 6072 6073 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], 6074 ut_params->op), "failed to process sym crypto op"); 6075 6076 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 6077 "crypto op processing failed"); 6078 6079 if (ut_params->op->sym->m_dst) { 6080 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst, 6081 uint8_t *, aad_pad_len); 6082 } else { 6083 auth_tag = p + aad_pad_len; 6084 } 6085 6086 TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len); 6087 6088 TEST_ASSERT_BUFFERS_ARE_EQUAL( 6089 auth_tag, 6090 tdata->gmac_tag.data, 6091 tdata->gmac_tag.len, 6092 "GMAC Generated auth tag not as expected"); 6093 6094 return 0; 6095 } 6096 6097 static int 6098 test_AES_GMAC_authentication_test_case_1(void) 6099 { 6100 return test_AES_GMAC_authentication(&gmac_test_case_1); 6101 } 6102 6103 static int 6104 test_AES_GMAC_authentication_test_case_2(void) 6105 { 6106 return test_AES_GMAC_authentication(&gmac_test_case_2); 6107 } 6108 6109 static int 6110 test_AES_GMAC_authentication_test_case_3(void) 6111 { 6112 return test_AES_GMAC_authentication(&gmac_test_case_3); 6113 } 6114 6115 static int 6116 test_AES_GMAC_authentication_test_case_4(void) 6117 { 6118 return test_AES_GMAC_authentication(&gmac_test_case_4); 6119 } 6120 6121 static int 6122 test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata) 6123 { 6124 struct crypto_testsuite_params *ts_params = &testsuite_params; 6125 struct crypto_unittest_params *ut_params = &unittest_params; 6126 int retval; 6127 6128 TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0, 6129 "No GMAC length in the source data"); 6130 6131 retval = create_gmac_session(ts_params->valid_devs[0], 6132 RTE_CRYPTO_CIPHER_OP_DECRYPT, 6133 tdata, RTE_CRYPTO_AUTH_OP_VERIFY); 6134 6135 if (retval < 0) 6136 return retval; 6137 6138 if (tdata->aad.len > MBUF_SIZE) 6139 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool); 6140 else 6141 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 6142 TEST_ASSERT_NOT_NULL(ut_params->ibuf, 6143 "Failed to allocate input buffer in mempool"); 6144 6145 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 6146 rte_pktmbuf_tailroom(ut_params->ibuf)); 6147 6148 retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY, 6149 tdata); 6150 6151 if (retval < 0) 6152 return retval; 6153 6154 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 6155 6156 ut_params->op->sym->m_src = ut_params->ibuf; 6157 6158 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], 6159 ut_params->op), "failed to process sym crypto op"); 6160 6161 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 6162 "crypto op processing failed"); 6163 6164 return 0; 6165 6166 } 6167 6168 static int 6169 test_AES_GMAC_authentication_verify_test_case_1(void) 6170 { 6171 return test_AES_GMAC_authentication_verify(&gmac_test_case_1); 6172 } 6173 6174 static int 6175 test_AES_GMAC_authentication_verify_test_case_2(void) 6176 { 6177 return test_AES_GMAC_authentication_verify(&gmac_test_case_2); 6178 } 6179 6180 static int 6181 test_AES_GMAC_authentication_verify_test_case_3(void) 6182 { 6183 return test_AES_GMAC_authentication_verify(&gmac_test_case_3); 6184 } 6185 6186 static int 6187 test_AES_GMAC_authentication_verify_test_case_4(void) 6188 { 6189 return test_AES_GMAC_authentication_verify(&gmac_test_case_4); 6190 } 6191 6192 struct test_crypto_vector { 6193 enum rte_crypto_cipher_algorithm crypto_algo; 6194 6195 struct { 6196 uint8_t data[64]; 6197 unsigned int len; 6198 } cipher_key; 6199 6200 struct { 6201 uint8_t data[64]; 6202 unsigned int len; 6203 } iv; 6204 6205 struct { 6206 const uint8_t *data; 6207 unsigned int len; 6208 } plaintext; 6209 6210 struct { 6211 const uint8_t *data; 6212 unsigned int len; 6213 } ciphertext; 6214 6215 enum rte_crypto_auth_algorithm auth_algo; 6216 6217 struct { 6218 uint8_t data[128]; 6219 unsigned int len; 6220 } auth_key; 6221 6222 struct { 6223 const uint8_t *data; 6224 unsigned int len; 6225 } aad; 6226 6227 struct { 6228 uint8_t data[128]; 6229 unsigned int len; 6230 } digest; 6231 }; 6232 6233 static const struct test_crypto_vector 6234 hmac_sha1_test_crypto_vector = { 6235 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC, 6236 .plaintext = { 6237 .data = plaintext_hash, 6238 .len = 512 6239 }, 6240 .auth_key = { 6241 .data = { 6242 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA, 6243 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD, 6244 0xDE, 0xF4, 0xDE, 0xAD 6245 }, 6246 .len = 20 6247 }, 6248 .digest = { 6249 .data = { 6250 0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77, 6251 0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17, 6252 0x3F, 0x91, 0x64, 0x59 6253 }, 6254 .len = 20 6255 } 6256 }; 6257 6258 static const struct test_crypto_vector 6259 aes128_gmac_test_vector = { 6260 .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC, 6261 .crypto_algo = RTE_CRYPTO_CIPHER_AES_GCM, 6262 .aad = { 6263 .data = plaintext_hash, 6264 .len = 512 6265 }, 6266 .iv = { 6267 .data = { 6268 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 6269 0x08, 0x09, 0x0A, 0x0B 6270 }, 6271 .len = 12 6272 }, 6273 .cipher_key = { 6274 .data = { 6275 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1, 6276 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA 6277 }, 6278 .len = 16 6279 }, 6280 .digest = { 6281 .data = { 6282 0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56, 6283 0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A 6284 }, 6285 .len = 16 6286 } 6287 }; 6288 6289 static const struct test_crypto_vector 6290 aes128cbc_hmac_sha1_test_vector = { 6291 .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC, 6292 .cipher_key = { 6293 .data = { 6294 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2, 6295 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A 6296 }, 6297 .len = 16 6298 }, 6299 .iv = { 6300 .data = { 6301 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 6302 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F 6303 }, 6304 .len = 16 6305 }, 6306 .plaintext = { 6307 .data = plaintext_hash, 6308 .len = 512 6309 }, 6310 .ciphertext = { 6311 .data = ciphertext512_aes128cbc, 6312 .len = 512 6313 }, 6314 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC, 6315 .auth_key = { 6316 .data = { 6317 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA, 6318 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD, 6319 0xDE, 0xF4, 0xDE, 0xAD 6320 }, 6321 .len = 20 6322 }, 6323 .digest = { 6324 .data = { 6325 0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60, 6326 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1, 6327 0x18, 0x8C, 0x1D, 0x32 6328 }, 6329 .len = 20 6330 } 6331 }; 6332 6333 static void 6334 data_corruption(uint8_t *data) 6335 { 6336 data[0] += 1; 6337 } 6338 6339 static void 6340 tag_corruption(uint8_t *data, unsigned int tag_offset) 6341 { 6342 data[tag_offset] += 1; 6343 } 6344 6345 static int 6346 create_auth_session(struct crypto_unittest_params *ut_params, 6347 uint8_t dev_id, 6348 const struct test_crypto_vector *reference, 6349 enum rte_crypto_auth_operation auth_op) 6350 { 6351 uint8_t auth_key[reference->auth_key.len + 1]; 6352 6353 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len); 6354 6355 /* Setup Authentication Parameters */ 6356 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 6357 ut_params->auth_xform.auth.op = auth_op; 6358 ut_params->auth_xform.next = NULL; 6359 ut_params->auth_xform.auth.algo = reference->auth_algo; 6360 ut_params->auth_xform.auth.key.length = reference->auth_key.len; 6361 ut_params->auth_xform.auth.key.data = auth_key; 6362 ut_params->auth_xform.auth.digest_length = reference->digest.len; 6363 ut_params->auth_xform.auth.add_auth_data_length = reference->aad.len; 6364 6365 /* Create Crypto session*/ 6366 ut_params->sess = rte_cryptodev_sym_session_create(dev_id, 6367 &ut_params->auth_xform); 6368 6369 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 6370 6371 return 0; 6372 } 6373 6374 static int 6375 create_auth_cipher_session(struct crypto_unittest_params *ut_params, 6376 uint8_t dev_id, 6377 const struct test_crypto_vector *reference, 6378 enum rte_crypto_auth_operation auth_op, 6379 enum rte_crypto_cipher_operation cipher_op) 6380 { 6381 uint8_t cipher_key[reference->cipher_key.len + 1]; 6382 uint8_t auth_key[reference->auth_key.len + 1]; 6383 6384 memcpy(cipher_key, reference->cipher_key.data, 6385 reference->cipher_key.len); 6386 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len); 6387 6388 /* Setup Authentication Parameters */ 6389 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 6390 ut_params->auth_xform.auth.op = auth_op; 6391 ut_params->auth_xform.next = &ut_params->cipher_xform; 6392 ut_params->auth_xform.auth.algo = reference->auth_algo; 6393 ut_params->auth_xform.auth.key.length = reference->auth_key.len; 6394 ut_params->auth_xform.auth.key.data = auth_key; 6395 ut_params->auth_xform.auth.digest_length = reference->digest.len; 6396 ut_params->auth_xform.auth.add_auth_data_length = reference->aad.len; 6397 6398 /* Setup Cipher Parameters */ 6399 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 6400 ut_params->cipher_xform.next = NULL; 6401 ut_params->cipher_xform.cipher.algo = reference->crypto_algo; 6402 ut_params->cipher_xform.cipher.op = cipher_op; 6403 ut_params->cipher_xform.cipher.key.data = cipher_key; 6404 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len; 6405 6406 /* Create Crypto session*/ 6407 ut_params->sess = rte_cryptodev_sym_session_create(dev_id, 6408 &ut_params->auth_xform); 6409 6410 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 6411 6412 return 0; 6413 } 6414 6415 static int 6416 create_auth_operation(struct crypto_testsuite_params *ts_params, 6417 struct crypto_unittest_params *ut_params, 6418 const struct test_crypto_vector *reference, 6419 unsigned int auth_generate) 6420 { 6421 /* Generate Crypto op data structure */ 6422 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 6423 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 6424 TEST_ASSERT_NOT_NULL(ut_params->op, 6425 "Failed to allocate pktmbuf offload"); 6426 6427 /* Set crypto operation data parameters */ 6428 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 6429 6430 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 6431 6432 /* set crypto operation source mbuf */ 6433 sym_op->m_src = ut_params->ibuf; 6434 6435 /* digest */ 6436 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( 6437 ut_params->ibuf, reference->digest.len); 6438 6439 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, 6440 "no room to append auth tag"); 6441 6442 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( 6443 ut_params->ibuf, reference->plaintext.len); 6444 sym_op->auth.digest.length = reference->digest.len; 6445 6446 if (auth_generate) 6447 memset(sym_op->auth.digest.data, 0, reference->digest.len); 6448 else 6449 memcpy(sym_op->auth.digest.data, 6450 reference->digest.data, 6451 reference->digest.len); 6452 6453 TEST_HEXDUMP(stdout, "digest:", 6454 sym_op->auth.digest.data, 6455 sym_op->auth.digest.length); 6456 6457 sym_op->auth.data.length = reference->plaintext.len; 6458 sym_op->auth.data.offset = 0; 6459 6460 return 0; 6461 } 6462 6463 static int 6464 create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params, 6465 struct crypto_unittest_params *ut_params, 6466 const struct test_crypto_vector *reference, 6467 unsigned int auth_generate) 6468 { 6469 /* Generate Crypto op data structure */ 6470 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 6471 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 6472 TEST_ASSERT_NOT_NULL(ut_params->op, 6473 "Failed to allocate pktmbuf offload"); 6474 6475 /* Set crypto operation data parameters */ 6476 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 6477 6478 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 6479 6480 /* set crypto operation source mbuf */ 6481 sym_op->m_src = ut_params->ibuf; 6482 6483 /* aad */ 6484 sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 6485 reference->aad.len); 6486 TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data, "no room to append AAD"); 6487 memcpy(sym_op->auth.aad.data, reference->aad.data, reference->aad.len); 6488 6489 TEST_HEXDUMP(stdout, "AAD:", sym_op->auth.aad.data, reference->aad.len); 6490 6491 sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); 6492 sym_op->auth.aad.length = reference->aad.len; 6493 6494 /* digest */ 6495 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( 6496 ut_params->ibuf, reference->digest.len); 6497 6498 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, 6499 "no room to append auth tag"); 6500 6501 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( 6502 ut_params->ibuf, reference->ciphertext.len); 6503 sym_op->auth.digest.length = reference->digest.len; 6504 6505 if (auth_generate) 6506 memset(sym_op->auth.digest.data, 0, reference->digest.len); 6507 else 6508 memcpy(sym_op->auth.digest.data, 6509 reference->digest.data, 6510 reference->digest.len); 6511 6512 TEST_HEXDUMP(stdout, "digest:", 6513 sym_op->auth.digest.data, 6514 sym_op->auth.digest.length); 6515 6516 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend( 6517 ut_params->ibuf, reference->iv.len); 6518 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv"); 6519 6520 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); 6521 sym_op->cipher.iv.length = reference->iv.len; 6522 6523 memcpy(sym_op->cipher.iv.data, reference->iv.data, reference->iv.len); 6524 6525 sym_op->cipher.data.length = 0; 6526 sym_op->cipher.data.offset = 0; 6527 6528 sym_op->auth.data.length = 0; 6529 sym_op->auth.data.offset = 0; 6530 6531 return 0; 6532 } 6533 6534 static int 6535 create_cipher_auth_operation(struct crypto_testsuite_params *ts_params, 6536 struct crypto_unittest_params *ut_params, 6537 const struct test_crypto_vector *reference, 6538 unsigned int auth_generate) 6539 { 6540 /* Generate Crypto op data structure */ 6541 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 6542 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 6543 TEST_ASSERT_NOT_NULL(ut_params->op, 6544 "Failed to allocate pktmbuf offload"); 6545 6546 /* Set crypto operation data parameters */ 6547 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 6548 6549 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 6550 6551 /* set crypto operation source mbuf */ 6552 sym_op->m_src = ut_params->ibuf; 6553 6554 /* digest */ 6555 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( 6556 ut_params->ibuf, reference->digest.len); 6557 6558 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, 6559 "no room to append auth tag"); 6560 6561 sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( 6562 ut_params->ibuf, reference->ciphertext.len); 6563 sym_op->auth.digest.length = reference->digest.len; 6564 6565 if (auth_generate) 6566 memset(sym_op->auth.digest.data, 0, reference->digest.len); 6567 else 6568 memcpy(sym_op->auth.digest.data, 6569 reference->digest.data, 6570 reference->digest.len); 6571 6572 TEST_HEXDUMP(stdout, "digest:", 6573 sym_op->auth.digest.data, 6574 sym_op->auth.digest.length); 6575 6576 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend( 6577 ut_params->ibuf, reference->iv.len); 6578 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, "no room to prepend iv"); 6579 6580 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); 6581 sym_op->cipher.iv.length = reference->iv.len; 6582 6583 memcpy(sym_op->cipher.iv.data, reference->iv.data, reference->iv.len); 6584 6585 sym_op->cipher.data.length = reference->ciphertext.len; 6586 sym_op->cipher.data.offset = reference->iv.len; 6587 6588 sym_op->auth.data.length = reference->ciphertext.len; 6589 sym_op->auth.data.offset = reference->iv.len; 6590 6591 return 0; 6592 } 6593 6594 static int 6595 create_auth_verify_operation(struct crypto_testsuite_params *ts_params, 6596 struct crypto_unittest_params *ut_params, 6597 const struct test_crypto_vector *reference) 6598 { 6599 return create_auth_operation(ts_params, ut_params, reference, 0); 6600 } 6601 6602 static int 6603 create_auth_verify_GMAC_operation( 6604 struct crypto_testsuite_params *ts_params, 6605 struct crypto_unittest_params *ut_params, 6606 const struct test_crypto_vector *reference) 6607 { 6608 return create_auth_GMAC_operation(ts_params, ut_params, reference, 0); 6609 } 6610 6611 static int 6612 create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params, 6613 struct crypto_unittest_params *ut_params, 6614 const struct test_crypto_vector *reference) 6615 { 6616 return create_cipher_auth_operation(ts_params, ut_params, reference, 0); 6617 } 6618 6619 static int 6620 test_authentication_verify_fail_when_data_corruption( 6621 struct crypto_testsuite_params *ts_params, 6622 struct crypto_unittest_params *ut_params, 6623 const struct test_crypto_vector *reference, 6624 unsigned int data_corrupted) 6625 { 6626 int retval; 6627 6628 uint8_t *plaintext; 6629 6630 /* Create session */ 6631 retval = create_auth_session(ut_params, 6632 ts_params->valid_devs[0], 6633 reference, 6634 RTE_CRYPTO_AUTH_OP_VERIFY); 6635 if (retval < 0) 6636 return retval; 6637 6638 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 6639 TEST_ASSERT_NOT_NULL(ut_params->ibuf, 6640 "Failed to allocate input buffer in mempool"); 6641 6642 /* clear mbuf payload */ 6643 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 6644 rte_pktmbuf_tailroom(ut_params->ibuf)); 6645 6646 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 6647 reference->plaintext.len); 6648 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext"); 6649 memcpy(plaintext, reference->plaintext.data, reference->plaintext.len); 6650 6651 TEST_HEXDUMP(stdout, "plaintext:", plaintext, reference->plaintext.len); 6652 6653 /* Create operation */ 6654 retval = create_auth_verify_operation(ts_params, ut_params, reference); 6655 6656 if (retval < 0) 6657 return retval; 6658 6659 if (data_corrupted) 6660 data_corruption(plaintext); 6661 else 6662 tag_corruption(plaintext, reference->plaintext.len); 6663 6664 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 6665 ut_params->op); 6666 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process"); 6667 TEST_ASSERT_EQUAL(ut_params->op->status, 6668 RTE_CRYPTO_OP_STATUS_AUTH_FAILED, 6669 "authentication not failed"); 6670 6671 ut_params->obuf = ut_params->op->sym->m_src; 6672 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf"); 6673 6674 return 0; 6675 } 6676 6677 static int 6678 test_authentication_verify_GMAC_fail_when_corruption( 6679 struct crypto_testsuite_params *ts_params, 6680 struct crypto_unittest_params *ut_params, 6681 const struct test_crypto_vector *reference, 6682 unsigned int data_corrupted) 6683 { 6684 int retval; 6685 6686 /* Create session */ 6687 retval = create_auth_cipher_session(ut_params, 6688 ts_params->valid_devs[0], 6689 reference, 6690 RTE_CRYPTO_AUTH_OP_VERIFY, 6691 RTE_CRYPTO_CIPHER_OP_DECRYPT); 6692 if (retval < 0) 6693 return retval; 6694 6695 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 6696 TEST_ASSERT_NOT_NULL(ut_params->ibuf, 6697 "Failed to allocate input buffer in mempool"); 6698 6699 /* clear mbuf payload */ 6700 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 6701 rte_pktmbuf_tailroom(ut_params->ibuf)); 6702 6703 /* Create operation */ 6704 retval = create_auth_verify_GMAC_operation(ts_params, 6705 ut_params, 6706 reference); 6707 6708 if (retval < 0) 6709 return retval; 6710 6711 if (data_corrupted) 6712 data_corruption(ut_params->op->sym->auth.aad.data); 6713 else 6714 tag_corruption(ut_params->op->sym->auth.aad.data, 6715 reference->aad.len); 6716 6717 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 6718 ut_params->op); 6719 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process"); 6720 TEST_ASSERT_EQUAL(ut_params->op->status, 6721 RTE_CRYPTO_OP_STATUS_AUTH_FAILED, 6722 "authentication not failed"); 6723 6724 ut_params->obuf = ut_params->op->sym->m_src; 6725 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf"); 6726 6727 return 0; 6728 } 6729 6730 static int 6731 test_authenticated_decryption_fail_when_corruption( 6732 struct crypto_testsuite_params *ts_params, 6733 struct crypto_unittest_params *ut_params, 6734 const struct test_crypto_vector *reference, 6735 unsigned int data_corrupted) 6736 { 6737 int retval; 6738 6739 uint8_t *ciphertext; 6740 6741 /* Create session */ 6742 retval = create_auth_cipher_session(ut_params, 6743 ts_params->valid_devs[0], 6744 reference, 6745 RTE_CRYPTO_AUTH_OP_VERIFY, 6746 RTE_CRYPTO_CIPHER_OP_DECRYPT); 6747 if (retval < 0) 6748 return retval; 6749 6750 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 6751 TEST_ASSERT_NOT_NULL(ut_params->ibuf, 6752 "Failed to allocate input buffer in mempool"); 6753 6754 /* clear mbuf payload */ 6755 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 6756 rte_pktmbuf_tailroom(ut_params->ibuf)); 6757 6758 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 6759 reference->ciphertext.len); 6760 TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext"); 6761 memcpy(ciphertext, reference->ciphertext.data, 6762 reference->ciphertext.len); 6763 6764 /* Create operation */ 6765 retval = create_cipher_auth_verify_operation(ts_params, 6766 ut_params, 6767 reference); 6768 6769 if (retval < 0) 6770 return retval; 6771 6772 if (data_corrupted) 6773 data_corruption(ciphertext); 6774 else 6775 tag_corruption(ciphertext, reference->ciphertext.len); 6776 6777 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 6778 ut_params->op); 6779 6780 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process"); 6781 TEST_ASSERT_EQUAL(ut_params->op->status, 6782 RTE_CRYPTO_OP_STATUS_AUTH_FAILED, 6783 "authentication not failed"); 6784 6785 ut_params->obuf = ut_params->op->sym->m_src; 6786 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf"); 6787 6788 return 0; 6789 } 6790 6791 static int 6792 create_gcm_operation_SGL(enum rte_crypto_cipher_operation op, 6793 const struct gcm_test_data *tdata, 6794 void *digest_mem, uint64_t digest_phys) 6795 { 6796 struct crypto_testsuite_params *ts_params = &testsuite_params; 6797 struct crypto_unittest_params *ut_params = &unittest_params; 6798 6799 const unsigned int auth_tag_len = tdata->auth_tag.len; 6800 const unsigned int iv_len = tdata->iv.len; 6801 const unsigned int aad_len = tdata->aad.len; 6802 6803 unsigned int iv_pad_len = 0; 6804 6805 /* Generate Crypto op data structure */ 6806 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 6807 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 6808 TEST_ASSERT_NOT_NULL(ut_params->op, 6809 "Failed to allocate symmetric crypto operation struct"); 6810 6811 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 6812 6813 sym_op->auth.digest.data = digest_mem; 6814 6815 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, 6816 "no room to append digest"); 6817 6818 sym_op->auth.digest.phys_addr = digest_phys; 6819 sym_op->auth.digest.length = auth_tag_len; 6820 6821 if (op == RTE_CRYPTO_CIPHER_OP_DECRYPT) { 6822 rte_memcpy(sym_op->auth.digest.data, tdata->auth_tag.data, 6823 auth_tag_len); 6824 TEST_HEXDUMP(stdout, "digest:", 6825 sym_op->auth.digest.data, 6826 sym_op->auth.digest.length); 6827 } 6828 6829 iv_pad_len = RTE_ALIGN_CEIL(iv_len, 16); 6830 6831 sym_op->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend( 6832 ut_params->ibuf, iv_pad_len); 6833 6834 TEST_ASSERT_NOT_NULL(sym_op->cipher.iv.data, 6835 "no room to prepend iv"); 6836 6837 memset(sym_op->cipher.iv.data, 0, iv_pad_len); 6838 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf); 6839 sym_op->cipher.iv.length = iv_len; 6840 6841 rte_memcpy(sym_op->cipher.iv.data, tdata->iv.data, iv_pad_len); 6842 6843 sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend( 6844 ut_params->ibuf, aad_len); 6845 TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data, 6846 "no room to prepend aad"); 6847 sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys( 6848 ut_params->ibuf); 6849 sym_op->auth.aad.length = aad_len; 6850 6851 memset(sym_op->auth.aad.data, 0, aad_len); 6852 rte_memcpy(sym_op->auth.aad.data, tdata->aad.data, aad_len); 6853 6854 TEST_HEXDUMP(stdout, "iv:", sym_op->cipher.iv.data, iv_pad_len); 6855 TEST_HEXDUMP(stdout, "aad:", 6856 sym_op->auth.aad.data, aad_len); 6857 6858 sym_op->cipher.data.length = tdata->plaintext.len; 6859 sym_op->cipher.data.offset = aad_len + iv_pad_len; 6860 6861 sym_op->auth.data.offset = aad_len + iv_pad_len; 6862 sym_op->auth.data.length = tdata->plaintext.len; 6863 6864 return 0; 6865 } 6866 6867 #define SGL_MAX_NO 16 6868 6869 static int 6870 test_AES_GCM_authenticated_encryption_SGL(const struct gcm_test_data *tdata, 6871 const int oop, uint32_t fragsz, uint32_t fragsz_oop) 6872 { 6873 struct crypto_testsuite_params *ts_params = &testsuite_params; 6874 struct crypto_unittest_params *ut_params = &unittest_params; 6875 struct rte_mbuf *buf, *buf_oop = NULL, *buf_last_oop = NULL; 6876 int retval; 6877 int to_trn = 0; 6878 int to_trn_tbl[SGL_MAX_NO]; 6879 int segs = 1; 6880 unsigned int trn_data = 0; 6881 uint8_t *plaintext, *ciphertext, *auth_tag; 6882 6883 if (fragsz > tdata->plaintext.len) 6884 fragsz = tdata->plaintext.len; 6885 6886 uint16_t plaintext_len = fragsz; 6887 uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz; 6888 6889 if (fragsz_oop > tdata->plaintext.len) 6890 frag_size_oop = tdata->plaintext.len; 6891 6892 int ecx = 0; 6893 void *digest_mem = NULL; 6894 6895 uint32_t prepend_len = ALIGN_POW2_ROUNDUP(tdata->iv.len, 16) 6896 + tdata->aad.len; 6897 6898 if (tdata->plaintext.len % fragsz != 0) { 6899 if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO) 6900 return 1; 6901 } else { 6902 if (tdata->plaintext.len / fragsz > SGL_MAX_NO) 6903 return 1; 6904 } 6905 6906 /* 6907 * For out-op-place we need to alloc another mbuf 6908 */ 6909 if (oop) { 6910 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 6911 rte_pktmbuf_append(ut_params->obuf, 6912 frag_size_oop + prepend_len); 6913 buf_oop = ut_params->obuf; 6914 } 6915 6916 /* Create GCM session */ 6917 retval = create_gcm_session(ts_params->valid_devs[0], 6918 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 6919 tdata->key.data, tdata->key.len, 6920 tdata->aad.len, tdata->auth_tag.len, 6921 RTE_CRYPTO_AUTH_OP_GENERATE); 6922 if (retval < 0) 6923 return retval; 6924 6925 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 6926 6927 /* clear mbuf payload */ 6928 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 6929 rte_pktmbuf_tailroom(ut_params->ibuf)); 6930 6931 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 6932 plaintext_len); 6933 6934 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 6935 6936 trn_data += plaintext_len; 6937 6938 buf = ut_params->ibuf; 6939 6940 /* 6941 * Loop until no more fragments 6942 */ 6943 6944 while (trn_data < tdata->plaintext.len) { 6945 ++segs; 6946 to_trn = (tdata->plaintext.len - trn_data < fragsz) ? 6947 (tdata->plaintext.len - trn_data) : fragsz; 6948 6949 to_trn_tbl[ecx++] = to_trn; 6950 6951 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool); 6952 buf = buf->next; 6953 6954 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0, 6955 rte_pktmbuf_tailroom(buf)); 6956 6957 /* OOP */ 6958 if (oop && !fragsz_oop) { 6959 buf_last_oop = buf_oop->next = 6960 rte_pktmbuf_alloc(ts_params->mbuf_pool); 6961 buf_oop = buf_oop->next; 6962 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *), 6963 0, rte_pktmbuf_tailroom(buf_oop)); 6964 rte_pktmbuf_append(buf_oop, to_trn); 6965 } 6966 6967 plaintext = (uint8_t *)rte_pktmbuf_append(buf, 6968 to_trn); 6969 6970 memcpy(plaintext, tdata->plaintext.data + trn_data, 6971 to_trn); 6972 trn_data += to_trn; 6973 if (trn_data == tdata->plaintext.len) { 6974 if (oop) { 6975 if (!fragsz_oop) 6976 digest_mem = rte_pktmbuf_append(buf_oop, 6977 tdata->auth_tag.len); 6978 } else 6979 digest_mem = (uint8_t *)rte_pktmbuf_append(buf, 6980 tdata->auth_tag.len); 6981 } 6982 } 6983 6984 uint64_t digest_phys = 0; 6985 6986 ut_params->ibuf->nb_segs = segs; 6987 6988 segs = 1; 6989 if (fragsz_oop && oop) { 6990 to_trn = 0; 6991 ecx = 0; 6992 6993 if (frag_size_oop == tdata->plaintext.len) { 6994 digest_mem = rte_pktmbuf_append(ut_params->obuf, 6995 tdata->auth_tag.len); 6996 6997 digest_phys = rte_pktmbuf_mtophys_offset( 6998 ut_params->obuf, 6999 tdata->plaintext.len + prepend_len); 7000 } 7001 7002 trn_data = frag_size_oop; 7003 while (trn_data < tdata->plaintext.len) { 7004 ++segs; 7005 to_trn = 7006 (tdata->plaintext.len - trn_data < 7007 frag_size_oop) ? 7008 (tdata->plaintext.len - trn_data) : 7009 frag_size_oop; 7010 7011 to_trn_tbl[ecx++] = to_trn; 7012 7013 buf_last_oop = buf_oop->next = 7014 rte_pktmbuf_alloc(ts_params->mbuf_pool); 7015 buf_oop = buf_oop->next; 7016 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *), 7017 0, rte_pktmbuf_tailroom(buf_oop)); 7018 rte_pktmbuf_append(buf_oop, to_trn); 7019 7020 trn_data += to_trn; 7021 7022 if (trn_data == tdata->plaintext.len) { 7023 digest_mem = rte_pktmbuf_append(buf_oop, 7024 tdata->auth_tag.len); 7025 } 7026 } 7027 7028 ut_params->obuf->nb_segs = segs; 7029 } 7030 7031 /* 7032 * Place digest at the end of the last buffer 7033 */ 7034 if (!digest_phys) 7035 digest_phys = rte_pktmbuf_mtophys(buf) + to_trn; 7036 if (oop && buf_last_oop) 7037 digest_phys = rte_pktmbuf_mtophys(buf_last_oop) + to_trn; 7038 7039 if (!digest_mem && !oop) { 7040 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 7041 + tdata->auth_tag.len); 7042 digest_phys = rte_pktmbuf_mtophys_offset(ut_params->ibuf, 7043 tdata->plaintext.len); 7044 } 7045 7046 /* Create GCM opertaion */ 7047 retval = create_gcm_operation_SGL(RTE_CRYPTO_CIPHER_OP_ENCRYPT, 7048 tdata, digest_mem, digest_phys); 7049 7050 if (retval < 0) 7051 return retval; 7052 7053 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 7054 7055 ut_params->op->sym->m_src = ut_params->ibuf; 7056 if (oop) 7057 ut_params->op->sym->m_dst = ut_params->obuf; 7058 7059 /* Process crypto operation */ 7060 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], 7061 ut_params->op), "failed to process sym crypto op"); 7062 7063 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 7064 "crypto op processing failed"); 7065 7066 7067 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src, 7068 uint8_t *, prepend_len); 7069 if (oop) { 7070 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst, 7071 uint8_t *, prepend_len); 7072 } 7073 7074 if (fragsz_oop) 7075 fragsz = fragsz_oop; 7076 7077 TEST_ASSERT_BUFFERS_ARE_EQUAL( 7078 ciphertext, 7079 tdata->ciphertext.data, 7080 fragsz, 7081 "GCM Ciphertext data not as expected"); 7082 7083 buf = ut_params->op->sym->m_src->next; 7084 if (oop) 7085 buf = ut_params->op->sym->m_dst->next; 7086 7087 unsigned int off = fragsz; 7088 7089 ecx = 0; 7090 while (buf) { 7091 ciphertext = rte_pktmbuf_mtod(buf, 7092 uint8_t *); 7093 7094 TEST_ASSERT_BUFFERS_ARE_EQUAL( 7095 ciphertext, 7096 tdata->ciphertext.data + off, 7097 to_trn_tbl[ecx], 7098 "GCM Ciphertext data not as expected"); 7099 7100 off += to_trn_tbl[ecx++]; 7101 buf = buf->next; 7102 } 7103 7104 auth_tag = digest_mem; 7105 TEST_ASSERT_BUFFERS_ARE_EQUAL( 7106 auth_tag, 7107 tdata->auth_tag.data, 7108 tdata->auth_tag.len, 7109 "GCM Generated auth tag not as expected"); 7110 7111 return 0; 7112 } 7113 7114 #define IN_PLACE 0 7115 #define OUT_OF_PLACE 1 7116 7117 static int 7118 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void) 7119 { 7120 return test_AES_GCM_authenticated_encryption_SGL( 7121 &gcm_test_case_SGL_1, OUT_OF_PLACE, 400, 400); 7122 } 7123 7124 static int 7125 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B(void) 7126 { 7127 return test_AES_GCM_authenticated_encryption_SGL( 7128 &gcm_test_case_SGL_1, OUT_OF_PLACE, 1500, 2000); 7129 } 7130 7131 static int 7132 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void) 7133 { 7134 return test_AES_GCM_authenticated_encryption_SGL( 7135 &gcm_test_case_8, OUT_OF_PLACE, 400, 7136 gcm_test_case_8.plaintext.len); 7137 } 7138 7139 static int 7140 test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void) 7141 { 7142 7143 return test_AES_GCM_authenticated_encryption_SGL( 7144 &gcm_test_case_SGL_1, IN_PLACE, 1500, 0); 7145 } 7146 7147 static int 7148 test_authentication_verify_fail_when_data_corrupted( 7149 struct crypto_testsuite_params *ts_params, 7150 struct crypto_unittest_params *ut_params, 7151 const struct test_crypto_vector *reference) 7152 { 7153 return test_authentication_verify_fail_when_data_corruption( 7154 ts_params, ut_params, reference, 1); 7155 } 7156 7157 static int 7158 test_authentication_verify_fail_when_tag_corrupted( 7159 struct crypto_testsuite_params *ts_params, 7160 struct crypto_unittest_params *ut_params, 7161 const struct test_crypto_vector *reference) 7162 { 7163 return test_authentication_verify_fail_when_data_corruption( 7164 ts_params, ut_params, reference, 0); 7165 } 7166 7167 static int 7168 test_authentication_verify_GMAC_fail_when_data_corrupted( 7169 struct crypto_testsuite_params *ts_params, 7170 struct crypto_unittest_params *ut_params, 7171 const struct test_crypto_vector *reference) 7172 { 7173 return test_authentication_verify_GMAC_fail_when_corruption( 7174 ts_params, ut_params, reference, 1); 7175 } 7176 7177 static int 7178 test_authentication_verify_GMAC_fail_when_tag_corrupted( 7179 struct crypto_testsuite_params *ts_params, 7180 struct crypto_unittest_params *ut_params, 7181 const struct test_crypto_vector *reference) 7182 { 7183 return test_authentication_verify_GMAC_fail_when_corruption( 7184 ts_params, ut_params, reference, 0); 7185 } 7186 7187 static int 7188 test_authenticated_decryption_fail_when_data_corrupted( 7189 struct crypto_testsuite_params *ts_params, 7190 struct crypto_unittest_params *ut_params, 7191 const struct test_crypto_vector *reference) 7192 { 7193 return test_authenticated_decryption_fail_when_corruption( 7194 ts_params, ut_params, reference, 1); 7195 } 7196 7197 static int 7198 test_authenticated_decryption_fail_when_tag_corrupted( 7199 struct crypto_testsuite_params *ts_params, 7200 struct crypto_unittest_params *ut_params, 7201 const struct test_crypto_vector *reference) 7202 { 7203 return test_authenticated_decryption_fail_when_corruption( 7204 ts_params, ut_params, reference, 0); 7205 } 7206 7207 static int 7208 authentication_verify_HMAC_SHA1_fail_data_corrupt(void) 7209 { 7210 return test_authentication_verify_fail_when_data_corrupted( 7211 &testsuite_params, &unittest_params, 7212 &hmac_sha1_test_crypto_vector); 7213 } 7214 7215 static int 7216 authentication_verify_HMAC_SHA1_fail_tag_corrupt(void) 7217 { 7218 return test_authentication_verify_fail_when_tag_corrupted( 7219 &testsuite_params, &unittest_params, 7220 &hmac_sha1_test_crypto_vector); 7221 } 7222 7223 static int 7224 authentication_verify_AES128_GMAC_fail_data_corrupt(void) 7225 { 7226 return test_authentication_verify_GMAC_fail_when_data_corrupted( 7227 &testsuite_params, &unittest_params, 7228 &aes128_gmac_test_vector); 7229 } 7230 7231 static int 7232 authentication_verify_AES128_GMAC_fail_tag_corrupt(void) 7233 { 7234 return test_authentication_verify_GMAC_fail_when_tag_corrupted( 7235 &testsuite_params, &unittest_params, 7236 &aes128_gmac_test_vector); 7237 } 7238 7239 static int 7240 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void) 7241 { 7242 return test_authenticated_decryption_fail_when_data_corrupted( 7243 &testsuite_params, 7244 &unittest_params, 7245 &aes128cbc_hmac_sha1_test_vector); 7246 } 7247 7248 static int 7249 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void) 7250 { 7251 return test_authenticated_decryption_fail_when_tag_corrupted( 7252 &testsuite_params, 7253 &unittest_params, 7254 &aes128cbc_hmac_sha1_test_vector); 7255 } 7256 7257 static struct unit_test_suite cryptodev_qat_testsuite = { 7258 .suite_name = "Crypto QAT Unit Test Suite", 7259 .setup = testsuite_setup, 7260 .teardown = testsuite_teardown, 7261 .unit_test_cases = { 7262 TEST_CASE_ST(ut_setup, ut_teardown, 7263 test_device_configure_invalid_dev_id), 7264 TEST_CASE_ST(ut_setup, ut_teardown, 7265 test_device_configure_invalid_queue_pair_ids), 7266 TEST_CASE_ST(ut_setup, ut_teardown, 7267 test_queue_pair_descriptor_setup), 7268 TEST_CASE_ST(ut_setup, ut_teardown, 7269 test_multi_session), 7270 7271 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_qat_all), 7272 TEST_CASE_ST(ut_setup, ut_teardown, 7273 test_AES_cipheronly_qat_all), 7274 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_qat_all), 7275 TEST_CASE_ST(ut_setup, ut_teardown, 7276 test_3DES_cipheronly_qat_all), 7277 TEST_CASE_ST(ut_setup, ut_teardown, 7278 test_DES_cipheronly_qat_all), 7279 TEST_CASE_ST(ut_setup, ut_teardown, test_stats), 7280 7281 /** AES GCM Authenticated Encryption */ 7282 TEST_CASE_ST(ut_setup, ut_teardown, 7283 test_AES_GCM_auth_encrypt_SGL_in_place_1500B), 7284 TEST_CASE_ST(ut_setup, ut_teardown, 7285 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B), 7286 TEST_CASE_ST(ut_setup, ut_teardown, 7287 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B), 7288 TEST_CASE_ST(ut_setup, ut_teardown, 7289 test_mb_AES_GCM_authenticated_encryption_test_case_1), 7290 TEST_CASE_ST(ut_setup, ut_teardown, 7291 test_mb_AES_GCM_authenticated_encryption_test_case_2), 7292 TEST_CASE_ST(ut_setup, ut_teardown, 7293 test_mb_AES_GCM_authenticated_encryption_test_case_3), 7294 TEST_CASE_ST(ut_setup, ut_teardown, 7295 test_mb_AES_GCM_authenticated_encryption_test_case_4), 7296 TEST_CASE_ST(ut_setup, ut_teardown, 7297 test_mb_AES_GCM_authenticated_encryption_test_case_5), 7298 TEST_CASE_ST(ut_setup, ut_teardown, 7299 test_mb_AES_GCM_authenticated_encryption_test_case_6), 7300 TEST_CASE_ST(ut_setup, ut_teardown, 7301 test_mb_AES_GCM_authenticated_encryption_test_case_7), 7302 7303 /** AES GCM Authenticated Decryption */ 7304 TEST_CASE_ST(ut_setup, ut_teardown, 7305 test_mb_AES_GCM_authenticated_decryption_test_case_1), 7306 TEST_CASE_ST(ut_setup, ut_teardown, 7307 test_mb_AES_GCM_authenticated_decryption_test_case_2), 7308 TEST_CASE_ST(ut_setup, ut_teardown, 7309 test_mb_AES_GCM_authenticated_decryption_test_case_3), 7310 TEST_CASE_ST(ut_setup, ut_teardown, 7311 test_mb_AES_GCM_authenticated_decryption_test_case_4), 7312 TEST_CASE_ST(ut_setup, ut_teardown, 7313 test_mb_AES_GCM_authenticated_decryption_test_case_5), 7314 TEST_CASE_ST(ut_setup, ut_teardown, 7315 test_mb_AES_GCM_authenticated_decryption_test_case_6), 7316 TEST_CASE_ST(ut_setup, ut_teardown, 7317 test_mb_AES_GCM_authenticated_decryption_test_case_7), 7318 7319 /** AES GMAC Authentication */ 7320 TEST_CASE_ST(ut_setup, ut_teardown, 7321 test_AES_GMAC_authentication_test_case_1), 7322 TEST_CASE_ST(ut_setup, ut_teardown, 7323 test_AES_GMAC_authentication_verify_test_case_1), 7324 TEST_CASE_ST(ut_setup, ut_teardown, 7325 test_AES_GMAC_authentication_test_case_2), 7326 TEST_CASE_ST(ut_setup, ut_teardown, 7327 test_AES_GMAC_authentication_verify_test_case_2), 7328 TEST_CASE_ST(ut_setup, ut_teardown, 7329 test_AES_GMAC_authentication_test_case_3), 7330 TEST_CASE_ST(ut_setup, ut_teardown, 7331 test_AES_GMAC_authentication_verify_test_case_3), 7332 7333 /** SNOW 3G encrypt only (UEA2) */ 7334 TEST_CASE_ST(ut_setup, ut_teardown, 7335 test_snow3g_encryption_test_case_1), 7336 TEST_CASE_ST(ut_setup, ut_teardown, 7337 test_snow3g_encryption_test_case_2), 7338 TEST_CASE_ST(ut_setup, ut_teardown, 7339 test_snow3g_encryption_test_case_3), 7340 TEST_CASE_ST(ut_setup, ut_teardown, 7341 test_snow3g_encryption_test_case_4), 7342 TEST_CASE_ST(ut_setup, ut_teardown, 7343 test_snow3g_encryption_test_case_5), 7344 7345 TEST_CASE_ST(ut_setup, ut_teardown, 7346 test_snow3g_encryption_test_case_1_oop), 7347 TEST_CASE_ST(ut_setup, ut_teardown, 7348 test_snow3g_decryption_test_case_1_oop), 7349 7350 /** SNOW 3G decrypt only (UEA2) */ 7351 TEST_CASE_ST(ut_setup, ut_teardown, 7352 test_snow3g_decryption_test_case_1), 7353 TEST_CASE_ST(ut_setup, ut_teardown, 7354 test_snow3g_decryption_test_case_2), 7355 TEST_CASE_ST(ut_setup, ut_teardown, 7356 test_snow3g_decryption_test_case_3), 7357 TEST_CASE_ST(ut_setup, ut_teardown, 7358 test_snow3g_decryption_test_case_4), 7359 TEST_CASE_ST(ut_setup, ut_teardown, 7360 test_snow3g_decryption_test_case_5), 7361 TEST_CASE_ST(ut_setup, ut_teardown, 7362 test_snow3g_hash_generate_test_case_1), 7363 TEST_CASE_ST(ut_setup, ut_teardown, 7364 test_snow3g_hash_generate_test_case_2), 7365 TEST_CASE_ST(ut_setup, ut_teardown, 7366 test_snow3g_hash_generate_test_case_3), 7367 TEST_CASE_ST(ut_setup, ut_teardown, 7368 test_snow3g_hash_verify_test_case_1), 7369 TEST_CASE_ST(ut_setup, ut_teardown, 7370 test_snow3g_hash_verify_test_case_2), 7371 TEST_CASE_ST(ut_setup, ut_teardown, 7372 test_snow3g_hash_verify_test_case_3), 7373 TEST_CASE_ST(ut_setup, ut_teardown, 7374 test_snow3g_cipher_auth_test_case_1), 7375 TEST_CASE_ST(ut_setup, ut_teardown, 7376 test_snow3g_auth_cipher_test_case_1), 7377 7378 /** HMAC_MD5 Authentication */ 7379 TEST_CASE_ST(ut_setup, ut_teardown, 7380 test_MD5_HMAC_generate_case_1), 7381 TEST_CASE_ST(ut_setup, ut_teardown, 7382 test_MD5_HMAC_verify_case_1), 7383 TEST_CASE_ST(ut_setup, ut_teardown, 7384 test_MD5_HMAC_generate_case_2), 7385 TEST_CASE_ST(ut_setup, ut_teardown, 7386 test_MD5_HMAC_verify_case_2), 7387 7388 /** NULL tests */ 7389 TEST_CASE_ST(ut_setup, ut_teardown, 7390 test_null_auth_only_operation), 7391 TEST_CASE_ST(ut_setup, ut_teardown, 7392 test_null_cipher_only_operation), 7393 TEST_CASE_ST(ut_setup, ut_teardown, 7394 test_null_cipher_auth_operation), 7395 TEST_CASE_ST(ut_setup, ut_teardown, 7396 test_null_auth_cipher_operation), 7397 7398 TEST_CASE_ST(ut_setup, ut_teardown, 7399 test_kasumi_hash_generate_test_case_6), 7400 7401 /** KASUMI tests */ 7402 TEST_CASE_ST(ut_setup, ut_teardown, 7403 test_kasumi_encryption_test_case_1), 7404 TEST_CASE_ST(ut_setup, ut_teardown, 7405 test_kasumi_encryption_test_case_3), 7406 TEST_CASE_ST(ut_setup, ut_teardown, 7407 test_kasumi_auth_cipher_test_case_1), 7408 TEST_CASE_ST(ut_setup, ut_teardown, 7409 test_kasumi_cipher_auth_test_case_1), 7410 7411 /** Negative tests */ 7412 TEST_CASE_ST(ut_setup, ut_teardown, 7413 authentication_verify_HMAC_SHA1_fail_data_corrupt), 7414 TEST_CASE_ST(ut_setup, ut_teardown, 7415 authentication_verify_HMAC_SHA1_fail_tag_corrupt), 7416 TEST_CASE_ST(ut_setup, ut_teardown, 7417 authentication_verify_AES128_GMAC_fail_data_corrupt), 7418 TEST_CASE_ST(ut_setup, ut_teardown, 7419 authentication_verify_AES128_GMAC_fail_tag_corrupt), 7420 TEST_CASE_ST(ut_setup, ut_teardown, 7421 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt), 7422 TEST_CASE_ST(ut_setup, ut_teardown, 7423 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt), 7424 7425 TEST_CASES_END() /**< NULL terminate unit test array */ 7426 } 7427 }; 7428 7429 static struct unit_test_suite cryptodev_aesni_mb_testsuite = { 7430 .suite_name = "Crypto Device AESNI MB Unit Test Suite", 7431 .setup = testsuite_setup, 7432 .teardown = testsuite_teardown, 7433 .unit_test_cases = { 7434 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_mb_all), 7435 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_mb_all), 7436 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_mb_all), 7437 7438 TEST_CASES_END() /**< NULL terminate unit test array */ 7439 } 7440 }; 7441 7442 static struct unit_test_suite cryptodev_openssl_testsuite = { 7443 .suite_name = "Crypto Device OPENSSL Unit Test Suite", 7444 .setup = testsuite_setup, 7445 .teardown = testsuite_teardown, 7446 .unit_test_cases = { 7447 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session), 7448 TEST_CASE_ST(ut_setup, ut_teardown, 7449 test_multi_session_random_usage), 7450 TEST_CASE_ST(ut_setup, ut_teardown, 7451 test_AES_chain_openssl_all), 7452 TEST_CASE_ST(ut_setup, ut_teardown, 7453 test_AES_cipheronly_openssl_all), 7454 TEST_CASE_ST(ut_setup, ut_teardown, 7455 test_3DES_chain_openssl_all), 7456 TEST_CASE_ST(ut_setup, ut_teardown, 7457 test_3DES_cipheronly_openssl_all), 7458 TEST_CASE_ST(ut_setup, ut_teardown, 7459 test_authonly_openssl_all), 7460 7461 /** AES GCM Authenticated Encryption */ 7462 TEST_CASE_ST(ut_setup, ut_teardown, 7463 test_mb_AES_GCM_authenticated_encryption_test_case_1), 7464 TEST_CASE_ST(ut_setup, ut_teardown, 7465 test_mb_AES_GCM_authenticated_encryption_test_case_2), 7466 TEST_CASE_ST(ut_setup, ut_teardown, 7467 test_mb_AES_GCM_authenticated_encryption_test_case_3), 7468 TEST_CASE_ST(ut_setup, ut_teardown, 7469 test_mb_AES_GCM_authenticated_encryption_test_case_4), 7470 TEST_CASE_ST(ut_setup, ut_teardown, 7471 test_mb_AES_GCM_authenticated_encryption_test_case_5), 7472 TEST_CASE_ST(ut_setup, ut_teardown, 7473 test_mb_AES_GCM_authenticated_encryption_test_case_6), 7474 TEST_CASE_ST(ut_setup, ut_teardown, 7475 test_mb_AES_GCM_authenticated_encryption_test_case_7), 7476 7477 /** AES GCM Authenticated Decryption */ 7478 TEST_CASE_ST(ut_setup, ut_teardown, 7479 test_mb_AES_GCM_authenticated_decryption_test_case_1), 7480 TEST_CASE_ST(ut_setup, ut_teardown, 7481 test_mb_AES_GCM_authenticated_decryption_test_case_2), 7482 TEST_CASE_ST(ut_setup, ut_teardown, 7483 test_mb_AES_GCM_authenticated_decryption_test_case_3), 7484 TEST_CASE_ST(ut_setup, ut_teardown, 7485 test_mb_AES_GCM_authenticated_decryption_test_case_4), 7486 TEST_CASE_ST(ut_setup, ut_teardown, 7487 test_mb_AES_GCM_authenticated_decryption_test_case_5), 7488 TEST_CASE_ST(ut_setup, ut_teardown, 7489 test_mb_AES_GCM_authenticated_decryption_test_case_6), 7490 TEST_CASE_ST(ut_setup, ut_teardown, 7491 test_mb_AES_GCM_authenticated_decryption_test_case_7), 7492 7493 /** AES GMAC Authentication */ 7494 TEST_CASE_ST(ut_setup, ut_teardown, 7495 test_AES_GMAC_authentication_test_case_1), 7496 TEST_CASE_ST(ut_setup, ut_teardown, 7497 test_AES_GMAC_authentication_verify_test_case_1), 7498 TEST_CASE_ST(ut_setup, ut_teardown, 7499 test_AES_GMAC_authentication_test_case_2), 7500 TEST_CASE_ST(ut_setup, ut_teardown, 7501 test_AES_GMAC_authentication_verify_test_case_2), 7502 TEST_CASE_ST(ut_setup, ut_teardown, 7503 test_AES_GMAC_authentication_test_case_3), 7504 TEST_CASE_ST(ut_setup, ut_teardown, 7505 test_AES_GMAC_authentication_verify_test_case_3), 7506 TEST_CASE_ST(ut_setup, ut_teardown, 7507 test_AES_GMAC_authentication_test_case_4), 7508 TEST_CASE_ST(ut_setup, ut_teardown, 7509 test_AES_GMAC_authentication_verify_test_case_4), 7510 7511 /** Scatter-Gather */ 7512 TEST_CASE_ST(ut_setup, ut_teardown, 7513 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg), 7514 7515 /** Negative tests */ 7516 TEST_CASE_ST(ut_setup, ut_teardown, 7517 authentication_verify_HMAC_SHA1_fail_data_corrupt), 7518 TEST_CASE_ST(ut_setup, ut_teardown, 7519 authentication_verify_HMAC_SHA1_fail_tag_corrupt), 7520 TEST_CASE_ST(ut_setup, ut_teardown, 7521 authentication_verify_AES128_GMAC_fail_data_corrupt), 7522 TEST_CASE_ST(ut_setup, ut_teardown, 7523 authentication_verify_AES128_GMAC_fail_tag_corrupt), 7524 TEST_CASE_ST(ut_setup, ut_teardown, 7525 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt), 7526 TEST_CASE_ST(ut_setup, ut_teardown, 7527 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt), 7528 7529 TEST_CASES_END() /**< NULL terminate unit test array */ 7530 } 7531 }; 7532 7533 static struct unit_test_suite cryptodev_aesni_gcm_testsuite = { 7534 .suite_name = "Crypto Device AESNI GCM Unit Test Suite", 7535 .setup = testsuite_setup, 7536 .teardown = testsuite_teardown, 7537 .unit_test_cases = { 7538 /** AES GCM Authenticated Encryption */ 7539 TEST_CASE_ST(ut_setup, ut_teardown, 7540 test_mb_AES_GCM_authenticated_encryption_test_case_1), 7541 TEST_CASE_ST(ut_setup, ut_teardown, 7542 test_mb_AES_GCM_authenticated_encryption_test_case_2), 7543 TEST_CASE_ST(ut_setup, ut_teardown, 7544 test_mb_AES_GCM_authenticated_encryption_test_case_3), 7545 TEST_CASE_ST(ut_setup, ut_teardown, 7546 test_mb_AES_GCM_authenticated_encryption_test_case_4), 7547 TEST_CASE_ST(ut_setup, ut_teardown, 7548 test_mb_AES_GCM_authenticated_encryption_test_case_5), 7549 TEST_CASE_ST(ut_setup, ut_teardown, 7550 test_mb_AES_GCM_authenticated_encryption_test_case_6), 7551 TEST_CASE_ST(ut_setup, ut_teardown, 7552 test_mb_AES_GCM_authenticated_encryption_test_case_7), 7553 7554 /** AES GCM Authenticated Decryption */ 7555 TEST_CASE_ST(ut_setup, ut_teardown, 7556 test_mb_AES_GCM_authenticated_decryption_test_case_1), 7557 TEST_CASE_ST(ut_setup, ut_teardown, 7558 test_mb_AES_GCM_authenticated_decryption_test_case_2), 7559 TEST_CASE_ST(ut_setup, ut_teardown, 7560 test_mb_AES_GCM_authenticated_decryption_test_case_3), 7561 TEST_CASE_ST(ut_setup, ut_teardown, 7562 test_mb_AES_GCM_authenticated_decryption_test_case_4), 7563 TEST_CASE_ST(ut_setup, ut_teardown, 7564 test_mb_AES_GCM_authenticated_decryption_test_case_5), 7565 TEST_CASE_ST(ut_setup, ut_teardown, 7566 test_mb_AES_GCM_authenticated_decryption_test_case_6), 7567 TEST_CASE_ST(ut_setup, ut_teardown, 7568 test_mb_AES_GCM_authenticated_decryption_test_case_7), 7569 7570 /** AES GCM Authenticated Encryption 256 bits key */ 7571 TEST_CASE_ST(ut_setup, ut_teardown, 7572 test_mb_AES_GCM_auth_encryption_test_case_256_1), 7573 TEST_CASE_ST(ut_setup, ut_teardown, 7574 test_mb_AES_GCM_auth_encryption_test_case_256_2), 7575 TEST_CASE_ST(ut_setup, ut_teardown, 7576 test_mb_AES_GCM_auth_encryption_test_case_256_3), 7577 TEST_CASE_ST(ut_setup, ut_teardown, 7578 test_mb_AES_GCM_auth_encryption_test_case_256_4), 7579 TEST_CASE_ST(ut_setup, ut_teardown, 7580 test_mb_AES_GCM_auth_encryption_test_case_256_5), 7581 TEST_CASE_ST(ut_setup, ut_teardown, 7582 test_mb_AES_GCM_auth_encryption_test_case_256_6), 7583 TEST_CASE_ST(ut_setup, ut_teardown, 7584 test_mb_AES_GCM_auth_encryption_test_case_256_7), 7585 7586 /** AES GCM Authenticated Decryption 256 bits key */ 7587 TEST_CASE_ST(ut_setup, ut_teardown, 7588 test_mb_AES_GCM_auth_decryption_test_case_256_1), 7589 TEST_CASE_ST(ut_setup, ut_teardown, 7590 test_mb_AES_GCM_auth_decryption_test_case_256_2), 7591 TEST_CASE_ST(ut_setup, ut_teardown, 7592 test_mb_AES_GCM_auth_decryption_test_case_256_3), 7593 TEST_CASE_ST(ut_setup, ut_teardown, 7594 test_mb_AES_GCM_auth_decryption_test_case_256_4), 7595 TEST_CASE_ST(ut_setup, ut_teardown, 7596 test_mb_AES_GCM_auth_decryption_test_case_256_5), 7597 TEST_CASE_ST(ut_setup, ut_teardown, 7598 test_mb_AES_GCM_auth_decryption_test_case_256_6), 7599 TEST_CASE_ST(ut_setup, ut_teardown, 7600 test_mb_AES_GCM_auth_decryption_test_case_256_7), 7601 7602 /** AES GCM Authenticated Encryption big aad size */ 7603 TEST_CASE_ST(ut_setup, ut_teardown, 7604 test_mb_AES_GCM_auth_encryption_test_case_aad_1), 7605 TEST_CASE_ST(ut_setup, ut_teardown, 7606 test_mb_AES_GCM_auth_encryption_test_case_aad_2), 7607 7608 /** AES GCM Authenticated Decryption big aad size */ 7609 TEST_CASE_ST(ut_setup, ut_teardown, 7610 test_mb_AES_GCM_auth_decryption_test_case_aad_1), 7611 TEST_CASE_ST(ut_setup, ut_teardown, 7612 test_mb_AES_GCM_auth_decryption_test_case_aad_2), 7613 7614 /** AES GMAC Authentication */ 7615 TEST_CASE_ST(ut_setup, ut_teardown, 7616 test_AES_GMAC_authentication_test_case_1), 7617 TEST_CASE_ST(ut_setup, ut_teardown, 7618 test_AES_GMAC_authentication_verify_test_case_1), 7619 TEST_CASE_ST(ut_setup, ut_teardown, 7620 test_AES_GMAC_authentication_test_case_3), 7621 TEST_CASE_ST(ut_setup, ut_teardown, 7622 test_AES_GMAC_authentication_verify_test_case_3), 7623 TEST_CASE_ST(ut_setup, ut_teardown, 7624 test_AES_GMAC_authentication_test_case_4), 7625 TEST_CASE_ST(ut_setup, ut_teardown, 7626 test_AES_GMAC_authentication_verify_test_case_4), 7627 7628 /** Negative tests */ 7629 TEST_CASE_ST(ut_setup, ut_teardown, 7630 authentication_verify_AES128_GMAC_fail_data_corrupt), 7631 TEST_CASE_ST(ut_setup, ut_teardown, 7632 authentication_verify_AES128_GMAC_fail_tag_corrupt), 7633 7634 /** Out of place tests */ 7635 TEST_CASE_ST(ut_setup, ut_teardown, 7636 test_mb_AES_GCM_authenticated_encryption_oop), 7637 TEST_CASE_ST(ut_setup, ut_teardown, 7638 test_mb_AES_GCM_authenticated_decryption_oop), 7639 7640 /** Session-less tests */ 7641 TEST_CASE_ST(ut_setup, ut_teardown, 7642 test_mb_AES_GCM_authenticated_encryption_sessionless), 7643 TEST_CASE_ST(ut_setup, ut_teardown, 7644 test_mb_AES_GCM_authenticated_decryption_sessionless), 7645 7646 /** Scatter-Gather */ 7647 TEST_CASE_ST(ut_setup, ut_teardown, 7648 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg), 7649 7650 TEST_CASES_END() /**< NULL terminate unit test array */ 7651 } 7652 }; 7653 7654 static struct unit_test_suite cryptodev_sw_kasumi_testsuite = { 7655 .suite_name = "Crypto Device SW KASUMI Unit Test Suite", 7656 .setup = testsuite_setup, 7657 .teardown = testsuite_teardown, 7658 .unit_test_cases = { 7659 /** KASUMI encrypt only (UEA1) */ 7660 TEST_CASE_ST(ut_setup, ut_teardown, 7661 test_kasumi_encryption_test_case_1), 7662 TEST_CASE_ST(ut_setup, ut_teardown, 7663 test_kasumi_encryption_test_case_1_sgl), 7664 TEST_CASE_ST(ut_setup, ut_teardown, 7665 test_kasumi_encryption_test_case_2), 7666 TEST_CASE_ST(ut_setup, ut_teardown, 7667 test_kasumi_encryption_test_case_3), 7668 TEST_CASE_ST(ut_setup, ut_teardown, 7669 test_kasumi_encryption_test_case_4), 7670 TEST_CASE_ST(ut_setup, ut_teardown, 7671 test_kasumi_encryption_test_case_5), 7672 /** KASUMI decrypt only (UEA1) */ 7673 TEST_CASE_ST(ut_setup, ut_teardown, 7674 test_kasumi_decryption_test_case_1), 7675 TEST_CASE_ST(ut_setup, ut_teardown, 7676 test_kasumi_decryption_test_case_2), 7677 TEST_CASE_ST(ut_setup, ut_teardown, 7678 test_kasumi_decryption_test_case_3), 7679 TEST_CASE_ST(ut_setup, ut_teardown, 7680 test_kasumi_decryption_test_case_4), 7681 TEST_CASE_ST(ut_setup, ut_teardown, 7682 test_kasumi_decryption_test_case_5), 7683 7684 TEST_CASE_ST(ut_setup, ut_teardown, 7685 test_kasumi_encryption_test_case_1_oop), 7686 TEST_CASE_ST(ut_setup, ut_teardown, 7687 test_kasumi_encryption_test_case_1_oop_sgl), 7688 7689 7690 TEST_CASE_ST(ut_setup, ut_teardown, 7691 test_kasumi_decryption_test_case_1_oop), 7692 7693 /** KASUMI hash only (UIA1) */ 7694 TEST_CASE_ST(ut_setup, ut_teardown, 7695 test_kasumi_hash_generate_test_case_1), 7696 TEST_CASE_ST(ut_setup, ut_teardown, 7697 test_kasumi_hash_generate_test_case_2), 7698 TEST_CASE_ST(ut_setup, ut_teardown, 7699 test_kasumi_hash_generate_test_case_3), 7700 TEST_CASE_ST(ut_setup, ut_teardown, 7701 test_kasumi_hash_generate_test_case_4), 7702 TEST_CASE_ST(ut_setup, ut_teardown, 7703 test_kasumi_hash_generate_test_case_5), 7704 TEST_CASE_ST(ut_setup, ut_teardown, 7705 test_kasumi_hash_generate_test_case_6), 7706 TEST_CASE_ST(ut_setup, ut_teardown, 7707 test_kasumi_hash_verify_test_case_1), 7708 TEST_CASE_ST(ut_setup, ut_teardown, 7709 test_kasumi_hash_verify_test_case_2), 7710 TEST_CASE_ST(ut_setup, ut_teardown, 7711 test_kasumi_hash_verify_test_case_3), 7712 TEST_CASE_ST(ut_setup, ut_teardown, 7713 test_kasumi_hash_verify_test_case_4), 7714 TEST_CASE_ST(ut_setup, ut_teardown, 7715 test_kasumi_hash_verify_test_case_5), 7716 TEST_CASE_ST(ut_setup, ut_teardown, 7717 test_kasumi_auth_cipher_test_case_1), 7718 TEST_CASE_ST(ut_setup, ut_teardown, 7719 test_kasumi_cipher_auth_test_case_1), 7720 TEST_CASES_END() /**< NULL terminate unit test array */ 7721 } 7722 }; 7723 static struct unit_test_suite cryptodev_sw_snow3g_testsuite = { 7724 .suite_name = "Crypto Device SW SNOW 3G Unit Test Suite", 7725 .setup = testsuite_setup, 7726 .teardown = testsuite_teardown, 7727 .unit_test_cases = { 7728 /** SNOW 3G encrypt only (UEA2) */ 7729 TEST_CASE_ST(ut_setup, ut_teardown, 7730 test_snow3g_encryption_test_case_1), 7731 TEST_CASE_ST(ut_setup, ut_teardown, 7732 test_snow3g_encryption_test_case_2), 7733 TEST_CASE_ST(ut_setup, ut_teardown, 7734 test_snow3g_encryption_test_case_3), 7735 TEST_CASE_ST(ut_setup, ut_teardown, 7736 test_snow3g_encryption_test_case_4), 7737 TEST_CASE_ST(ut_setup, ut_teardown, 7738 test_snow3g_encryption_test_case_5), 7739 7740 TEST_CASE_ST(ut_setup, ut_teardown, 7741 test_snow3g_encryption_test_case_1_oop), 7742 TEST_CASE_ST(ut_setup, ut_teardown, 7743 test_snow3g_encryption_test_case_1_oop_sgl), 7744 TEST_CASE_ST(ut_setup, ut_teardown, 7745 test_snow3g_decryption_test_case_1_oop), 7746 7747 TEST_CASE_ST(ut_setup, ut_teardown, 7748 test_snow3g_encryption_test_case_1_offset_oop), 7749 7750 /** SNOW 3G decrypt only (UEA2) */ 7751 TEST_CASE_ST(ut_setup, ut_teardown, 7752 test_snow3g_decryption_test_case_1), 7753 TEST_CASE_ST(ut_setup, ut_teardown, 7754 test_snow3g_decryption_test_case_2), 7755 TEST_CASE_ST(ut_setup, ut_teardown, 7756 test_snow3g_decryption_test_case_3), 7757 TEST_CASE_ST(ut_setup, ut_teardown, 7758 test_snow3g_decryption_test_case_4), 7759 TEST_CASE_ST(ut_setup, ut_teardown, 7760 test_snow3g_decryption_test_case_5), 7761 TEST_CASE_ST(ut_setup, ut_teardown, 7762 test_snow3g_hash_generate_test_case_1), 7763 TEST_CASE_ST(ut_setup, ut_teardown, 7764 test_snow3g_hash_generate_test_case_2), 7765 TEST_CASE_ST(ut_setup, ut_teardown, 7766 test_snow3g_hash_generate_test_case_3), 7767 /* Tests with buffers which length is not byte-aligned */ 7768 TEST_CASE_ST(ut_setup, ut_teardown, 7769 test_snow3g_hash_generate_test_case_4), 7770 TEST_CASE_ST(ut_setup, ut_teardown, 7771 test_snow3g_hash_generate_test_case_5), 7772 TEST_CASE_ST(ut_setup, ut_teardown, 7773 test_snow3g_hash_generate_test_case_6), 7774 TEST_CASE_ST(ut_setup, ut_teardown, 7775 test_snow3g_hash_verify_test_case_1), 7776 TEST_CASE_ST(ut_setup, ut_teardown, 7777 test_snow3g_hash_verify_test_case_2), 7778 TEST_CASE_ST(ut_setup, ut_teardown, 7779 test_snow3g_hash_verify_test_case_3), 7780 /* Tests with buffers which length is not byte-aligned */ 7781 TEST_CASE_ST(ut_setup, ut_teardown, 7782 test_snow3g_hash_verify_test_case_4), 7783 TEST_CASE_ST(ut_setup, ut_teardown, 7784 test_snow3g_hash_verify_test_case_5), 7785 TEST_CASE_ST(ut_setup, ut_teardown, 7786 test_snow3g_hash_verify_test_case_6), 7787 TEST_CASE_ST(ut_setup, ut_teardown, 7788 test_snow3g_cipher_auth_test_case_1), 7789 TEST_CASE_ST(ut_setup, ut_teardown, 7790 test_snow3g_auth_cipher_test_case_1), 7791 7792 TEST_CASES_END() /**< NULL terminate unit test array */ 7793 } 7794 }; 7795 7796 static struct unit_test_suite cryptodev_sw_zuc_testsuite = { 7797 .suite_name = "Crypto Device SW ZUC Unit Test Suite", 7798 .setup = testsuite_setup, 7799 .teardown = testsuite_teardown, 7800 .unit_test_cases = { 7801 /** ZUC encrypt only (EEA3) */ 7802 TEST_CASE_ST(ut_setup, ut_teardown, 7803 test_zuc_encryption_test_case_1), 7804 TEST_CASE_ST(ut_setup, ut_teardown, 7805 test_zuc_encryption_test_case_2), 7806 TEST_CASE_ST(ut_setup, ut_teardown, 7807 test_zuc_encryption_test_case_3), 7808 TEST_CASE_ST(ut_setup, ut_teardown, 7809 test_zuc_encryption_test_case_4), 7810 TEST_CASE_ST(ut_setup, ut_teardown, 7811 test_zuc_encryption_test_case_5), 7812 TEST_CASE_ST(ut_setup, ut_teardown, 7813 test_zuc_hash_generate_test_case_1), 7814 TEST_CASE_ST(ut_setup, ut_teardown, 7815 test_zuc_hash_generate_test_case_2), 7816 TEST_CASE_ST(ut_setup, ut_teardown, 7817 test_zuc_hash_generate_test_case_3), 7818 TEST_CASE_ST(ut_setup, ut_teardown, 7819 test_zuc_hash_generate_test_case_4), 7820 TEST_CASE_ST(ut_setup, ut_teardown, 7821 test_zuc_hash_generate_test_case_5), 7822 TEST_CASE_ST(ut_setup, ut_teardown, 7823 test_zuc_encryption_test_case_6_sgl), 7824 TEST_CASES_END() /**< NULL terminate unit test array */ 7825 } 7826 }; 7827 7828 static struct unit_test_suite cryptodev_null_testsuite = { 7829 .suite_name = "Crypto Device NULL Unit Test Suite", 7830 .setup = testsuite_setup, 7831 .teardown = testsuite_teardown, 7832 .unit_test_cases = { 7833 TEST_CASE_ST(ut_setup, ut_teardown, 7834 test_null_auth_only_operation), 7835 TEST_CASE_ST(ut_setup, ut_teardown, 7836 test_null_cipher_only_operation), 7837 TEST_CASE_ST(ut_setup, ut_teardown, 7838 test_null_cipher_auth_operation), 7839 TEST_CASE_ST(ut_setup, ut_teardown, 7840 test_null_auth_cipher_operation), 7841 TEST_CASE_ST(ut_setup, ut_teardown, 7842 test_null_invalid_operation), 7843 TEST_CASE_ST(ut_setup, ut_teardown, 7844 test_null_burst_operation), 7845 7846 TEST_CASES_END() /**< NULL terminate unit test array */ 7847 } 7848 }; 7849 7850 static int 7851 test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/) 7852 { 7853 gbl_cryptodev_type = RTE_CRYPTODEV_QAT_SYM_PMD; 7854 return unit_test_suite_runner(&cryptodev_qat_testsuite); 7855 } 7856 7857 static int 7858 test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/) 7859 { 7860 gbl_cryptodev_type = RTE_CRYPTODEV_AESNI_MB_PMD; 7861 7862 return unit_test_suite_runner(&cryptodev_aesni_mb_testsuite); 7863 } 7864 7865 static int 7866 test_cryptodev_openssl(void) 7867 { 7868 gbl_cryptodev_type = RTE_CRYPTODEV_OPENSSL_PMD; 7869 7870 return unit_test_suite_runner(&cryptodev_openssl_testsuite); 7871 } 7872 7873 static int 7874 test_cryptodev_aesni_gcm(void) 7875 { 7876 gbl_cryptodev_type = RTE_CRYPTODEV_AESNI_GCM_PMD; 7877 7878 return unit_test_suite_runner(&cryptodev_aesni_gcm_testsuite); 7879 } 7880 7881 static int 7882 test_cryptodev_null(void) 7883 { 7884 gbl_cryptodev_type = RTE_CRYPTODEV_NULL_PMD; 7885 7886 return unit_test_suite_runner(&cryptodev_null_testsuite); 7887 } 7888 7889 static int 7890 test_cryptodev_sw_snow3g(void /*argv __rte_unused, int argc __rte_unused*/) 7891 { 7892 gbl_cryptodev_type = RTE_CRYPTODEV_SNOW3G_PMD; 7893 7894 return unit_test_suite_runner(&cryptodev_sw_snow3g_testsuite); 7895 } 7896 7897 static int 7898 test_cryptodev_sw_kasumi(void /*argv __rte_unused, int argc __rte_unused*/) 7899 { 7900 gbl_cryptodev_type = RTE_CRYPTODEV_KASUMI_PMD; 7901 7902 return unit_test_suite_runner(&cryptodev_sw_kasumi_testsuite); 7903 } 7904 7905 static int 7906 test_cryptodev_sw_zuc(void /*argv __rte_unused, int argc __rte_unused*/) 7907 { 7908 gbl_cryptodev_type = RTE_CRYPTODEV_ZUC_PMD; 7909 7910 return unit_test_suite_runner(&cryptodev_sw_zuc_testsuite); 7911 } 7912 7913 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat); 7914 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb); 7915 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl); 7916 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm); 7917 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null); 7918 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g); 7919 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi); 7920 REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc); 7921