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