1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2015-2020 Intel Corporation 3 * Copyright 2020 NXP 4 */ 5 6 #include <time.h> 7 8 #include <rte_common.h> 9 #include <rte_hexdump.h> 10 #include <rte_mbuf.h> 11 #include <rte_malloc.h> 12 #include <rte_memcpy.h> 13 #include <rte_pause.h> 14 #include <rte_bus_vdev.h> 15 #include <rte_ether.h> 16 17 #include <rte_crypto.h> 18 #include <rte_cryptodev.h> 19 #include <rte_ip.h> 20 #include <rte_string_fns.h> 21 #include <rte_tcp.h> 22 #include <rte_udp.h> 23 24 #ifdef RTE_CRYPTO_SCHEDULER 25 #include <rte_cryptodev_scheduler.h> 26 #include <rte_cryptodev_scheduler_operations.h> 27 #endif 28 29 #include <rte_lcore.h> 30 31 #include "test.h" 32 #include "test_cryptodev.h" 33 34 #include "test_cryptodev_blockcipher.h" 35 #include "test_cryptodev_aes_test_vectors.h" 36 #include "test_cryptodev_des_test_vectors.h" 37 #include "test_cryptodev_hash_test_vectors.h" 38 #include "test_cryptodev_kasumi_test_vectors.h" 39 #include "test_cryptodev_kasumi_hash_test_vectors.h" 40 #include "test_cryptodev_snow3g_test_vectors.h" 41 #include "test_cryptodev_snow3g_hash_test_vectors.h" 42 #include "test_cryptodev_zuc_test_vectors.h" 43 #include "test_cryptodev_aead_test_vectors.h" 44 #include "test_cryptodev_hmac_test_vectors.h" 45 #include "test_cryptodev_mixed_test_vectors.h" 46 #ifdef RTE_LIB_SECURITY 47 #include "test_cryptodev_security_ipsec.h" 48 #include "test_cryptodev_security_ipsec_test_vectors.h" 49 #include "test_cryptodev_security_pdcp_test_vectors.h" 50 #include "test_cryptodev_security_pdcp_sdap_test_vectors.h" 51 #include "test_cryptodev_security_pdcp_test_func.h" 52 #include "test_cryptodev_security_docsis_test_vectors.h" 53 54 #define SDAP_DISABLED 0 55 #define SDAP_ENABLED 1 56 #endif 57 58 #define VDEV_ARGS_SIZE 100 59 #define MAX_NB_SESSIONS 4 60 61 #define MAX_DRV_SERVICE_CTX_SIZE 256 62 63 #define MAX_RAW_DEQUEUE_COUNT 65535 64 65 #define IN_PLACE 0 66 #define OUT_OF_PLACE 1 67 68 static int gbl_driver_id; 69 70 static enum rte_security_session_action_type gbl_action_type = 71 RTE_SECURITY_ACTION_TYPE_NONE; 72 73 enum cryptodev_api_test_type global_api_test_type = CRYPTODEV_API_TEST; 74 75 struct crypto_unittest_params { 76 struct rte_crypto_sym_xform cipher_xform; 77 struct rte_crypto_sym_xform auth_xform; 78 struct rte_crypto_sym_xform aead_xform; 79 #ifdef RTE_LIB_SECURITY 80 struct rte_security_docsis_xform docsis_xform; 81 #endif 82 83 union { 84 struct rte_cryptodev_sym_session *sess; 85 #ifdef RTE_LIB_SECURITY 86 struct rte_security_session *sec_session; 87 #endif 88 }; 89 #ifdef RTE_LIB_SECURITY 90 enum rte_security_session_action_type type; 91 #endif 92 struct rte_crypto_op *op; 93 94 struct rte_mbuf *obuf, *ibuf; 95 96 uint8_t *digest; 97 }; 98 99 #define ALIGN_POW2_ROUNDUP(num, align) \ 100 (((num) + (align) - 1) & ~((align) - 1)) 101 102 #define ADD_STATIC_TESTSUITE(index, parent_ts, child_ts, num_child_ts) \ 103 for (j = 0; j < num_child_ts; index++, j++) \ 104 parent_ts.unit_test_suites[index] = child_ts[j] 105 106 #define ADD_BLOCKCIPHER_TESTSUITE(index, parent_ts, blk_types, num_blk_types) \ 107 for (j = 0; j < num_blk_types; index++, j++) \ 108 parent_ts.unit_test_suites[index] = \ 109 build_blockcipher_test_suite(blk_types[j]) 110 111 #define FREE_BLOCKCIPHER_TESTSUITE(index, parent_ts, num_blk_types) \ 112 for (j = index; j < index + num_blk_types; j++) \ 113 free_blockcipher_test_suite(parent_ts.unit_test_suites[j]) 114 115 /* 116 * Forward declarations. 117 */ 118 static int 119 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params( 120 struct crypto_unittest_params *ut_params, uint8_t *cipher_key, 121 uint8_t *hmac_key); 122 123 static int 124 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess, 125 struct crypto_unittest_params *ut_params, 126 struct crypto_testsuite_params *ts_param, 127 const uint8_t *cipher, 128 const uint8_t *digest, 129 const uint8_t *iv); 130 131 static int 132 security_proto_supported(enum rte_security_session_action_type action, 133 enum rte_security_session_protocol proto); 134 135 static int 136 dev_configure_and_start(uint64_t ff_disable); 137 138 static struct rte_mbuf * 139 setup_test_string(struct rte_mempool *mpool, 140 const char *string, size_t len, uint8_t blocksize) 141 { 142 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool); 143 size_t t_len = len - (blocksize ? (len % blocksize) : 0); 144 145 if (m) { 146 char *dst; 147 148 memset(m->buf_addr, 0, m->buf_len); 149 dst = rte_pktmbuf_append(m, t_len); 150 if (!dst) { 151 rte_pktmbuf_free(m); 152 return NULL; 153 } 154 if (string != NULL) 155 rte_memcpy(dst, string, t_len); 156 else 157 memset(dst, 0, t_len); 158 } 159 160 return m; 161 } 162 163 /* Get number of bytes in X bits (rounding up) */ 164 static uint32_t 165 ceil_byte_length(uint32_t num_bits) 166 { 167 if (num_bits % 8) 168 return ((num_bits >> 3) + 1); 169 else 170 return (num_bits >> 3); 171 } 172 173 static void 174 post_process_raw_dp_op(void *user_data, uint32_t index __rte_unused, 175 uint8_t is_op_success) 176 { 177 struct rte_crypto_op *op = user_data; 178 op->status = is_op_success ? RTE_CRYPTO_OP_STATUS_SUCCESS : 179 RTE_CRYPTO_OP_STATUS_ERROR; 180 } 181 182 void 183 process_sym_raw_dp_op(uint8_t dev_id, uint16_t qp_id, 184 struct rte_crypto_op *op, uint8_t is_cipher, uint8_t is_auth, 185 uint8_t len_in_bits, uint8_t cipher_iv_len) 186 { 187 struct rte_crypto_sym_op *sop = op->sym; 188 struct rte_crypto_op *ret_op = NULL; 189 struct rte_crypto_vec data_vec[UINT8_MAX]; 190 struct rte_crypto_va_iova_ptr cipher_iv, digest, aad_auth_iv; 191 union rte_crypto_sym_ofs ofs; 192 struct rte_crypto_sym_vec vec; 193 struct rte_crypto_sgl sgl; 194 uint32_t max_len; 195 union rte_cryptodev_session_ctx sess; 196 uint32_t count = 0; 197 struct rte_crypto_raw_dp_ctx *ctx; 198 uint32_t cipher_offset = 0, cipher_len = 0, auth_offset = 0, 199 auth_len = 0; 200 int32_t n; 201 uint32_t n_success; 202 int ctx_service_size; 203 int32_t status = 0; 204 int enqueue_status, dequeue_status; 205 206 ctx_service_size = rte_cryptodev_get_raw_dp_ctx_size(dev_id); 207 if (ctx_service_size < 0) { 208 op->status = RTE_CRYPTO_OP_STATUS_ERROR; 209 return; 210 } 211 212 ctx = malloc(ctx_service_size); 213 if (!ctx) { 214 op->status = RTE_CRYPTO_OP_STATUS_ERROR; 215 return; 216 } 217 218 /* Both are enums, setting crypto_sess will suit any session type */ 219 sess.crypto_sess = op->sym->session; 220 221 if (rte_cryptodev_configure_raw_dp_ctx(dev_id, qp_id, ctx, 222 op->sess_type, sess, 0) < 0) { 223 op->status = RTE_CRYPTO_OP_STATUS_ERROR; 224 goto exit; 225 } 226 227 cipher_iv.iova = 0; 228 cipher_iv.va = NULL; 229 aad_auth_iv.iova = 0; 230 aad_auth_iv.va = NULL; 231 digest.iova = 0; 232 digest.va = NULL; 233 sgl.vec = data_vec; 234 vec.num = 1; 235 vec.sgl = &sgl; 236 vec.iv = &cipher_iv; 237 vec.digest = &digest; 238 vec.aad = &aad_auth_iv; 239 vec.status = &status; 240 241 ofs.raw = 0; 242 243 if (is_cipher && is_auth) { 244 cipher_offset = sop->cipher.data.offset; 245 cipher_len = sop->cipher.data.length; 246 auth_offset = sop->auth.data.offset; 247 auth_len = sop->auth.data.length; 248 max_len = RTE_MAX(cipher_offset + cipher_len, 249 auth_offset + auth_len); 250 if (len_in_bits) { 251 max_len = max_len >> 3; 252 cipher_offset = cipher_offset >> 3; 253 auth_offset = auth_offset >> 3; 254 cipher_len = cipher_len >> 3; 255 auth_len = auth_len >> 3; 256 } 257 ofs.ofs.cipher.head = cipher_offset; 258 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len; 259 ofs.ofs.auth.head = auth_offset; 260 ofs.ofs.auth.tail = max_len - auth_offset - auth_len; 261 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET); 262 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET); 263 aad_auth_iv.va = rte_crypto_op_ctod_offset( 264 op, void *, IV_OFFSET + cipher_iv_len); 265 aad_auth_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET + 266 cipher_iv_len); 267 digest.va = (void *)sop->auth.digest.data; 268 digest.iova = sop->auth.digest.phys_addr; 269 270 } else if (is_cipher) { 271 cipher_offset = sop->cipher.data.offset; 272 cipher_len = sop->cipher.data.length; 273 max_len = cipher_len + cipher_offset; 274 if (len_in_bits) { 275 max_len = max_len >> 3; 276 cipher_offset = cipher_offset >> 3; 277 cipher_len = cipher_len >> 3; 278 } 279 ofs.ofs.cipher.head = cipher_offset; 280 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len; 281 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET); 282 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET); 283 284 } else if (is_auth) { 285 auth_offset = sop->auth.data.offset; 286 auth_len = sop->auth.data.length; 287 max_len = auth_len + auth_offset; 288 if (len_in_bits) { 289 max_len = max_len >> 3; 290 auth_offset = auth_offset >> 3; 291 auth_len = auth_len >> 3; 292 } 293 ofs.ofs.auth.head = auth_offset; 294 ofs.ofs.auth.tail = max_len - auth_offset - auth_len; 295 aad_auth_iv.va = rte_crypto_op_ctod_offset( 296 op, void *, IV_OFFSET + cipher_iv_len); 297 aad_auth_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET + 298 cipher_iv_len); 299 digest.va = (void *)sop->auth.digest.data; 300 digest.iova = sop->auth.digest.phys_addr; 301 302 } else { /* aead */ 303 cipher_offset = sop->aead.data.offset; 304 cipher_len = sop->aead.data.length; 305 max_len = cipher_len + cipher_offset; 306 if (len_in_bits) { 307 max_len = max_len >> 3; 308 cipher_offset = cipher_offset >> 3; 309 cipher_len = cipher_len >> 3; 310 } 311 ofs.ofs.cipher.head = cipher_offset; 312 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len; 313 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET); 314 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET); 315 aad_auth_iv.va = (void *)sop->aead.aad.data; 316 aad_auth_iv.iova = sop->aead.aad.phys_addr; 317 digest.va = (void *)sop->aead.digest.data; 318 digest.iova = sop->aead.digest.phys_addr; 319 } 320 321 n = rte_crypto_mbuf_to_vec(sop->m_src, 0, max_len, 322 data_vec, RTE_DIM(data_vec)); 323 if (n < 0 || n > sop->m_src->nb_segs) { 324 op->status = RTE_CRYPTO_OP_STATUS_ERROR; 325 goto exit; 326 } 327 328 sgl.num = n; 329 330 if (rte_cryptodev_raw_enqueue_burst(ctx, &vec, ofs, (void **)&op, 331 &enqueue_status) < 1) { 332 op->status = RTE_CRYPTO_OP_STATUS_ERROR; 333 goto exit; 334 } 335 336 if (enqueue_status == 0) { 337 status = rte_cryptodev_raw_enqueue_done(ctx, 1); 338 if (status < 0) { 339 op->status = RTE_CRYPTO_OP_STATUS_ERROR; 340 goto exit; 341 } 342 } else if (enqueue_status < 0) { 343 op->status = RTE_CRYPTO_OP_STATUS_ERROR; 344 goto exit; 345 } 346 347 n = n_success = 0; 348 while (count++ < MAX_RAW_DEQUEUE_COUNT && n == 0) { 349 n = rte_cryptodev_raw_dequeue_burst(ctx, 350 NULL, 1, post_process_raw_dp_op, 351 (void **)&ret_op, 0, &n_success, 352 &dequeue_status); 353 if (dequeue_status < 0) { 354 op->status = RTE_CRYPTO_OP_STATUS_ERROR; 355 goto exit; 356 } 357 if (n == 0) 358 rte_pause(); 359 } 360 361 if (n == 1 && dequeue_status == 0) { 362 if (rte_cryptodev_raw_dequeue_done(ctx, 1) < 0) { 363 op->status = RTE_CRYPTO_OP_STATUS_ERROR; 364 goto exit; 365 } 366 } 367 368 op->status = (count == MAX_RAW_DEQUEUE_COUNT + 1 || ret_op != op || 369 n_success < 1) ? RTE_CRYPTO_OP_STATUS_ERROR : 370 RTE_CRYPTO_OP_STATUS_SUCCESS; 371 372 exit: 373 free(ctx); 374 } 375 376 static void 377 process_cpu_aead_op(uint8_t dev_id, struct rte_crypto_op *op) 378 { 379 int32_t n, st; 380 struct rte_crypto_sym_op *sop; 381 union rte_crypto_sym_ofs ofs; 382 struct rte_crypto_sgl sgl; 383 struct rte_crypto_sym_vec symvec; 384 struct rte_crypto_va_iova_ptr iv_ptr, aad_ptr, digest_ptr; 385 struct rte_crypto_vec vec[UINT8_MAX]; 386 387 sop = op->sym; 388 389 n = rte_crypto_mbuf_to_vec(sop->m_src, sop->aead.data.offset, 390 sop->aead.data.length, vec, RTE_DIM(vec)); 391 392 if (n < 0 || n != sop->m_src->nb_segs) { 393 op->status = RTE_CRYPTO_OP_STATUS_ERROR; 394 return; 395 } 396 397 sgl.vec = vec; 398 sgl.num = n; 399 symvec.sgl = &sgl; 400 symvec.iv = &iv_ptr; 401 symvec.digest = &digest_ptr; 402 symvec.aad = &aad_ptr; 403 symvec.status = &st; 404 symvec.num = 1; 405 406 /* for CPU crypto the IOVA address is not required */ 407 iv_ptr.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET); 408 digest_ptr.va = (void *)sop->aead.digest.data; 409 aad_ptr.va = (void *)sop->aead.aad.data; 410 411 ofs.raw = 0; 412 413 n = rte_cryptodev_sym_cpu_crypto_process(dev_id, sop->session, ofs, 414 &symvec); 415 416 if (n != 1) 417 op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED; 418 else 419 op->status = RTE_CRYPTO_OP_STATUS_SUCCESS; 420 } 421 422 static void 423 process_cpu_crypt_auth_op(uint8_t dev_id, struct rte_crypto_op *op) 424 { 425 int32_t n, st; 426 struct rte_crypto_sym_op *sop; 427 union rte_crypto_sym_ofs ofs; 428 struct rte_crypto_sgl sgl; 429 struct rte_crypto_sym_vec symvec; 430 struct rte_crypto_va_iova_ptr iv_ptr, digest_ptr; 431 struct rte_crypto_vec vec[UINT8_MAX]; 432 433 sop = op->sym; 434 435 n = rte_crypto_mbuf_to_vec(sop->m_src, sop->auth.data.offset, 436 sop->auth.data.length, vec, RTE_DIM(vec)); 437 438 if (n < 0 || n != sop->m_src->nb_segs) { 439 op->status = RTE_CRYPTO_OP_STATUS_ERROR; 440 return; 441 } 442 443 sgl.vec = vec; 444 sgl.num = n; 445 symvec.sgl = &sgl; 446 symvec.iv = &iv_ptr; 447 symvec.digest = &digest_ptr; 448 symvec.status = &st; 449 symvec.num = 1; 450 451 iv_ptr.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET); 452 digest_ptr.va = (void *)sop->auth.digest.data; 453 454 ofs.raw = 0; 455 ofs.ofs.cipher.head = sop->cipher.data.offset - sop->auth.data.offset; 456 ofs.ofs.cipher.tail = (sop->auth.data.offset + sop->auth.data.length) - 457 (sop->cipher.data.offset + sop->cipher.data.length); 458 459 n = rte_cryptodev_sym_cpu_crypto_process(dev_id, sop->session, ofs, 460 &symvec); 461 462 if (n != 1) 463 op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED; 464 else 465 op->status = RTE_CRYPTO_OP_STATUS_SUCCESS; 466 } 467 468 static struct rte_crypto_op * 469 process_crypto_request(uint8_t dev_id, struct rte_crypto_op *op) 470 { 471 472 RTE_VERIFY(gbl_action_type != RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO); 473 474 if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) { 475 RTE_LOG(ERR, USER1, "Error sending packet for encryption\n"); 476 return NULL; 477 } 478 479 op = NULL; 480 481 while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0) 482 rte_pause(); 483 484 if (op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) { 485 RTE_LOG(DEBUG, USER1, "Operation status %d\n", op->status); 486 return NULL; 487 } 488 489 return op; 490 } 491 492 static struct crypto_testsuite_params testsuite_params = { NULL }; 493 struct crypto_testsuite_params *p_testsuite_params = &testsuite_params; 494 static struct crypto_unittest_params unittest_params; 495 496 static int 497 testsuite_setup(void) 498 { 499 struct crypto_testsuite_params *ts_params = &testsuite_params; 500 struct rte_cryptodev_info info; 501 uint32_t i = 0, nb_devs, dev_id; 502 uint16_t qp_id; 503 504 memset(ts_params, 0, sizeof(*ts_params)); 505 506 ts_params->mbuf_pool = rte_mempool_lookup("CRYPTO_MBUFPOOL"); 507 if (ts_params->mbuf_pool == NULL) { 508 /* Not already created so create */ 509 ts_params->mbuf_pool = rte_pktmbuf_pool_create( 510 "CRYPTO_MBUFPOOL", 511 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE, 512 rte_socket_id()); 513 if (ts_params->mbuf_pool == NULL) { 514 RTE_LOG(ERR, USER1, "Can't create CRYPTO_MBUFPOOL\n"); 515 return TEST_FAILED; 516 } 517 } 518 519 ts_params->large_mbuf_pool = rte_mempool_lookup( 520 "CRYPTO_LARGE_MBUFPOOL"); 521 if (ts_params->large_mbuf_pool == NULL) { 522 /* Not already created so create */ 523 ts_params->large_mbuf_pool = rte_pktmbuf_pool_create( 524 "CRYPTO_LARGE_MBUFPOOL", 525 1, 0, 0, UINT16_MAX, 526 rte_socket_id()); 527 if (ts_params->large_mbuf_pool == NULL) { 528 RTE_LOG(ERR, USER1, 529 "Can't create CRYPTO_LARGE_MBUFPOOL\n"); 530 return TEST_FAILED; 531 } 532 } 533 534 ts_params->op_mpool = rte_crypto_op_pool_create( 535 "MBUF_CRYPTO_SYM_OP_POOL", 536 RTE_CRYPTO_OP_TYPE_SYMMETRIC, 537 NUM_MBUFS, MBUF_CACHE_SIZE, 538 DEFAULT_NUM_XFORMS * 539 sizeof(struct rte_crypto_sym_xform) + 540 MAXIMUM_IV_LENGTH, 541 rte_socket_id()); 542 if (ts_params->op_mpool == NULL) { 543 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n"); 544 return TEST_FAILED; 545 } 546 547 nb_devs = rte_cryptodev_count(); 548 if (nb_devs < 1) { 549 RTE_LOG(WARNING, USER1, "No crypto devices found?\n"); 550 return TEST_SKIPPED; 551 } 552 553 if (rte_cryptodev_device_count_by_driver(gbl_driver_id) < 1) { 554 RTE_LOG(WARNING, USER1, "No %s devices found?\n", 555 rte_cryptodev_driver_name_get(gbl_driver_id)); 556 return TEST_SKIPPED; 557 } 558 559 /* Create list of valid crypto devs */ 560 for (i = 0; i < nb_devs; i++) { 561 rte_cryptodev_info_get(i, &info); 562 if (info.driver_id == gbl_driver_id) 563 ts_params->valid_devs[ts_params->valid_dev_count++] = i; 564 } 565 566 if (ts_params->valid_dev_count < 1) 567 return TEST_FAILED; 568 569 /* Set up all the qps on the first of the valid devices found */ 570 571 dev_id = ts_params->valid_devs[0]; 572 573 rte_cryptodev_info_get(dev_id, &info); 574 575 ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs; 576 ts_params->conf.socket_id = SOCKET_ID_ANY; 577 ts_params->conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY; 578 579 unsigned int session_size = 580 rte_cryptodev_sym_get_private_session_size(dev_id); 581 582 #ifdef RTE_LIB_SECURITY 583 unsigned int security_session_size = rte_security_session_get_size( 584 rte_cryptodev_get_sec_ctx(dev_id)); 585 586 if (session_size < security_session_size) 587 session_size = security_session_size; 588 #endif 589 /* 590 * Create mempool with maximum number of sessions. 591 */ 592 if (info.sym.max_nb_sessions != 0 && 593 info.sym.max_nb_sessions < MAX_NB_SESSIONS) { 594 RTE_LOG(ERR, USER1, "Device does not support " 595 "at least %u sessions\n", 596 MAX_NB_SESSIONS); 597 return TEST_FAILED; 598 } 599 600 ts_params->session_mpool = rte_cryptodev_sym_session_pool_create( 601 "test_sess_mp", MAX_NB_SESSIONS, 0, 0, 0, 602 SOCKET_ID_ANY); 603 TEST_ASSERT_NOT_NULL(ts_params->session_mpool, 604 "session mempool allocation failed"); 605 606 ts_params->session_priv_mpool = rte_mempool_create( 607 "test_sess_mp_priv", 608 MAX_NB_SESSIONS, 609 session_size, 610 0, 0, NULL, NULL, NULL, 611 NULL, SOCKET_ID_ANY, 612 0); 613 TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool, 614 "session mempool allocation failed"); 615 616 617 618 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, 619 &ts_params->conf), 620 "Failed to configure cryptodev %u with %u qps", 621 dev_id, ts_params->conf.nb_queue_pairs); 622 623 ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; 624 ts_params->qp_conf.mp_session = ts_params->session_mpool; 625 ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool; 626 627 for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) { 628 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( 629 dev_id, qp_id, &ts_params->qp_conf, 630 rte_cryptodev_socket_id(dev_id)), 631 "Failed to setup queue pair %u on cryptodev %u", 632 qp_id, dev_id); 633 } 634 635 return TEST_SUCCESS; 636 } 637 638 static void 639 testsuite_teardown(void) 640 { 641 struct crypto_testsuite_params *ts_params = &testsuite_params; 642 int res; 643 644 if (ts_params->mbuf_pool != NULL) { 645 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n", 646 rte_mempool_avail_count(ts_params->mbuf_pool)); 647 } 648 649 if (ts_params->op_mpool != NULL) { 650 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n", 651 rte_mempool_avail_count(ts_params->op_mpool)); 652 } 653 654 /* Free session mempools */ 655 if (ts_params->session_priv_mpool != NULL) { 656 rte_mempool_free(ts_params->session_priv_mpool); 657 ts_params->session_priv_mpool = NULL; 658 } 659 660 if (ts_params->session_mpool != NULL) { 661 rte_mempool_free(ts_params->session_mpool); 662 ts_params->session_mpool = NULL; 663 } 664 665 res = rte_cryptodev_close(ts_params->valid_devs[0]); 666 if (res) 667 RTE_LOG(ERR, USER1, "Crypto device close error %d\n", res); 668 } 669 670 static int 671 check_capabilities_supported(enum rte_crypto_sym_xform_type type, 672 const int *algs, uint16_t num_algs) 673 { 674 uint8_t dev_id = testsuite_params.valid_devs[0]; 675 bool some_alg_supported = FALSE; 676 uint16_t i; 677 678 for (i = 0; i < num_algs && !some_alg_supported; i++) { 679 struct rte_cryptodev_sym_capability_idx alg = { 680 type, {algs[i]} 681 }; 682 if (rte_cryptodev_sym_capability_get(dev_id, 683 &alg) != NULL) 684 some_alg_supported = TRUE; 685 } 686 if (!some_alg_supported) 687 return TEST_SKIPPED; 688 689 return 0; 690 } 691 692 int 693 check_cipher_capabilities_supported(const enum rte_crypto_cipher_algorithm *ciphers, 694 uint16_t num_ciphers) 695 { 696 return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_CIPHER, 697 (const int *) ciphers, num_ciphers); 698 } 699 700 int 701 check_auth_capabilities_supported(const enum rte_crypto_auth_algorithm *auths, 702 uint16_t num_auths) 703 { 704 return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_AUTH, 705 (const int *) auths, num_auths); 706 } 707 708 int 709 check_aead_capabilities_supported(const enum rte_crypto_aead_algorithm *aeads, 710 uint16_t num_aeads) 711 { 712 return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_AEAD, 713 (const int *) aeads, num_aeads); 714 } 715 716 static int 717 null_testsuite_setup(void) 718 { 719 struct crypto_testsuite_params *ts_params = &testsuite_params; 720 uint8_t dev_id = ts_params->valid_devs[0]; 721 struct rte_cryptodev_info dev_info; 722 const enum rte_crypto_cipher_algorithm ciphers[] = { 723 RTE_CRYPTO_CIPHER_NULL 724 }; 725 const enum rte_crypto_auth_algorithm auths[] = { 726 RTE_CRYPTO_AUTH_NULL 727 }; 728 729 rte_cryptodev_info_get(dev_id, &dev_info); 730 731 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) { 732 RTE_LOG(INFO, USER1, "Feature flag requirements for NULL " 733 "testsuite not met\n"); 734 return TEST_SKIPPED; 735 } 736 737 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0 738 && check_auth_capabilities_supported(auths, 739 RTE_DIM(auths)) != 0) { 740 RTE_LOG(INFO, USER1, "Capability requirements for NULL " 741 "testsuite not met\n"); 742 return TEST_SKIPPED; 743 } 744 745 return 0; 746 } 747 748 static int 749 crypto_gen_testsuite_setup(void) 750 { 751 struct crypto_testsuite_params *ts_params = &testsuite_params; 752 uint8_t dev_id = ts_params->valid_devs[0]; 753 struct rte_cryptodev_info dev_info; 754 755 rte_cryptodev_info_get(dev_id, &dev_info); 756 757 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) { 758 RTE_LOG(INFO, USER1, "Feature flag requirements for Crypto Gen " 759 "testsuite not met\n"); 760 return TEST_SKIPPED; 761 } 762 763 return 0; 764 } 765 766 #ifdef RTE_LIB_SECURITY 767 static int 768 ipsec_proto_testsuite_setup(void) 769 { 770 struct crypto_testsuite_params *ts_params = &testsuite_params; 771 struct crypto_unittest_params *ut_params = &unittest_params; 772 struct rte_cryptodev_info dev_info; 773 int ret = 0; 774 775 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 776 777 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SECURITY)) { 778 RTE_LOG(INFO, USER1, "Feature flag requirements for IPsec Proto " 779 "testsuite not met\n"); 780 return TEST_SKIPPED; 781 } 782 783 /* Reconfigure to enable security */ 784 ret = dev_configure_and_start(0); 785 if (ret != TEST_SUCCESS) 786 return ret; 787 788 /* Set action type */ 789 ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL; 790 791 if (security_proto_supported( 792 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL, 793 RTE_SECURITY_PROTOCOL_IPSEC) < 0) { 794 RTE_LOG(INFO, USER1, "Capability requirements for IPsec Proto " 795 "test not met\n"); 796 ret = TEST_SKIPPED; 797 } 798 799 /* 800 * Stop the device. Device would be started again by individual test 801 * case setup routine. 802 */ 803 rte_cryptodev_stop(ts_params->valid_devs[0]); 804 805 return ret; 806 } 807 808 static int 809 pdcp_proto_testsuite_setup(void) 810 { 811 struct crypto_testsuite_params *ts_params = &testsuite_params; 812 uint8_t dev_id = ts_params->valid_devs[0]; 813 struct rte_cryptodev_info dev_info; 814 const enum rte_crypto_cipher_algorithm ciphers[] = { 815 RTE_CRYPTO_CIPHER_NULL, 816 RTE_CRYPTO_CIPHER_AES_CTR, 817 RTE_CRYPTO_CIPHER_ZUC_EEA3, 818 RTE_CRYPTO_CIPHER_SNOW3G_UEA2 819 }; 820 const enum rte_crypto_auth_algorithm auths[] = { 821 RTE_CRYPTO_AUTH_NULL, 822 RTE_CRYPTO_AUTH_SNOW3G_UIA2, 823 RTE_CRYPTO_AUTH_AES_CMAC, 824 RTE_CRYPTO_AUTH_ZUC_EIA3 825 }; 826 827 rte_cryptodev_info_get(dev_id, &dev_info); 828 829 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) || 830 !(dev_info.feature_flags & 831 RTE_CRYPTODEV_FF_SECURITY)) { 832 RTE_LOG(INFO, USER1, "Feature flag requirements for PDCP Proto " 833 "testsuite not met\n"); 834 return TEST_SKIPPED; 835 } 836 837 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0 838 && check_auth_capabilities_supported(auths, 839 RTE_DIM(auths)) != 0) { 840 RTE_LOG(INFO, USER1, "Capability requirements for PDCP Proto " 841 "testsuite not met\n"); 842 return TEST_SKIPPED; 843 } 844 845 return 0; 846 } 847 848 static int 849 docsis_proto_testsuite_setup(void) 850 { 851 struct crypto_testsuite_params *ts_params = &testsuite_params; 852 uint8_t dev_id = ts_params->valid_devs[0]; 853 struct rte_cryptodev_info dev_info; 854 const enum rte_crypto_cipher_algorithm ciphers[] = { 855 RTE_CRYPTO_CIPHER_AES_DOCSISBPI 856 }; 857 858 rte_cryptodev_info_get(dev_id, &dev_info); 859 860 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) || 861 !(dev_info.feature_flags & 862 RTE_CRYPTODEV_FF_SECURITY)) { 863 RTE_LOG(INFO, USER1, "Feature flag requirements for Docsis " 864 "Proto testsuite not met\n"); 865 return TEST_SKIPPED; 866 } 867 868 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0) { 869 RTE_LOG(INFO, USER1, "Capability requirements for Docsis Proto " 870 "testsuite not met\n"); 871 return TEST_SKIPPED; 872 } 873 874 return 0; 875 } 876 #endif 877 878 static int 879 aes_ccm_auth_testsuite_setup(void) 880 { 881 struct crypto_testsuite_params *ts_params = &testsuite_params; 882 uint8_t dev_id = ts_params->valid_devs[0]; 883 struct rte_cryptodev_info dev_info; 884 const enum rte_crypto_aead_algorithm aeads[] = { 885 RTE_CRYPTO_AEAD_AES_CCM 886 }; 887 888 rte_cryptodev_info_get(dev_id, &dev_info); 889 890 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) || 891 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 892 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 893 RTE_LOG(INFO, USER1, "Feature flag requirements for AES CCM " 894 "testsuite not met\n"); 895 return TEST_SKIPPED; 896 } 897 898 if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) { 899 RTE_LOG(INFO, USER1, "Capability requirements for AES CCM " 900 "testsuite not met\n"); 901 return TEST_SKIPPED; 902 } 903 904 return 0; 905 } 906 907 static int 908 aes_gcm_auth_testsuite_setup(void) 909 { 910 struct crypto_testsuite_params *ts_params = &testsuite_params; 911 uint8_t dev_id = ts_params->valid_devs[0]; 912 struct rte_cryptodev_info dev_info; 913 const enum rte_crypto_aead_algorithm aeads[] = { 914 RTE_CRYPTO_AEAD_AES_GCM 915 }; 916 917 rte_cryptodev_info_get(dev_id, &dev_info); 918 919 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) { 920 RTE_LOG(INFO, USER1, "Feature flag requirements for AES GCM " 921 "testsuite not met\n"); 922 return TEST_SKIPPED; 923 } 924 925 if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) { 926 RTE_LOG(INFO, USER1, "Capability requirements for AES GCM " 927 "testsuite not met\n"); 928 return TEST_SKIPPED; 929 } 930 931 return 0; 932 } 933 934 static int 935 aes_gmac_auth_testsuite_setup(void) 936 { 937 struct crypto_testsuite_params *ts_params = &testsuite_params; 938 uint8_t dev_id = ts_params->valid_devs[0]; 939 struct rte_cryptodev_info dev_info; 940 const enum rte_crypto_auth_algorithm auths[] = { 941 RTE_CRYPTO_AUTH_AES_GMAC 942 }; 943 944 rte_cryptodev_info_get(dev_id, &dev_info); 945 946 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) || 947 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 948 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 949 RTE_LOG(INFO, USER1, "Feature flag requirements for AES GMAC " 950 "testsuite not met\n"); 951 return TEST_SKIPPED; 952 } 953 954 if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) { 955 RTE_LOG(INFO, USER1, "Capability requirements for AES GMAC " 956 "testsuite not met\n"); 957 return TEST_SKIPPED; 958 } 959 960 return 0; 961 } 962 963 static int 964 chacha20_poly1305_testsuite_setup(void) 965 { 966 struct crypto_testsuite_params *ts_params = &testsuite_params; 967 uint8_t dev_id = ts_params->valid_devs[0]; 968 struct rte_cryptodev_info dev_info; 969 const enum rte_crypto_aead_algorithm aeads[] = { 970 RTE_CRYPTO_AEAD_CHACHA20_POLY1305 971 }; 972 973 rte_cryptodev_info_get(dev_id, &dev_info); 974 975 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) || 976 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 977 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 978 RTE_LOG(INFO, USER1, "Feature flag requirements for " 979 "Chacha20-Poly1305 testsuite not met\n"); 980 return TEST_SKIPPED; 981 } 982 983 if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) { 984 RTE_LOG(INFO, USER1, "Capability requirements for " 985 "Chacha20-Poly1305 testsuite not met\n"); 986 return TEST_SKIPPED; 987 } 988 989 return 0; 990 } 991 992 static int 993 snow3g_testsuite_setup(void) 994 { 995 struct crypto_testsuite_params *ts_params = &testsuite_params; 996 uint8_t dev_id = ts_params->valid_devs[0]; 997 struct rte_cryptodev_info dev_info; 998 const enum rte_crypto_cipher_algorithm ciphers[] = { 999 RTE_CRYPTO_CIPHER_SNOW3G_UEA2 1000 1001 }; 1002 const enum rte_crypto_auth_algorithm auths[] = { 1003 RTE_CRYPTO_AUTH_SNOW3G_UIA2 1004 }; 1005 1006 rte_cryptodev_info_get(dev_id, &dev_info); 1007 1008 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) { 1009 RTE_LOG(INFO, USER1, "Feature flag requirements for Snow3G " 1010 "testsuite not met\n"); 1011 return TEST_SKIPPED; 1012 } 1013 1014 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0 1015 && check_auth_capabilities_supported(auths, 1016 RTE_DIM(auths)) != 0) { 1017 RTE_LOG(INFO, USER1, "Capability requirements for Snow3G " 1018 "testsuite not met\n"); 1019 return TEST_SKIPPED; 1020 } 1021 1022 return 0; 1023 } 1024 1025 static int 1026 zuc_testsuite_setup(void) 1027 { 1028 struct crypto_testsuite_params *ts_params = &testsuite_params; 1029 uint8_t dev_id = ts_params->valid_devs[0]; 1030 struct rte_cryptodev_info dev_info; 1031 const enum rte_crypto_cipher_algorithm ciphers[] = { 1032 RTE_CRYPTO_CIPHER_ZUC_EEA3 1033 }; 1034 const enum rte_crypto_auth_algorithm auths[] = { 1035 RTE_CRYPTO_AUTH_ZUC_EIA3 1036 }; 1037 1038 rte_cryptodev_info_get(dev_id, &dev_info); 1039 1040 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) { 1041 RTE_LOG(INFO, USER1, "Feature flag requirements for ZUC " 1042 "testsuite not met\n"); 1043 return TEST_SKIPPED; 1044 } 1045 1046 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0 1047 && check_auth_capabilities_supported(auths, 1048 RTE_DIM(auths)) != 0) { 1049 RTE_LOG(INFO, USER1, "Capability requirements for ZUC " 1050 "testsuite not met\n"); 1051 return TEST_SKIPPED; 1052 } 1053 1054 return 0; 1055 } 1056 1057 static int 1058 hmac_md5_auth_testsuite_setup(void) 1059 { 1060 struct crypto_testsuite_params *ts_params = &testsuite_params; 1061 uint8_t dev_id = ts_params->valid_devs[0]; 1062 struct rte_cryptodev_info dev_info; 1063 const enum rte_crypto_auth_algorithm auths[] = { 1064 RTE_CRYPTO_AUTH_MD5_HMAC 1065 }; 1066 1067 rte_cryptodev_info_get(dev_id, &dev_info); 1068 1069 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) || 1070 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 1071 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 1072 RTE_LOG(INFO, USER1, "Feature flag requirements for HMAC MD5 " 1073 "Auth testsuite not met\n"); 1074 return TEST_SKIPPED; 1075 } 1076 1077 if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) { 1078 RTE_LOG(INFO, USER1, "Capability requirements for HMAC MD5 " 1079 "testsuite not met\n"); 1080 return TEST_SKIPPED; 1081 } 1082 1083 return 0; 1084 } 1085 1086 static int 1087 kasumi_testsuite_setup(void) 1088 { 1089 struct crypto_testsuite_params *ts_params = &testsuite_params; 1090 uint8_t dev_id = ts_params->valid_devs[0]; 1091 struct rte_cryptodev_info dev_info; 1092 const enum rte_crypto_cipher_algorithm ciphers[] = { 1093 RTE_CRYPTO_CIPHER_KASUMI_F8 1094 }; 1095 const enum rte_crypto_auth_algorithm auths[] = { 1096 RTE_CRYPTO_AUTH_KASUMI_F9 1097 }; 1098 1099 rte_cryptodev_info_get(dev_id, &dev_info); 1100 1101 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) || 1102 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 1103 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 1104 RTE_LOG(INFO, USER1, "Feature flag requirements for Kasumi " 1105 "testsuite not met\n"); 1106 return TEST_SKIPPED; 1107 } 1108 1109 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0 1110 && check_auth_capabilities_supported(auths, 1111 RTE_DIM(auths)) != 0) { 1112 RTE_LOG(INFO, USER1, "Capability requirements for Kasumi " 1113 "testsuite not met\n"); 1114 return TEST_SKIPPED; 1115 } 1116 1117 return 0; 1118 } 1119 1120 static int 1121 negative_aes_gcm_testsuite_setup(void) 1122 { 1123 struct crypto_testsuite_params *ts_params = &testsuite_params; 1124 uint8_t dev_id = ts_params->valid_devs[0]; 1125 struct rte_cryptodev_info dev_info; 1126 const enum rte_crypto_aead_algorithm aeads[] = { 1127 RTE_CRYPTO_AEAD_AES_GCM 1128 }; 1129 1130 rte_cryptodev_info_get(dev_id, &dev_info); 1131 1132 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) || 1133 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 1134 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 1135 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative " 1136 "AES GCM testsuite not met\n"); 1137 return TEST_SKIPPED; 1138 } 1139 1140 if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) { 1141 RTE_LOG(INFO, USER1, "Capability requirements for Negative " 1142 "AES GCM testsuite not met\n"); 1143 return TEST_SKIPPED; 1144 } 1145 1146 return 0; 1147 } 1148 1149 static int 1150 negative_aes_gmac_testsuite_setup(void) 1151 { 1152 struct crypto_testsuite_params *ts_params = &testsuite_params; 1153 uint8_t dev_id = ts_params->valid_devs[0]; 1154 struct rte_cryptodev_info dev_info; 1155 const enum rte_crypto_auth_algorithm auths[] = { 1156 RTE_CRYPTO_AUTH_AES_GMAC 1157 }; 1158 1159 rte_cryptodev_info_get(dev_id, &dev_info); 1160 1161 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) || 1162 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 1163 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 1164 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative " 1165 "AES GMAC testsuite not met\n"); 1166 return TEST_SKIPPED; 1167 } 1168 1169 if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) { 1170 RTE_LOG(INFO, USER1, "Capability requirements for Negative " 1171 "AES GMAC testsuite not met\n"); 1172 return TEST_SKIPPED; 1173 } 1174 1175 return 0; 1176 } 1177 1178 static int 1179 mixed_cipher_hash_testsuite_setup(void) 1180 { 1181 struct crypto_testsuite_params *ts_params = &testsuite_params; 1182 uint8_t dev_id = ts_params->valid_devs[0]; 1183 struct rte_cryptodev_info dev_info; 1184 uint64_t feat_flags; 1185 const enum rte_crypto_cipher_algorithm ciphers[] = { 1186 RTE_CRYPTO_CIPHER_NULL, 1187 RTE_CRYPTO_CIPHER_AES_CTR, 1188 RTE_CRYPTO_CIPHER_ZUC_EEA3, 1189 RTE_CRYPTO_CIPHER_SNOW3G_UEA2 1190 }; 1191 const enum rte_crypto_auth_algorithm auths[] = { 1192 RTE_CRYPTO_AUTH_NULL, 1193 RTE_CRYPTO_AUTH_SNOW3G_UIA2, 1194 RTE_CRYPTO_AUTH_AES_CMAC, 1195 RTE_CRYPTO_AUTH_ZUC_EIA3 1196 }; 1197 1198 rte_cryptodev_info_get(dev_id, &dev_info); 1199 feat_flags = dev_info.feature_flags; 1200 1201 if (!(feat_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) || 1202 (global_api_test_type == CRYPTODEV_RAW_API_TEST)) { 1203 RTE_LOG(INFO, USER1, "Feature flag requirements for Mixed " 1204 "Cipher Hash testsuite not met\n"); 1205 return TEST_SKIPPED; 1206 } 1207 1208 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0 1209 && check_auth_capabilities_supported(auths, 1210 RTE_DIM(auths)) != 0) { 1211 RTE_LOG(INFO, USER1, "Capability requirements for Mixed " 1212 "Cipher Hash testsuite not met\n"); 1213 return TEST_SKIPPED; 1214 } 1215 1216 return 0; 1217 } 1218 1219 static int 1220 esn_testsuite_setup(void) 1221 { 1222 struct crypto_testsuite_params *ts_params = &testsuite_params; 1223 uint8_t dev_id = ts_params->valid_devs[0]; 1224 struct rte_cryptodev_info dev_info; 1225 const enum rte_crypto_cipher_algorithm ciphers[] = { 1226 RTE_CRYPTO_CIPHER_AES_CBC 1227 }; 1228 const enum rte_crypto_auth_algorithm auths[] = { 1229 RTE_CRYPTO_AUTH_SHA1_HMAC 1230 }; 1231 1232 rte_cryptodev_info_get(dev_id, &dev_info); 1233 1234 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) || 1235 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 1236 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 1237 RTE_LOG(INFO, USER1, "Feature flag requirements for ESN " 1238 "testsuite not met\n"); 1239 return TEST_SKIPPED; 1240 } 1241 1242 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0 1243 && check_auth_capabilities_supported(auths, 1244 RTE_DIM(auths)) != 0) { 1245 RTE_LOG(INFO, USER1, "Capability requirements for ESN " 1246 "testsuite not met\n"); 1247 return TEST_SKIPPED; 1248 } 1249 1250 return 0; 1251 } 1252 1253 static int 1254 multi_session_testsuite_setup(void) 1255 { 1256 struct crypto_testsuite_params *ts_params = &testsuite_params; 1257 uint8_t dev_id = ts_params->valid_devs[0]; 1258 struct rte_cryptodev_info dev_info; 1259 const enum rte_crypto_cipher_algorithm ciphers[] = { 1260 RTE_CRYPTO_CIPHER_AES_CBC 1261 }; 1262 const enum rte_crypto_auth_algorithm auths[] = { 1263 RTE_CRYPTO_AUTH_SHA512_HMAC 1264 }; 1265 1266 rte_cryptodev_info_get(dev_id, &dev_info); 1267 1268 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) { 1269 RTE_LOG(INFO, USER1, "Feature flag requirements for Multi " 1270 "Session testsuite not met\n"); 1271 return TEST_SKIPPED; 1272 } 1273 1274 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0 1275 && check_auth_capabilities_supported(auths, 1276 RTE_DIM(auths)) != 0) { 1277 RTE_LOG(INFO, USER1, "Capability requirements for Multi " 1278 "Session testsuite not met\n"); 1279 return TEST_SKIPPED; 1280 } 1281 1282 return 0; 1283 } 1284 1285 static int 1286 negative_hmac_sha1_testsuite_setup(void) 1287 { 1288 struct crypto_testsuite_params *ts_params = &testsuite_params; 1289 uint8_t dev_id = ts_params->valid_devs[0]; 1290 struct rte_cryptodev_info dev_info; 1291 const enum rte_crypto_cipher_algorithm ciphers[] = { 1292 RTE_CRYPTO_CIPHER_AES_CBC 1293 }; 1294 const enum rte_crypto_auth_algorithm auths[] = { 1295 RTE_CRYPTO_AUTH_SHA1_HMAC 1296 }; 1297 1298 rte_cryptodev_info_get(dev_id, &dev_info); 1299 1300 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) || 1301 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 1302 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 1303 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative " 1304 "HMAC SHA1 testsuite not met\n"); 1305 return TEST_SKIPPED; 1306 } 1307 1308 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0 1309 && check_auth_capabilities_supported(auths, 1310 RTE_DIM(auths)) != 0) { 1311 RTE_LOG(INFO, USER1, "Capability requirements for Negative " 1312 "HMAC SHA1 testsuite not met\n"); 1313 return TEST_SKIPPED; 1314 } 1315 1316 return 0; 1317 } 1318 1319 static int 1320 dev_configure_and_start(uint64_t ff_disable) 1321 { 1322 struct crypto_testsuite_params *ts_params = &testsuite_params; 1323 struct crypto_unittest_params *ut_params = &unittest_params; 1324 1325 uint16_t qp_id; 1326 1327 /* Clear unit test parameters before running test */ 1328 memset(ut_params, 0, sizeof(*ut_params)); 1329 1330 /* Reconfigure device to default parameters */ 1331 ts_params->conf.socket_id = SOCKET_ID_ANY; 1332 ts_params->conf.ff_disable = ff_disable; 1333 ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; 1334 ts_params->qp_conf.mp_session = ts_params->session_mpool; 1335 ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool; 1336 1337 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0], 1338 &ts_params->conf), 1339 "Failed to configure cryptodev %u", 1340 ts_params->valid_devs[0]); 1341 1342 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) { 1343 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( 1344 ts_params->valid_devs[0], qp_id, 1345 &ts_params->qp_conf, 1346 rte_cryptodev_socket_id(ts_params->valid_devs[0])), 1347 "Failed to setup queue pair %u on cryptodev %u", 1348 qp_id, ts_params->valid_devs[0]); 1349 } 1350 1351 1352 rte_cryptodev_stats_reset(ts_params->valid_devs[0]); 1353 1354 /* Start the device */ 1355 TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]), 1356 "Failed to start cryptodev %u", 1357 ts_params->valid_devs[0]); 1358 1359 return TEST_SUCCESS; 1360 } 1361 1362 int 1363 ut_setup(void) 1364 { 1365 /* Configure and start the device with security feature disabled */ 1366 return dev_configure_and_start(RTE_CRYPTODEV_FF_SECURITY); 1367 } 1368 1369 static int 1370 ut_setup_security(void) 1371 { 1372 /* Configure and start the device with no features disabled */ 1373 return dev_configure_and_start(0); 1374 } 1375 1376 void 1377 ut_teardown(void) 1378 { 1379 struct crypto_testsuite_params *ts_params = &testsuite_params; 1380 struct crypto_unittest_params *ut_params = &unittest_params; 1381 struct rte_cryptodev_stats stats; 1382 1383 /* free crypto session structure */ 1384 #ifdef RTE_LIB_SECURITY 1385 if (ut_params->type == RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL) { 1386 if (ut_params->sec_session) { 1387 rte_security_session_destroy(rte_cryptodev_get_sec_ctx 1388 (ts_params->valid_devs[0]), 1389 ut_params->sec_session); 1390 ut_params->sec_session = NULL; 1391 } 1392 } else 1393 #endif 1394 { 1395 if (ut_params->sess) { 1396 rte_cryptodev_sym_session_clear( 1397 ts_params->valid_devs[0], 1398 ut_params->sess); 1399 rte_cryptodev_sym_session_free(ut_params->sess); 1400 ut_params->sess = NULL; 1401 } 1402 } 1403 1404 /* free crypto operation structure */ 1405 if (ut_params->op) 1406 rte_crypto_op_free(ut_params->op); 1407 1408 /* 1409 * free mbuf - both obuf and ibuf are usually the same, 1410 * so check if they point at the same address is necessary, 1411 * to avoid freeing the mbuf twice. 1412 */ 1413 if (ut_params->obuf) { 1414 rte_pktmbuf_free(ut_params->obuf); 1415 if (ut_params->ibuf == ut_params->obuf) 1416 ut_params->ibuf = 0; 1417 ut_params->obuf = 0; 1418 } 1419 if (ut_params->ibuf) { 1420 rte_pktmbuf_free(ut_params->ibuf); 1421 ut_params->ibuf = 0; 1422 } 1423 1424 if (ts_params->mbuf_pool != NULL) 1425 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n", 1426 rte_mempool_avail_count(ts_params->mbuf_pool)); 1427 1428 rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats); 1429 1430 /* Stop the device */ 1431 rte_cryptodev_stop(ts_params->valid_devs[0]); 1432 } 1433 1434 static int 1435 test_device_configure_invalid_dev_id(void) 1436 { 1437 struct crypto_testsuite_params *ts_params = &testsuite_params; 1438 uint16_t dev_id, num_devs = 0; 1439 1440 TEST_ASSERT((num_devs = rte_cryptodev_count()) >= 1, 1441 "Need at least %d devices for test", 1); 1442 1443 /* valid dev_id values */ 1444 dev_id = ts_params->valid_devs[0]; 1445 1446 /* Stop the device in case it's started so it can be configured */ 1447 rte_cryptodev_stop(dev_id); 1448 1449 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf), 1450 "Failed test for rte_cryptodev_configure: " 1451 "invalid dev_num %u", dev_id); 1452 1453 /* invalid dev_id values */ 1454 dev_id = num_devs; 1455 1456 TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf), 1457 "Failed test for rte_cryptodev_configure: " 1458 "invalid dev_num %u", dev_id); 1459 1460 dev_id = 0xff; 1461 1462 TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf), 1463 "Failed test for rte_cryptodev_configure:" 1464 "invalid dev_num %u", dev_id); 1465 1466 return TEST_SUCCESS; 1467 } 1468 1469 static int 1470 test_device_configure_invalid_queue_pair_ids(void) 1471 { 1472 struct crypto_testsuite_params *ts_params = &testsuite_params; 1473 uint16_t orig_nb_qps = ts_params->conf.nb_queue_pairs; 1474 1475 /* Stop the device in case it's started so it can be configured */ 1476 rte_cryptodev_stop(ts_params->valid_devs[0]); 1477 1478 /* valid - max value queue pairs */ 1479 ts_params->conf.nb_queue_pairs = orig_nb_qps; 1480 1481 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0], 1482 &ts_params->conf), 1483 "Failed to configure cryptodev: dev_id %u, qp_id %u", 1484 ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs); 1485 1486 /* valid - one queue pairs */ 1487 ts_params->conf.nb_queue_pairs = 1; 1488 1489 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0], 1490 &ts_params->conf), 1491 "Failed to configure cryptodev: dev_id %u, qp_id %u", 1492 ts_params->valid_devs[0], 1493 ts_params->conf.nb_queue_pairs); 1494 1495 1496 /* invalid - zero queue pairs */ 1497 ts_params->conf.nb_queue_pairs = 0; 1498 1499 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0], 1500 &ts_params->conf), 1501 "Failed test for rte_cryptodev_configure, dev_id %u," 1502 " invalid qps: %u", 1503 ts_params->valid_devs[0], 1504 ts_params->conf.nb_queue_pairs); 1505 1506 1507 /* invalid - max value supported by field queue pairs */ 1508 ts_params->conf.nb_queue_pairs = UINT16_MAX; 1509 1510 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0], 1511 &ts_params->conf), 1512 "Failed test for rte_cryptodev_configure, dev_id %u," 1513 " invalid qps: %u", 1514 ts_params->valid_devs[0], 1515 ts_params->conf.nb_queue_pairs); 1516 1517 1518 /* invalid - max value + 1 queue pairs */ 1519 ts_params->conf.nb_queue_pairs = orig_nb_qps + 1; 1520 1521 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0], 1522 &ts_params->conf), 1523 "Failed test for rte_cryptodev_configure, dev_id %u," 1524 " invalid qps: %u", 1525 ts_params->valid_devs[0], 1526 ts_params->conf.nb_queue_pairs); 1527 1528 /* revert to original testsuite value */ 1529 ts_params->conf.nb_queue_pairs = orig_nb_qps; 1530 1531 return TEST_SUCCESS; 1532 } 1533 1534 static int 1535 test_queue_pair_descriptor_setup(void) 1536 { 1537 struct crypto_testsuite_params *ts_params = &testsuite_params; 1538 struct rte_cryptodev_qp_conf qp_conf = { 1539 .nb_descriptors = MAX_NUM_OPS_INFLIGHT 1540 }; 1541 uint16_t qp_id; 1542 1543 /* Stop the device in case it's started so it can be configured */ 1544 rte_cryptodev_stop(ts_params->valid_devs[0]); 1545 1546 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0], 1547 &ts_params->conf), 1548 "Failed to configure cryptodev %u", 1549 ts_params->valid_devs[0]); 1550 1551 /* 1552 * Test various ring sizes on this device. memzones can't be 1553 * freed so are re-used if ring is released and re-created. 1554 */ 1555 qp_conf.nb_descriptors = MIN_NUM_OPS_INFLIGHT; /* min size*/ 1556 qp_conf.mp_session = ts_params->session_mpool; 1557 qp_conf.mp_session_private = ts_params->session_priv_mpool; 1558 1559 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) { 1560 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( 1561 ts_params->valid_devs[0], qp_id, &qp_conf, 1562 rte_cryptodev_socket_id( 1563 ts_params->valid_devs[0])), 1564 "Failed test for " 1565 "rte_cryptodev_queue_pair_setup: num_inflights " 1566 "%u on qp %u on cryptodev %u", 1567 qp_conf.nb_descriptors, qp_id, 1568 ts_params->valid_devs[0]); 1569 } 1570 1571 qp_conf.nb_descriptors = (uint32_t)(MAX_NUM_OPS_INFLIGHT / 2); 1572 1573 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) { 1574 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( 1575 ts_params->valid_devs[0], qp_id, &qp_conf, 1576 rte_cryptodev_socket_id( 1577 ts_params->valid_devs[0])), 1578 "Failed test for" 1579 " rte_cryptodev_queue_pair_setup: num_inflights" 1580 " %u on qp %u on cryptodev %u", 1581 qp_conf.nb_descriptors, qp_id, 1582 ts_params->valid_devs[0]); 1583 } 1584 1585 qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; /* valid */ 1586 1587 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) { 1588 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( 1589 ts_params->valid_devs[0], qp_id, &qp_conf, 1590 rte_cryptodev_socket_id( 1591 ts_params->valid_devs[0])), 1592 "Failed test for " 1593 "rte_cryptodev_queue_pair_setup: num_inflights" 1594 " %u on qp %u on cryptodev %u", 1595 qp_conf.nb_descriptors, qp_id, 1596 ts_params->valid_devs[0]); 1597 } 1598 1599 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT; 1600 1601 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) { 1602 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( 1603 ts_params->valid_devs[0], qp_id, &qp_conf, 1604 rte_cryptodev_socket_id( 1605 ts_params->valid_devs[0])), 1606 "Failed test for" 1607 " rte_cryptodev_queue_pair_setup:" 1608 "num_inflights %u on qp %u on cryptodev %u", 1609 qp_conf.nb_descriptors, qp_id, 1610 ts_params->valid_devs[0]); 1611 } 1612 1613 /* test invalid queue pair id */ 1614 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT; /*valid */ 1615 1616 qp_id = ts_params->conf.nb_queue_pairs; /*invalid */ 1617 1618 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup( 1619 ts_params->valid_devs[0], 1620 qp_id, &qp_conf, 1621 rte_cryptodev_socket_id(ts_params->valid_devs[0])), 1622 "Failed test for rte_cryptodev_queue_pair_setup:" 1623 "invalid qp %u on cryptodev %u", 1624 qp_id, ts_params->valid_devs[0]); 1625 1626 qp_id = 0xffff; /*invalid*/ 1627 1628 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup( 1629 ts_params->valid_devs[0], 1630 qp_id, &qp_conf, 1631 rte_cryptodev_socket_id(ts_params->valid_devs[0])), 1632 "Failed test for rte_cryptodev_queue_pair_setup:" 1633 "invalid qp %u on cryptodev %u", 1634 qp_id, ts_params->valid_devs[0]); 1635 1636 return TEST_SUCCESS; 1637 } 1638 1639 /* ***** Plaintext data for tests ***** */ 1640 1641 const char catch_22_quote_1[] = 1642 "There was only one catch and that was Catch-22, which " 1643 "specified that a concern for one's safety in the face of " 1644 "dangers that were real and immediate was the process of a " 1645 "rational mind. Orr was crazy and could be grounded. All he " 1646 "had to do was ask; and as soon as he did, he would no longer " 1647 "be crazy and would have to fly more missions. Orr would be " 1648 "crazy to fly more missions and sane if he didn't, but if he " 1649 "was sane he had to fly them. If he flew them he was crazy " 1650 "and didn't have to; but if he didn't want to he was sane and " 1651 "had to. Yossarian was moved very deeply by the absolute " 1652 "simplicity of this clause of Catch-22 and let out a " 1653 "respectful whistle. \"That's some catch, that Catch-22\", he " 1654 "observed. \"It's the best there is,\" Doc Daneeka agreed."; 1655 1656 const char catch_22_quote[] = 1657 "What a lousy earth! He wondered how many people were " 1658 "destitute that same night even in his own prosperous country, " 1659 "how many homes were shanties, how many husbands were drunk " 1660 "and wives socked, and how many children were bullied, abused, " 1661 "or abandoned. How many families hungered for food they could " 1662 "not afford to buy? How many hearts were broken? How many " 1663 "suicides would take place that same night, how many people " 1664 "would go insane? How many cockroaches and landlords would " 1665 "triumph? How many winners were losers, successes failures, " 1666 "and rich men poor men? How many wise guys were stupid? How " 1667 "many happy endings were unhappy endings? How many honest men " 1668 "were liars, brave men cowards, loyal men traitors, how many " 1669 "sainted men were corrupt, how many people in positions of " 1670 "trust had sold their souls to bodyguards, how many had never " 1671 "had souls? How many straight-and-narrow paths were crooked " 1672 "paths? How many best families were worst families and how " 1673 "many good people were bad people? When you added them all up " 1674 "and then subtracted, you might be left with only the children, " 1675 "and perhaps with Albert Einstein and an old violinist or " 1676 "sculptor somewhere."; 1677 1678 #define QUOTE_480_BYTES (480) 1679 #define QUOTE_512_BYTES (512) 1680 #define QUOTE_768_BYTES (768) 1681 #define QUOTE_1024_BYTES (1024) 1682 1683 1684 1685 /* ***** SHA1 Hash Tests ***** */ 1686 1687 #define HMAC_KEY_LENGTH_SHA1 (DIGEST_BYTE_LENGTH_SHA1) 1688 1689 static uint8_t hmac_sha1_key[] = { 1690 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA, 1691 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD, 1692 0xDE, 0xF4, 0xDE, 0xAD }; 1693 1694 /* ***** SHA224 Hash Tests ***** */ 1695 1696 #define HMAC_KEY_LENGTH_SHA224 (DIGEST_BYTE_LENGTH_SHA224) 1697 1698 1699 /* ***** AES-CBC Cipher Tests ***** */ 1700 1701 #define CIPHER_KEY_LENGTH_AES_CBC (16) 1702 #define CIPHER_IV_LENGTH_AES_CBC (CIPHER_KEY_LENGTH_AES_CBC) 1703 1704 static uint8_t aes_cbc_key[] = { 1705 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2, 1706 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A }; 1707 1708 static uint8_t aes_cbc_iv[] = { 1709 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 1710 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f }; 1711 1712 1713 /* ***** AES-CBC / HMAC-SHA1 Hash Tests ***** */ 1714 1715 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_ciphertext[] = { 1716 0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31, 1717 0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76, 1718 0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E, 1719 0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A, 1720 0x3F, 0x6B, 0x5D, 0xDF, 0x52, 0x85, 0x5F, 0x8E, 1721 0x42, 0x3C, 0xFB, 0xE9, 0x1A, 0x24, 0xD6, 0x08, 1722 0xDD, 0xFD, 0x16, 0xFB, 0xE9, 0x55, 0xEF, 0xF0, 1723 0xA0, 0x8D, 0x13, 0xAB, 0x81, 0xC6, 0x90, 0x01, 1724 0xB5, 0x18, 0x84, 0xB3, 0xF6, 0xE6, 0x11, 0x57, 1725 0xD6, 0x71, 0xC6, 0x3C, 0x3F, 0x2F, 0x33, 0xEE, 1726 0x24, 0x42, 0x6E, 0xAC, 0x0B, 0xCA, 0xEC, 0xF9, 1727 0x84, 0xF8, 0x22, 0xAA, 0x60, 0xF0, 0x32, 0xA9, 1728 0x75, 0x75, 0x3B, 0xCB, 0x70, 0x21, 0x0A, 0x8D, 1729 0x0F, 0xE0, 0xC4, 0x78, 0x2B, 0xF8, 0x97, 0xE3, 1730 0xE4, 0x26, 0x4B, 0x29, 0xDA, 0x88, 0xCD, 0x46, 1731 0xEC, 0xAA, 0xF9, 0x7F, 0xF1, 0x15, 0xEA, 0xC3, 1732 0x87, 0xE6, 0x31, 0xF2, 0xCF, 0xDE, 0x4D, 0x80, 1733 0x70, 0x91, 0x7E, 0x0C, 0xF7, 0x26, 0x3A, 0x92, 1734 0x4F, 0x18, 0x83, 0xC0, 0x8F, 0x59, 0x01, 0xA5, 1735 0x88, 0xD1, 0xDB, 0x26, 0x71, 0x27, 0x16, 0xF5, 1736 0xEE, 0x10, 0x82, 0xAC, 0x68, 0x26, 0x9B, 0xE2, 1737 0x6D, 0xD8, 0x9A, 0x80, 0xDF, 0x04, 0x31, 0xD5, 1738 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA, 1739 0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76, 1740 0x73, 0x02, 0x42, 0xC9, 0x23, 0x18, 0x8E, 0xB4, 1741 0x6F, 0xB4, 0xA3, 0x54, 0x6E, 0x88, 0x3B, 0x62, 1742 0x7C, 0x02, 0x8D, 0x4C, 0x9F, 0xC8, 0x45, 0xF4, 1743 0xC9, 0xDE, 0x4F, 0xEB, 0x22, 0x83, 0x1B, 0xE4, 1744 0x49, 0x37, 0xE4, 0xAD, 0xE7, 0xCD, 0x21, 0x54, 1745 0xBC, 0x1C, 0xC2, 0x04, 0x97, 0xB4, 0x10, 0x61, 1746 0xF0, 0xE4, 0xEF, 0x27, 0x63, 0x3A, 0xDA, 0x91, 1747 0x41, 0x25, 0x62, 0x1C, 0x5C, 0xB6, 0x38, 0x4A, 1748 0x88, 0x71, 0x59, 0x5A, 0x8D, 0xA0, 0x09, 0xAF, 1749 0x72, 0x94, 0xD7, 0x79, 0x5C, 0x60, 0x7C, 0x8F, 1750 0x4C, 0xF5, 0xD9, 0xA1, 0x39, 0x6D, 0x81, 0x28, 1751 0xEF, 0x13, 0x28, 0xDF, 0xF5, 0x3E, 0xF7, 0x8E, 1752 0x09, 0x9C, 0x78, 0x18, 0x79, 0xB8, 0x68, 0xD7, 1753 0xA8, 0x29, 0x62, 0xAD, 0xDE, 0xE1, 0x61, 0x76, 1754 0x1B, 0x05, 0x16, 0xCD, 0xBF, 0x02, 0x8E, 0xA6, 1755 0x43, 0x6E, 0x92, 0x55, 0x4F, 0x60, 0x9C, 0x03, 1756 0xB8, 0x4F, 0xA3, 0x02, 0xAC, 0xA8, 0xA7, 0x0C, 1757 0x1E, 0xB5, 0x6B, 0xF8, 0xC8, 0x4D, 0xDE, 0xD2, 1758 0xB0, 0x29, 0x6E, 0x40, 0xE6, 0xD6, 0xC9, 0xE6, 1759 0xB9, 0x0F, 0xB6, 0x63, 0xF5, 0xAA, 0x2B, 0x96, 1760 0xA7, 0x16, 0xAC, 0x4E, 0x0A, 0x33, 0x1C, 0xA6, 1761 0xE6, 0xBD, 0x8A, 0xCF, 0x40, 0xA9, 0xB2, 0xFA, 1762 0x63, 0x27, 0xFD, 0x9B, 0xD9, 0xFC, 0xD5, 0x87, 1763 0x8D, 0x4C, 0xB6, 0xA4, 0xCB, 0xE7, 0x74, 0x55, 1764 0xF4, 0xFB, 0x41, 0x25, 0xB5, 0x4B, 0x0A, 0x1B, 1765 0xB1, 0xD6, 0xB7, 0xD9, 0x47, 0x2A, 0xC3, 0x98, 1766 0x6A, 0xC4, 0x03, 0x73, 0x1F, 0x93, 0x6E, 0x53, 1767 0x19, 0x25, 0x64, 0x15, 0x83, 0xF9, 0x73, 0x2A, 1768 0x74, 0xB4, 0x93, 0x69, 0xC4, 0x72, 0xFC, 0x26, 1769 0xA2, 0x9F, 0x43, 0x45, 0xDD, 0xB9, 0xEF, 0x36, 1770 0xC8, 0x3A, 0xCD, 0x99, 0x9B, 0x54, 0x1A, 0x36, 1771 0xC1, 0x59, 0xF8, 0x98, 0xA8, 0xCC, 0x28, 0x0D, 1772 0x73, 0x4C, 0xEE, 0x98, 0xCB, 0x7C, 0x58, 0x7E, 1773 0x20, 0x75, 0x1E, 0xB7, 0xC9, 0xF8, 0xF2, 0x0E, 1774 0x63, 0x9E, 0x05, 0x78, 0x1A, 0xB6, 0xA8, 0x7A, 1775 0xF9, 0x98, 0x6A, 0xA6, 0x46, 0x84, 0x2E, 0xF6, 1776 0x4B, 0xDC, 0x9B, 0x8F, 0x9B, 0x8F, 0xEE, 0xB4, 1777 0xAA, 0x3F, 0xEE, 0xC0, 0x37, 0x27, 0x76, 0xC7, 1778 0x95, 0xBB, 0x26, 0x74, 0x69, 0x12, 0x7F, 0xF1, 1779 0xBB, 0xFF, 0xAE, 0xB5, 0x99, 0x6E, 0xCB, 0x0C 1780 }; 1781 1782 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest[] = { 1783 0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60, 1784 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1, 1785 0x18, 0x8c, 0x1d, 0x32 1786 }; 1787 1788 1789 /* Multisession Vector context Test */ 1790 /*Begin Session 0 */ 1791 static uint8_t ms_aes_cbc_key0[] = { 1792 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 1793 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff 1794 }; 1795 1796 static uint8_t ms_aes_cbc_iv0[] = { 1797 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 1798 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff 1799 }; 1800 1801 static const uint8_t ms_aes_cbc_cipher0[] = { 1802 0x3C, 0xE4, 0xEE, 0x42, 0xB6, 0x9B, 0xC3, 0x38, 1803 0x5F, 0xAD, 0x54, 0xDC, 0xA8, 0x32, 0x81, 0xDC, 1804 0x7A, 0x6F, 0x85, 0x58, 0x07, 0x35, 0xED, 0xEB, 1805 0xAD, 0x79, 0x79, 0x96, 0xD3, 0x0E, 0xA6, 0xD9, 1806 0xAA, 0x86, 0xA4, 0x8F, 0xB5, 0xD6, 0x6E, 0x6D, 1807 0x0C, 0x91, 0x2F, 0xC4, 0x67, 0x98, 0x0E, 0xC4, 1808 0x8D, 0x83, 0x68, 0x69, 0xC4, 0xD3, 0x94, 0x34, 1809 0xC4, 0x5D, 0x60, 0x55, 0x22, 0x87, 0x8F, 0x6F, 1810 0x17, 0x8E, 0x75, 0xE4, 0x02, 0xF5, 0x1B, 0x99, 1811 0xC8, 0x39, 0xA9, 0xAB, 0x23, 0x91, 0x12, 0xED, 1812 0x08, 0xE7, 0xD9, 0x25, 0x89, 0x24, 0x4F, 0x8D, 1813 0x68, 0xF3, 0x10, 0x39, 0x0A, 0xEE, 0x45, 0x24, 1814 0xDF, 0x7A, 0x9D, 0x00, 0x25, 0xE5, 0x35, 0x71, 1815 0x4E, 0x40, 0x59, 0x6F, 0x0A, 0x13, 0xB3, 0x72, 1816 0x1D, 0x98, 0x63, 0x94, 0x89, 0xA5, 0x39, 0x8E, 1817 0xD3, 0x9C, 0x8A, 0x7F, 0x71, 0x2F, 0xC7, 0xCD, 1818 0x81, 0x05, 0xDC, 0xC0, 0x8D, 0xCE, 0x6D, 0x18, 1819 0x30, 0xC4, 0x72, 0x51, 0xF0, 0x27, 0xC8, 0xF6, 1820 0x60, 0x5B, 0x7C, 0xB2, 0xE3, 0x49, 0x0C, 0x29, 1821 0xC6, 0x9F, 0x39, 0x57, 0x80, 0x55, 0x24, 0x2C, 1822 0x9B, 0x0F, 0x5A, 0xB3, 0x89, 0x55, 0x31, 0x96, 1823 0x0D, 0xCD, 0xF6, 0x51, 0x03, 0x2D, 0x89, 0x26, 1824 0x74, 0x44, 0xD6, 0xE8, 0xDC, 0xEA, 0x44, 0x55, 1825 0x64, 0x71, 0x9C, 0x9F, 0x5D, 0xBA, 0x39, 0x46, 1826 0xA8, 0x17, 0xA1, 0x9C, 0x52, 0x9D, 0xBC, 0x6B, 1827 0x4A, 0x98, 0xE6, 0xEA, 0x33, 0xEC, 0x58, 0xB4, 1828 0x43, 0xF0, 0x32, 0x45, 0xA4, 0xC1, 0x55, 0xB7, 1829 0x5D, 0xB5, 0x59, 0xB2, 0xE3, 0x96, 0xFF, 0xA5, 1830 0xAF, 0xE1, 0x86, 0x1B, 0x42, 0xE6, 0x3B, 0xA0, 1831 0x90, 0x4A, 0xE8, 0x8C, 0x21, 0x7F, 0x36, 0x1E, 1832 0x5B, 0x65, 0x25, 0xD1, 0xC1, 0x5A, 0xCA, 0x3D, 1833 0x10, 0xED, 0x2D, 0x79, 0xD0, 0x0F, 0x58, 0x44, 1834 0x69, 0x81, 0xF5, 0xD4, 0xC9, 0x0F, 0x90, 0x76, 1835 0x1F, 0x54, 0xD2, 0xD5, 0x97, 0xCE, 0x2C, 0xE3, 1836 0xEF, 0xF4, 0xB7, 0xC6, 0x3A, 0x87, 0x7F, 0x83, 1837 0x2A, 0xAF, 0xCD, 0x90, 0x12, 0xA7, 0x7D, 0x85, 1838 0x1D, 0x62, 0xD3, 0x85, 0x25, 0x05, 0xDB, 0x45, 1839 0x92, 0xA3, 0xF6, 0xA2, 0xA8, 0x41, 0xE4, 0x25, 1840 0x86, 0x87, 0x67, 0x24, 0xEC, 0x89, 0x23, 0x2A, 1841 0x9B, 0x20, 0x4D, 0x93, 0xEE, 0xE2, 0x2E, 0xC1, 1842 0x0B, 0x15, 0x33, 0xCF, 0x00, 0xD1, 0x1A, 0xDA, 1843 0x93, 0xFD, 0x28, 0x21, 0x5B, 0xCF, 0xD1, 0xF3, 1844 0x5A, 0x81, 0xBA, 0x82, 0x5E, 0x2F, 0x61, 0xB4, 1845 0x05, 0x71, 0xB5, 0xF4, 0x39, 0x3C, 0x1F, 0x60, 1846 0x00, 0x7A, 0xC4, 0xF8, 0x35, 0x20, 0x6C, 0x3A, 1847 0xCC, 0x03, 0x8F, 0x7B, 0xA2, 0xB6, 0x65, 0x8A, 1848 0xB6, 0x5F, 0xFD, 0x25, 0xD3, 0x5F, 0x92, 0xF9, 1849 0xAE, 0x17, 0x9B, 0x5E, 0x6E, 0x9A, 0xE4, 0x55, 1850 0x10, 0x25, 0x07, 0xA4, 0xAF, 0x21, 0x69, 0x13, 1851 0xD8, 0xFA, 0x31, 0xED, 0xF7, 0xA7, 0xA7, 0x3B, 1852 0xB8, 0x96, 0x8E, 0x10, 0x86, 0x74, 0xD8, 0xB1, 1853 0x34, 0x9E, 0x9B, 0x6A, 0x26, 0xA8, 0xD4, 0xD0, 1854 0xB5, 0xF6, 0xDE, 0xE7, 0xCA, 0x06, 0xDC, 0xA3, 1855 0x6F, 0xEE, 0x6B, 0x1E, 0xB5, 0x30, 0x99, 0x23, 1856 0xF9, 0x76, 0xF0, 0xA0, 0xCF, 0x3B, 0x94, 0x7B, 1857 0x19, 0x8D, 0xA5, 0x0C, 0x18, 0xA6, 0x1D, 0x07, 1858 0x89, 0xBE, 0x5B, 0x61, 0xE5, 0xF1, 0x42, 0xDB, 1859 0xD4, 0x2E, 0x02, 0x1F, 0xCE, 0xEF, 0x92, 0xB1, 1860 0x1B, 0x56, 0x50, 0xF2, 0x16, 0xE5, 0xE7, 0x4F, 1861 0xFD, 0xBB, 0x3E, 0xD2, 0xFC, 0x3C, 0xC6, 0x0F, 1862 0xF9, 0x12, 0x4E, 0xCB, 0x1E, 0x0C, 0x15, 0x84, 1863 0x2A, 0x14, 0x8A, 0x02, 0xE4, 0x7E, 0x95, 0x5B, 1864 0x86, 0xDB, 0x9B, 0x62, 0x5B, 0x19, 0xD2, 0x17, 1865 0xFA, 0x13, 0xBB, 0x6B, 0x3F, 0x45, 0x9F, 0xBF 1866 }; 1867 1868 1869 static uint8_t ms_hmac_key0[] = { 1870 0xFF, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1, 1871 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA, 1872 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76, 1873 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60, 1874 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1, 1875 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0, 1876 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76, 1877 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60 1878 }; 1879 1880 static const uint8_t ms_hmac_digest0[] = { 1881 0x43, 0x52, 0xED, 0x34, 0xAB, 0x36, 0xB2, 0x51, 1882 0xFB, 0xA3, 0xA6, 0x7C, 0x38, 0xFC, 0x42, 0x8F, 1883 0x57, 0x64, 0xAB, 0x81, 0xA7, 0x89, 0xB7, 0x6C, 1884 0xA0, 0xDC, 0xB9, 0x4D, 0xC4, 0x30, 0xF9, 0xD4, 1885 0x10, 0x82, 0x55, 0xD0, 0xAB, 0x32, 0xFB, 0x56, 1886 0x0D, 0xE4, 0x68, 0x3D, 0x76, 0xD0, 0x7B, 0xE4, 1887 0xA6, 0x2C, 0x34, 0x9E, 0x8C, 0x41, 0xF8, 0x23, 1888 0x28, 0x1B, 0x3A, 0x90, 0x26, 0x34, 0x47, 0x90 1889 }; 1890 1891 /* End Session 0 */ 1892 /* Begin session 1 */ 1893 1894 static uint8_t ms_aes_cbc_key1[] = { 1895 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 1896 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff 1897 }; 1898 1899 static uint8_t ms_aes_cbc_iv1[] = { 1900 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 1901 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff 1902 }; 1903 1904 static const uint8_t ms_aes_cbc_cipher1[] = { 1905 0x5A, 0x7A, 0x67, 0x5D, 0xB8, 0xE1, 0xDC, 0x71, 1906 0x39, 0xA8, 0x74, 0x93, 0x9C, 0x4C, 0xFE, 0x23, 1907 0x61, 0xCD, 0xA4, 0xB3, 0xD9, 0xCE, 0x99, 0x09, 1908 0x2A, 0x23, 0xF3, 0x29, 0xBF, 0x4C, 0xB4, 0x6A, 1909 0x1B, 0x6B, 0x73, 0x4D, 0x48, 0x0C, 0xCF, 0x6C, 1910 0x5E, 0x34, 0x9E, 0x7F, 0xBC, 0x8F, 0xCC, 0x8F, 1911 0x75, 0x1D, 0x3D, 0x77, 0x10, 0x76, 0xC8, 0xB9, 1912 0x99, 0x6F, 0xD6, 0x56, 0x75, 0xA9, 0xB2, 0x66, 1913 0xC2, 0x24, 0x2B, 0x9C, 0xFE, 0x40, 0x8E, 0x43, 1914 0x20, 0x97, 0x1B, 0xFA, 0xD0, 0xCF, 0x04, 0xAB, 1915 0xBB, 0xF6, 0x5D, 0xF5, 0xA0, 0x19, 0x7C, 0x23, 1916 0x5D, 0x80, 0x8C, 0x49, 0xF6, 0x76, 0x88, 0x29, 1917 0x27, 0x4C, 0x59, 0x2B, 0x43, 0xA6, 0xB2, 0x26, 1918 0x27, 0x78, 0xBE, 0x1B, 0xE1, 0x4F, 0x5A, 0x1F, 1919 0xFC, 0x68, 0x08, 0xE7, 0xC4, 0xD1, 0x34, 0x68, 1920 0xB7, 0x13, 0x14, 0x41, 0x62, 0x6B, 0x1F, 0x77, 1921 0x0C, 0x68, 0x1D, 0x0D, 0xED, 0x89, 0xAA, 0xD8, 1922 0x97, 0x02, 0xBA, 0x5E, 0xD4, 0x84, 0x25, 0x97, 1923 0x03, 0xA5, 0xA6, 0x13, 0x66, 0x02, 0xF4, 0xC3, 1924 0xF3, 0xD3, 0xCC, 0x95, 0xC3, 0x87, 0x46, 0x90, 1925 0x1F, 0x6E, 0x14, 0xA8, 0x00, 0xF2, 0x6F, 0xD5, 1926 0xA1, 0xAD, 0xD5, 0x40, 0xA2, 0x0F, 0x32, 0x7E, 1927 0x99, 0xA3, 0xF5, 0x53, 0xC3, 0x26, 0xA1, 0x45, 1928 0x01, 0x88, 0x57, 0x84, 0x3E, 0x7B, 0x4E, 0x0B, 1929 0x3C, 0xB5, 0x3E, 0x9E, 0xE9, 0x78, 0x77, 0xC5, 1930 0xC0, 0x89, 0xA8, 0xF8, 0xF1, 0xA5, 0x2D, 0x5D, 1931 0xF9, 0xC6, 0xFB, 0xCB, 0x05, 0x23, 0xBD, 0x6E, 1932 0x5E, 0x14, 0xC6, 0x57, 0x73, 0xCF, 0x98, 0xBD, 1933 0x10, 0x8B, 0x18, 0xA6, 0x01, 0x5B, 0x13, 0xAE, 1934 0x8E, 0xDE, 0x1F, 0xB5, 0xB7, 0x40, 0x6C, 0xC1, 1935 0x1E, 0xA1, 0x19, 0x20, 0x9E, 0x95, 0xE0, 0x2F, 1936 0x1C, 0xF5, 0xD9, 0xD0, 0x2B, 0x1E, 0x82, 0x25, 1937 0x62, 0xB4, 0xEB, 0xA1, 0x1F, 0xCE, 0x44, 0xA1, 1938 0xCB, 0x92, 0x01, 0x6B, 0xE4, 0x26, 0x23, 0xE3, 1939 0xC5, 0x67, 0x35, 0x55, 0xDA, 0xE5, 0x27, 0xEE, 1940 0x8D, 0x12, 0x84, 0xB7, 0xBA, 0xA7, 0x1C, 0xD6, 1941 0x32, 0x3F, 0x67, 0xED, 0xFB, 0x5B, 0x8B, 0x52, 1942 0x46, 0x8C, 0xF9, 0x69, 0xCD, 0xAE, 0x79, 0xAA, 1943 0x37, 0x78, 0x49, 0xEB, 0xC6, 0x8E, 0x76, 0x63, 1944 0x84, 0xFF, 0x9D, 0x22, 0x99, 0x51, 0xB7, 0x5E, 1945 0x83, 0x4C, 0x8B, 0xDF, 0x5A, 0x07, 0xCC, 0xBA, 1946 0x42, 0xA5, 0x98, 0xB6, 0x47, 0x0E, 0x66, 0xEB, 1947 0x23, 0x0E, 0xBA, 0x44, 0xA8, 0xAA, 0x20, 0x71, 1948 0x79, 0x9C, 0x77, 0x5F, 0xF5, 0xFE, 0xEC, 0xEF, 1949 0xC6, 0x64, 0x3D, 0x84, 0xD0, 0x2B, 0xA7, 0x0A, 1950 0xC3, 0x72, 0x5B, 0x9C, 0xFA, 0xA8, 0x87, 0x95, 1951 0x94, 0x11, 0x38, 0xA7, 0x1E, 0x58, 0xE3, 0x73, 1952 0xC6, 0xC9, 0xD1, 0x7B, 0x92, 0xDB, 0x0F, 0x49, 1953 0x74, 0xC2, 0xA2, 0x0E, 0x35, 0x57, 0xAC, 0xDB, 1954 0x9A, 0x1C, 0xCF, 0x5A, 0x32, 0x3E, 0x26, 0x9B, 1955 0xEC, 0xB3, 0xEF, 0x9C, 0xFE, 0xBE, 0x52, 0xAC, 1956 0xB1, 0x29, 0xDD, 0xFD, 0x07, 0xE2, 0xEE, 0xED, 1957 0xE4, 0x46, 0x37, 0xFE, 0xD1, 0xDC, 0xCD, 0x02, 1958 0xF9, 0x31, 0xB0, 0xFB, 0x36, 0xB7, 0x34, 0xA4, 1959 0x76, 0xE8, 0x57, 0xBF, 0x99, 0x92, 0xC7, 0xAF, 1960 0x98, 0x10, 0xE2, 0x70, 0xCA, 0xC9, 0x2B, 0x82, 1961 0x06, 0x96, 0x88, 0x0D, 0xB3, 0xAC, 0x9E, 0x6D, 1962 0x43, 0xBC, 0x5B, 0x31, 0xCF, 0x65, 0x8D, 0xA6, 1963 0xC7, 0xFE, 0x73, 0xE1, 0x54, 0xF7, 0x10, 0xF9, 1964 0x86, 0xF7, 0xDF, 0xA1, 0xA1, 0xD8, 0xAE, 0x35, 1965 0xB3, 0x90, 0xDC, 0x6F, 0x43, 0x7A, 0x8B, 0xE0, 1966 0xFE, 0x8F, 0x33, 0x4D, 0x29, 0x6C, 0x45, 0x53, 1967 0x73, 0xDD, 0x21, 0x0B, 0x85, 0x30, 0xB5, 0xA5, 1968 0xF3, 0x5D, 0xEC, 0x79, 0x61, 0x9D, 0x9E, 0xB3 1969 1970 }; 1971 1972 static uint8_t ms_hmac_key1[] = { 1973 0xFE, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1, 1974 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA, 1975 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76, 1976 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60, 1977 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1, 1978 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0, 1979 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76, 1980 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60 1981 }; 1982 1983 static const uint8_t ms_hmac_digest1[] = { 1984 0xCE, 0x6E, 0x5F, 0x77, 0x96, 0x9A, 0xB1, 0x69, 1985 0x2D, 0x5E, 0xF3, 0x2F, 0x32, 0x10, 0xCB, 0x50, 1986 0x0E, 0x09, 0x56, 0x25, 0x07, 0x34, 0xC9, 0x20, 1987 0xEC, 0x13, 0x43, 0x23, 0x5C, 0x08, 0x8B, 0xCD, 1988 0xDC, 0x86, 0x8C, 0xEE, 0x0A, 0x95, 0x2E, 0xB9, 1989 0x8C, 0x7B, 0x02, 0x7A, 0xD4, 0xE1, 0x49, 0xB4, 1990 0x45, 0xB5, 0x52, 0x37, 0xC6, 0xFF, 0xFE, 0xAA, 1991 0x0A, 0x87, 0xB8, 0x51, 0xF9, 0x2A, 0x01, 0x8F 1992 }; 1993 /* End Session 1 */ 1994 /* Begin Session 2 */ 1995 static uint8_t ms_aes_cbc_key2[] = { 1996 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 1997 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff 1998 }; 1999 2000 static uint8_t ms_aes_cbc_iv2[] = { 2001 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 2002 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff 2003 }; 2004 2005 static const uint8_t ms_aes_cbc_cipher2[] = { 2006 0xBB, 0x3C, 0x68, 0x25, 0xFD, 0xB6, 0xA2, 0x91, 2007 0x20, 0x56, 0xF6, 0x30, 0x35, 0xFC, 0x9E, 0x97, 2008 0xF2, 0x90, 0xFC, 0x7E, 0x3E, 0x0A, 0x75, 0xC8, 2009 0x4C, 0xF2, 0x2D, 0xAC, 0xD3, 0x93, 0xF0, 0xC5, 2010 0x14, 0x88, 0x8A, 0x23, 0xC2, 0x59, 0x9A, 0x98, 2011 0x4B, 0xD5, 0x2C, 0xDA, 0x43, 0xA9, 0x34, 0x69, 2012 0x7C, 0x6D, 0xDB, 0xDC, 0xCB, 0xC0, 0xA0, 0x09, 2013 0xA7, 0x86, 0x16, 0x4B, 0xBF, 0xA8, 0xB6, 0xCF, 2014 0x7F, 0x74, 0x1F, 0x22, 0xF0, 0xF6, 0xBB, 0x44, 2015 0x8B, 0x4C, 0x9E, 0x23, 0xF8, 0x9F, 0xFC, 0x5B, 2016 0x9E, 0x9C, 0x2A, 0x79, 0x30, 0x8F, 0xBF, 0xA9, 2017 0x68, 0xA1, 0x20, 0x71, 0x7C, 0x77, 0x22, 0x34, 2018 0x07, 0xCD, 0xC6, 0xF6, 0x50, 0x0A, 0x08, 0x99, 2019 0x17, 0x98, 0xE3, 0x93, 0x8A, 0xB0, 0xEE, 0xDF, 2020 0xC2, 0xBA, 0x3B, 0x44, 0x73, 0xDF, 0xDD, 0xDC, 2021 0x14, 0x4D, 0x3B, 0xBB, 0x5E, 0x58, 0xC1, 0x26, 2022 0xA7, 0xAE, 0x47, 0xF3, 0x24, 0x6D, 0x4F, 0xD3, 2023 0x6E, 0x3E, 0x33, 0xE6, 0x7F, 0xCA, 0x50, 0xAF, 2024 0x5D, 0x3D, 0xA0, 0xDD, 0xC9, 0xF3, 0x30, 0xD3, 2025 0x6E, 0x8B, 0x2E, 0x12, 0x24, 0x34, 0xF0, 0xD3, 2026 0xC7, 0x8D, 0x23, 0x29, 0xAA, 0x05, 0xE1, 0xFA, 2027 0x2E, 0xF6, 0x8D, 0x37, 0x86, 0xC0, 0x6D, 0x13, 2028 0x2D, 0x98, 0xF3, 0x52, 0x39, 0x22, 0xCE, 0x38, 2029 0xC2, 0x1A, 0x72, 0xED, 0xFB, 0xCC, 0xE4, 0x71, 2030 0x5A, 0x0C, 0x0D, 0x09, 0xF8, 0xE8, 0x1B, 0xBC, 2031 0x53, 0xC8, 0xD8, 0x8F, 0xE5, 0x98, 0x5A, 0xB1, 2032 0x06, 0xA6, 0x5B, 0xE6, 0xA2, 0x88, 0x21, 0x9E, 2033 0x36, 0xC0, 0x34, 0xF9, 0xFB, 0x3B, 0x0A, 0x22, 2034 0x00, 0x00, 0x39, 0x48, 0x8D, 0x23, 0x74, 0x62, 2035 0x72, 0x91, 0xE6, 0x36, 0xAA, 0x77, 0x9C, 0x72, 2036 0x9D, 0xA8, 0xC3, 0xA9, 0xD5, 0x44, 0x72, 0xA6, 2037 0xB9, 0x28, 0x8F, 0x64, 0x4C, 0x8A, 0x64, 0xE6, 2038 0x4E, 0xFA, 0xEF, 0x87, 0xDE, 0x7B, 0x22, 0x44, 2039 0xB0, 0xDF, 0x2E, 0x5F, 0x0B, 0xA5, 0xF2, 0x24, 2040 0x07, 0x5C, 0x2D, 0x39, 0xB7, 0x3D, 0x8A, 0xE5, 2041 0x0E, 0x9D, 0x4E, 0x50, 0xED, 0x03, 0x99, 0x8E, 2042 0xF0, 0x06, 0x55, 0x4E, 0xA2, 0x24, 0xE7, 0x17, 2043 0x46, 0xDF, 0x6C, 0xCD, 0xC6, 0x44, 0xE8, 0xF9, 2044 0xB9, 0x1B, 0x36, 0xF6, 0x7F, 0x10, 0xA4, 0x7D, 2045 0x90, 0xBD, 0xE4, 0xAA, 0xD6, 0x9E, 0x18, 0x9D, 2046 0x22, 0x35, 0xD6, 0x55, 0x54, 0xAA, 0xF7, 0x22, 2047 0xA3, 0x3E, 0xEF, 0xC8, 0xA2, 0x34, 0x8D, 0xA9, 2048 0x37, 0x63, 0xA6, 0xC3, 0x57, 0xCB, 0x0C, 0x49, 2049 0x7D, 0x02, 0xBE, 0xAA, 0x13, 0x75, 0xB7, 0x4E, 2050 0x52, 0x62, 0xA5, 0xC2, 0x33, 0xC7, 0x6C, 0x1B, 2051 0xF6, 0x34, 0xF6, 0x09, 0xA5, 0x0C, 0xC7, 0xA2, 2052 0x61, 0x48, 0x62, 0x7D, 0x17, 0x15, 0xE3, 0x95, 2053 0xC8, 0x63, 0xD2, 0xA4, 0x43, 0xA9, 0x49, 0x07, 2054 0xB2, 0x3B, 0x2B, 0x62, 0x7D, 0xCB, 0x51, 0xB3, 2055 0x25, 0x33, 0x47, 0x0E, 0x14, 0x67, 0xDC, 0x6A, 2056 0x9B, 0x51, 0xAC, 0x9D, 0x8F, 0xA2, 0x2B, 0x57, 2057 0x8C, 0x5C, 0x5F, 0x76, 0x23, 0x92, 0x0F, 0x84, 2058 0x46, 0x0E, 0x40, 0x85, 0x38, 0x60, 0xFA, 0x61, 2059 0x20, 0xC5, 0xE3, 0xF1, 0x70, 0xAC, 0x1B, 0xBF, 2060 0xC4, 0x2B, 0xC5, 0x67, 0xD1, 0x43, 0xC5, 0x17, 2061 0x74, 0x71, 0x69, 0x6F, 0x82, 0x89, 0x19, 0x8A, 2062 0x70, 0x43, 0x92, 0x01, 0xC4, 0x63, 0x7E, 0xB1, 2063 0x59, 0x4E, 0xCD, 0xEA, 0x93, 0xA4, 0x52, 0x53, 2064 0x9B, 0x61, 0x5B, 0xD2, 0x3E, 0x19, 0x39, 0xB7, 2065 0x32, 0xEA, 0x8E, 0xF8, 0x1D, 0x76, 0x5C, 0xB2, 2066 0x73, 0x2D, 0x91, 0xC0, 0x18, 0xED, 0x25, 0x2A, 2067 0x53, 0x64, 0xF0, 0x92, 0x31, 0x55, 0x21, 0xA8, 2068 0x24, 0xA9, 0xD1, 0x02, 0xF6, 0x6C, 0x2B, 0x70, 2069 0xA9, 0x59, 0xC1, 0xD6, 0xC3, 0x57, 0x5B, 0x92 2070 }; 2071 2072 static uint8_t ms_hmac_key2[] = { 2073 0xFC, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1, 2074 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA, 2075 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76, 2076 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60, 2077 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1, 2078 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0, 2079 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76, 2080 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60 2081 }; 2082 2083 static const uint8_t ms_hmac_digest2[] = { 2084 0xA5, 0x0F, 0x9C, 0xFB, 0x08, 0x62, 0x59, 0xFF, 2085 0x80, 0x2F, 0xEB, 0x4B, 0xE1, 0x46, 0x21, 0xD6, 2086 0x02, 0x98, 0xF2, 0x8E, 0xF4, 0xEC, 0xD4, 0x77, 2087 0x86, 0x4C, 0x31, 0x28, 0xC8, 0x25, 0x80, 0x27, 2088 0x3A, 0x72, 0x5D, 0x6A, 0x56, 0x8A, 0xD3, 0x82, 2089 0xB0, 0xEC, 0x31, 0x6D, 0x8B, 0x6B, 0xB4, 0x24, 2090 0xE7, 0x62, 0xC1, 0x52, 0xBC, 0x14, 0x1B, 0x8E, 2091 0xEC, 0x9A, 0xF1, 0x47, 0x80, 0xD2, 0xB0, 0x59 2092 }; 2093 2094 /* End Session 2 */ 2095 2096 2097 static int 2098 test_AES_CBC_HMAC_SHA1_encrypt_digest(void) 2099 { 2100 struct crypto_testsuite_params *ts_params = &testsuite_params; 2101 struct crypto_unittest_params *ut_params = &unittest_params; 2102 2103 /* Verify the capabilities */ 2104 struct rte_cryptodev_sym_capability_idx cap_idx; 2105 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; 2106 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC; 2107 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 2108 &cap_idx) == NULL) 2109 return TEST_SKIPPED; 2110 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 2111 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC; 2112 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 2113 &cap_idx) == NULL) 2114 return TEST_SKIPPED; 2115 2116 /* Generate test mbuf data and space for digest */ 2117 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool, 2118 catch_22_quote, QUOTE_512_BYTES, 0); 2119 2120 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 2121 DIGEST_BYTE_LENGTH_SHA1); 2122 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest"); 2123 2124 /* Setup Cipher Parameters */ 2125 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 2126 ut_params->cipher_xform.next = &ut_params->auth_xform; 2127 2128 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC; 2129 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; 2130 ut_params->cipher_xform.cipher.key.data = aes_cbc_key; 2131 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC; 2132 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET; 2133 ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC; 2134 2135 /* Setup HMAC Parameters */ 2136 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 2137 2138 ut_params->auth_xform.next = NULL; 2139 2140 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; 2141 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC; 2142 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1; 2143 ut_params->auth_xform.auth.key.data = hmac_sha1_key; 2144 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1; 2145 2146 ut_params->sess = rte_cryptodev_sym_session_create( 2147 ts_params->session_mpool); 2148 2149 /* Create crypto session*/ 2150 rte_cryptodev_sym_session_init(ts_params->valid_devs[0], 2151 ut_params->sess, &ut_params->cipher_xform, 2152 ts_params->session_priv_mpool); 2153 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 2154 2155 /* Generate crypto op data structure */ 2156 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 2157 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 2158 TEST_ASSERT_NOT_NULL(ut_params->op, 2159 "Failed to allocate symmetric crypto operation struct"); 2160 2161 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 2162 2163 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 2164 2165 /* set crypto operation source mbuf */ 2166 sym_op->m_src = ut_params->ibuf; 2167 2168 /* Set crypto operation authentication parameters */ 2169 sym_op->auth.digest.data = ut_params->digest; 2170 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( 2171 ut_params->ibuf, QUOTE_512_BYTES); 2172 2173 sym_op->auth.data.offset = 0; 2174 sym_op->auth.data.length = QUOTE_512_BYTES; 2175 2176 /* Copy IV at the end of the crypto operation */ 2177 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET), 2178 aes_cbc_iv, CIPHER_IV_LENGTH_AES_CBC); 2179 2180 /* Set crypto operation cipher parameters */ 2181 sym_op->cipher.data.offset = 0; 2182 sym_op->cipher.data.length = QUOTE_512_BYTES; 2183 2184 /* Process crypto operation */ 2185 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 2186 process_cpu_crypt_auth_op(ts_params->valid_devs[0], 2187 ut_params->op); 2188 else 2189 TEST_ASSERT_NOT_NULL( 2190 process_crypto_request(ts_params->valid_devs[0], 2191 ut_params->op), 2192 "failed to process sym crypto op"); 2193 2194 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 2195 "crypto op processing failed"); 2196 2197 /* Validate obuf */ 2198 uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src, 2199 uint8_t *); 2200 2201 TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext, 2202 catch_22_quote_2_512_bytes_AES_CBC_ciphertext, 2203 QUOTE_512_BYTES, 2204 "ciphertext data not as expected"); 2205 2206 uint8_t *digest = ciphertext + QUOTE_512_BYTES; 2207 2208 TEST_ASSERT_BUFFERS_ARE_EQUAL(digest, 2209 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest, 2210 gbl_driver_id == rte_cryptodev_driver_id_get( 2211 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) ? 2212 TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 : 2213 DIGEST_BYTE_LENGTH_SHA1, 2214 "Generated digest data not as expected"); 2215 2216 return TEST_SUCCESS; 2217 } 2218 2219 /* ***** AES-CBC / HMAC-SHA512 Hash Tests ***** */ 2220 2221 #define HMAC_KEY_LENGTH_SHA512 (DIGEST_BYTE_LENGTH_SHA512) 2222 2223 static uint8_t hmac_sha512_key[] = { 2224 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1, 2225 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA, 2226 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76, 2227 0x9a, 0xaf, 0x88, 0x1b, 0xb6, 0x8f, 0xf8, 0x60, 2228 0xa2, 0x5a, 0x7f, 0x3f, 0xf4, 0x72, 0x70, 0xf1, 2229 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0, 2230 0x47, 0x3a, 0x75, 0x61, 0x5C, 0xa2, 0x10, 0x76, 2231 0x9a, 0xaf, 0x77, 0x5b, 0xb6, 0x7f, 0xf7, 0x60 }; 2232 2233 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest[] = { 2234 0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8, 2235 0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48, 2236 0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8, 2237 0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70, 2238 0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8, 2239 0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E, 2240 0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D, 2241 0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A }; 2242 2243 2244 2245 static int 2246 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params( 2247 struct crypto_unittest_params *ut_params, 2248 uint8_t *cipher_key, 2249 uint8_t *hmac_key); 2250 2251 static int 2252 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess, 2253 struct crypto_unittest_params *ut_params, 2254 struct crypto_testsuite_params *ts_params, 2255 const uint8_t *cipher, 2256 const uint8_t *digest, 2257 const uint8_t *iv); 2258 2259 2260 static int 2261 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params( 2262 struct crypto_unittest_params *ut_params, 2263 uint8_t *cipher_key, 2264 uint8_t *hmac_key) 2265 { 2266 2267 /* Setup Cipher Parameters */ 2268 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 2269 ut_params->cipher_xform.next = NULL; 2270 2271 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC; 2272 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT; 2273 ut_params->cipher_xform.cipher.key.data = cipher_key; 2274 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC; 2275 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET; 2276 ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC; 2277 2278 /* Setup HMAC Parameters */ 2279 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 2280 ut_params->auth_xform.next = &ut_params->cipher_xform; 2281 2282 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY; 2283 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC; 2284 ut_params->auth_xform.auth.key.data = hmac_key; 2285 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512; 2286 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512; 2287 2288 return TEST_SUCCESS; 2289 } 2290 2291 2292 static int 2293 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess, 2294 struct crypto_unittest_params *ut_params, 2295 struct crypto_testsuite_params *ts_params, 2296 const uint8_t *cipher, 2297 const uint8_t *digest, 2298 const uint8_t *iv) 2299 { 2300 /* Generate test mbuf data and digest */ 2301 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool, 2302 (const char *) 2303 cipher, 2304 QUOTE_512_BYTES, 0); 2305 2306 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 2307 DIGEST_BYTE_LENGTH_SHA512); 2308 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest"); 2309 2310 rte_memcpy(ut_params->digest, 2311 digest, 2312 DIGEST_BYTE_LENGTH_SHA512); 2313 2314 /* Generate Crypto op data structure */ 2315 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 2316 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 2317 TEST_ASSERT_NOT_NULL(ut_params->op, 2318 "Failed to allocate symmetric crypto operation struct"); 2319 2320 rte_crypto_op_attach_sym_session(ut_params->op, sess); 2321 2322 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 2323 2324 /* set crypto operation source mbuf */ 2325 sym_op->m_src = ut_params->ibuf; 2326 2327 sym_op->auth.digest.data = ut_params->digest; 2328 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( 2329 ut_params->ibuf, QUOTE_512_BYTES); 2330 2331 sym_op->auth.data.offset = 0; 2332 sym_op->auth.data.length = QUOTE_512_BYTES; 2333 2334 /* Copy IV at the end of the crypto operation */ 2335 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET), 2336 iv, CIPHER_IV_LENGTH_AES_CBC); 2337 2338 sym_op->cipher.data.offset = 0; 2339 sym_op->cipher.data.length = QUOTE_512_BYTES; 2340 2341 /* Process crypto operation */ 2342 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 2343 process_cpu_crypt_auth_op(ts_params->valid_devs[0], 2344 ut_params->op); 2345 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 2346 process_sym_raw_dp_op(ts_params->valid_devs[0], 0, 2347 ut_params->op, 1, 1, 0, 0); 2348 else 2349 TEST_ASSERT_NOT_NULL( 2350 process_crypto_request(ts_params->valid_devs[0], 2351 ut_params->op), 2352 "failed to process sym crypto op"); 2353 2354 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 2355 "crypto op processing failed"); 2356 2357 ut_params->obuf = ut_params->op->sym->m_src; 2358 2359 /* Validate obuf */ 2360 TEST_ASSERT_BUFFERS_ARE_EQUAL( 2361 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 2362 catch_22_quote, 2363 QUOTE_512_BYTES, 2364 "Plaintext data not as expected"); 2365 2366 /* Validate obuf */ 2367 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 2368 "Digest verification failed"); 2369 2370 return TEST_SUCCESS; 2371 } 2372 2373 /* ***** SNOW 3G Tests ***** */ 2374 static int 2375 create_wireless_algo_hash_session(uint8_t dev_id, 2376 const uint8_t *key, const uint8_t key_len, 2377 const uint8_t iv_len, const uint8_t auth_len, 2378 enum rte_crypto_auth_operation op, 2379 enum rte_crypto_auth_algorithm algo) 2380 { 2381 uint8_t hash_key[key_len]; 2382 int status; 2383 2384 struct crypto_testsuite_params *ts_params = &testsuite_params; 2385 struct crypto_unittest_params *ut_params = &unittest_params; 2386 2387 memcpy(hash_key, key, key_len); 2388 2389 debug_hexdump(stdout, "key:", key, key_len); 2390 2391 /* Setup Authentication Parameters */ 2392 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 2393 ut_params->auth_xform.next = NULL; 2394 2395 ut_params->auth_xform.auth.op = op; 2396 ut_params->auth_xform.auth.algo = algo; 2397 ut_params->auth_xform.auth.key.length = key_len; 2398 ut_params->auth_xform.auth.key.data = hash_key; 2399 ut_params->auth_xform.auth.digest_length = auth_len; 2400 ut_params->auth_xform.auth.iv.offset = IV_OFFSET; 2401 ut_params->auth_xform.auth.iv.length = iv_len; 2402 ut_params->sess = rte_cryptodev_sym_session_create( 2403 ts_params->session_mpool); 2404 2405 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess, 2406 &ut_params->auth_xform, 2407 ts_params->session_priv_mpool); 2408 if (status == -ENOTSUP) 2409 return TEST_SKIPPED; 2410 2411 TEST_ASSERT_EQUAL(status, 0, "session init failed"); 2412 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 2413 return 0; 2414 } 2415 2416 static int 2417 create_wireless_algo_cipher_session(uint8_t dev_id, 2418 enum rte_crypto_cipher_operation op, 2419 enum rte_crypto_cipher_algorithm algo, 2420 const uint8_t *key, const uint8_t key_len, 2421 uint8_t iv_len) 2422 { 2423 uint8_t cipher_key[key_len]; 2424 int status; 2425 struct crypto_testsuite_params *ts_params = &testsuite_params; 2426 struct crypto_unittest_params *ut_params = &unittest_params; 2427 2428 memcpy(cipher_key, key, key_len); 2429 2430 /* Setup Cipher Parameters */ 2431 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 2432 ut_params->cipher_xform.next = NULL; 2433 2434 ut_params->cipher_xform.cipher.algo = algo; 2435 ut_params->cipher_xform.cipher.op = op; 2436 ut_params->cipher_xform.cipher.key.data = cipher_key; 2437 ut_params->cipher_xform.cipher.key.length = key_len; 2438 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET; 2439 ut_params->cipher_xform.cipher.iv.length = iv_len; 2440 2441 debug_hexdump(stdout, "key:", key, key_len); 2442 2443 /* Create Crypto session */ 2444 ut_params->sess = rte_cryptodev_sym_session_create( 2445 ts_params->session_mpool); 2446 2447 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess, 2448 &ut_params->cipher_xform, 2449 ts_params->session_priv_mpool); 2450 if (status == -ENOTSUP) 2451 return TEST_SKIPPED; 2452 2453 TEST_ASSERT_EQUAL(status, 0, "session init failed"); 2454 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 2455 return 0; 2456 } 2457 2458 static int 2459 create_wireless_algo_cipher_operation(const uint8_t *iv, uint8_t iv_len, 2460 unsigned int cipher_len, 2461 unsigned int cipher_offset) 2462 { 2463 struct crypto_testsuite_params *ts_params = &testsuite_params; 2464 struct crypto_unittest_params *ut_params = &unittest_params; 2465 2466 /* Generate Crypto op data structure */ 2467 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 2468 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 2469 TEST_ASSERT_NOT_NULL(ut_params->op, 2470 "Failed to allocate pktmbuf offload"); 2471 2472 /* Set crypto operation data parameters */ 2473 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 2474 2475 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 2476 2477 /* set crypto operation source mbuf */ 2478 sym_op->m_src = ut_params->ibuf; 2479 2480 /* iv */ 2481 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET), 2482 iv, iv_len); 2483 sym_op->cipher.data.length = cipher_len; 2484 sym_op->cipher.data.offset = cipher_offset; 2485 return 0; 2486 } 2487 2488 static int 2489 create_wireless_algo_cipher_operation_oop(const uint8_t *iv, uint8_t iv_len, 2490 unsigned int cipher_len, 2491 unsigned int cipher_offset) 2492 { 2493 struct crypto_testsuite_params *ts_params = &testsuite_params; 2494 struct crypto_unittest_params *ut_params = &unittest_params; 2495 2496 /* Generate Crypto op data structure */ 2497 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 2498 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 2499 TEST_ASSERT_NOT_NULL(ut_params->op, 2500 "Failed to allocate pktmbuf offload"); 2501 2502 /* Set crypto operation data parameters */ 2503 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 2504 2505 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 2506 2507 /* set crypto operation source mbuf */ 2508 sym_op->m_src = ut_params->ibuf; 2509 sym_op->m_dst = ut_params->obuf; 2510 2511 /* iv */ 2512 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET), 2513 iv, iv_len); 2514 sym_op->cipher.data.length = cipher_len; 2515 sym_op->cipher.data.offset = cipher_offset; 2516 return 0; 2517 } 2518 2519 static int 2520 create_wireless_algo_cipher_auth_session(uint8_t dev_id, 2521 enum rte_crypto_cipher_operation cipher_op, 2522 enum rte_crypto_auth_operation auth_op, 2523 enum rte_crypto_auth_algorithm auth_algo, 2524 enum rte_crypto_cipher_algorithm cipher_algo, 2525 const uint8_t *key, uint8_t key_len, 2526 uint8_t auth_iv_len, uint8_t auth_len, 2527 uint8_t cipher_iv_len) 2528 2529 { 2530 uint8_t cipher_auth_key[key_len]; 2531 int status; 2532 2533 struct crypto_testsuite_params *ts_params = &testsuite_params; 2534 struct crypto_unittest_params *ut_params = &unittest_params; 2535 2536 memcpy(cipher_auth_key, key, key_len); 2537 2538 /* Setup Authentication Parameters */ 2539 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 2540 ut_params->auth_xform.next = NULL; 2541 2542 ut_params->auth_xform.auth.op = auth_op; 2543 ut_params->auth_xform.auth.algo = auth_algo; 2544 ut_params->auth_xform.auth.key.length = key_len; 2545 /* Hash key = cipher key */ 2546 ut_params->auth_xform.auth.key.data = cipher_auth_key; 2547 ut_params->auth_xform.auth.digest_length = auth_len; 2548 /* Auth IV will be after cipher IV */ 2549 ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len; 2550 ut_params->auth_xform.auth.iv.length = auth_iv_len; 2551 2552 /* Setup Cipher Parameters */ 2553 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 2554 ut_params->cipher_xform.next = &ut_params->auth_xform; 2555 2556 ut_params->cipher_xform.cipher.algo = cipher_algo; 2557 ut_params->cipher_xform.cipher.op = cipher_op; 2558 ut_params->cipher_xform.cipher.key.data = cipher_auth_key; 2559 ut_params->cipher_xform.cipher.key.length = key_len; 2560 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET; 2561 ut_params->cipher_xform.cipher.iv.length = cipher_iv_len; 2562 2563 debug_hexdump(stdout, "key:", key, key_len); 2564 2565 /* Create Crypto session*/ 2566 ut_params->sess = rte_cryptodev_sym_session_create( 2567 ts_params->session_mpool); 2568 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 2569 2570 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess, 2571 &ut_params->cipher_xform, 2572 ts_params->session_priv_mpool); 2573 if (status == -ENOTSUP) 2574 return TEST_SKIPPED; 2575 2576 TEST_ASSERT_EQUAL(status, 0, "session init failed"); 2577 return 0; 2578 } 2579 2580 static int 2581 create_wireless_cipher_auth_session(uint8_t dev_id, 2582 enum rte_crypto_cipher_operation cipher_op, 2583 enum rte_crypto_auth_operation auth_op, 2584 enum rte_crypto_auth_algorithm auth_algo, 2585 enum rte_crypto_cipher_algorithm cipher_algo, 2586 const struct wireless_test_data *tdata) 2587 { 2588 const uint8_t key_len = tdata->key.len; 2589 uint8_t cipher_auth_key[key_len]; 2590 int status; 2591 2592 struct crypto_testsuite_params *ts_params = &testsuite_params; 2593 struct crypto_unittest_params *ut_params = &unittest_params; 2594 const uint8_t *key = tdata->key.data; 2595 const uint8_t auth_len = tdata->digest.len; 2596 uint8_t cipher_iv_len = tdata->cipher_iv.len; 2597 uint8_t auth_iv_len = tdata->auth_iv.len; 2598 2599 memcpy(cipher_auth_key, key, key_len); 2600 2601 /* Setup Authentication Parameters */ 2602 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 2603 ut_params->auth_xform.next = NULL; 2604 2605 ut_params->auth_xform.auth.op = auth_op; 2606 ut_params->auth_xform.auth.algo = auth_algo; 2607 ut_params->auth_xform.auth.key.length = key_len; 2608 /* Hash key = cipher key */ 2609 ut_params->auth_xform.auth.key.data = cipher_auth_key; 2610 ut_params->auth_xform.auth.digest_length = auth_len; 2611 /* Auth IV will be after cipher IV */ 2612 ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len; 2613 ut_params->auth_xform.auth.iv.length = auth_iv_len; 2614 2615 /* Setup Cipher Parameters */ 2616 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 2617 ut_params->cipher_xform.next = &ut_params->auth_xform; 2618 2619 ut_params->cipher_xform.cipher.algo = cipher_algo; 2620 ut_params->cipher_xform.cipher.op = cipher_op; 2621 ut_params->cipher_xform.cipher.key.data = cipher_auth_key; 2622 ut_params->cipher_xform.cipher.key.length = key_len; 2623 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET; 2624 ut_params->cipher_xform.cipher.iv.length = cipher_iv_len; 2625 2626 2627 debug_hexdump(stdout, "key:", key, key_len); 2628 2629 /* Create Crypto session*/ 2630 ut_params->sess = rte_cryptodev_sym_session_create( 2631 ts_params->session_mpool); 2632 2633 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess, 2634 &ut_params->cipher_xform, 2635 ts_params->session_priv_mpool); 2636 if (status == -ENOTSUP) 2637 return TEST_SKIPPED; 2638 2639 TEST_ASSERT_EQUAL(status, 0, "session init failed"); 2640 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 2641 return 0; 2642 } 2643 2644 static int 2645 create_zuc_cipher_auth_encrypt_generate_session(uint8_t dev_id, 2646 const struct wireless_test_data *tdata) 2647 { 2648 return create_wireless_cipher_auth_session(dev_id, 2649 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 2650 RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_ZUC_EIA3, 2651 RTE_CRYPTO_CIPHER_ZUC_EEA3, tdata); 2652 } 2653 2654 static int 2655 create_wireless_algo_auth_cipher_session(uint8_t dev_id, 2656 enum rte_crypto_cipher_operation cipher_op, 2657 enum rte_crypto_auth_operation auth_op, 2658 enum rte_crypto_auth_algorithm auth_algo, 2659 enum rte_crypto_cipher_algorithm cipher_algo, 2660 const uint8_t *key, const uint8_t key_len, 2661 uint8_t auth_iv_len, uint8_t auth_len, 2662 uint8_t cipher_iv_len) 2663 { 2664 uint8_t auth_cipher_key[key_len]; 2665 int status; 2666 struct crypto_testsuite_params *ts_params = &testsuite_params; 2667 struct crypto_unittest_params *ut_params = &unittest_params; 2668 2669 memcpy(auth_cipher_key, key, key_len); 2670 2671 /* Setup Authentication Parameters */ 2672 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 2673 ut_params->auth_xform.auth.op = auth_op; 2674 ut_params->auth_xform.next = &ut_params->cipher_xform; 2675 ut_params->auth_xform.auth.algo = auth_algo; 2676 ut_params->auth_xform.auth.key.length = key_len; 2677 ut_params->auth_xform.auth.key.data = auth_cipher_key; 2678 ut_params->auth_xform.auth.digest_length = auth_len; 2679 /* Auth IV will be after cipher IV */ 2680 ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len; 2681 ut_params->auth_xform.auth.iv.length = auth_iv_len; 2682 2683 /* Setup Cipher Parameters */ 2684 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 2685 ut_params->cipher_xform.next = NULL; 2686 ut_params->cipher_xform.cipher.algo = cipher_algo; 2687 ut_params->cipher_xform.cipher.op = cipher_op; 2688 ut_params->cipher_xform.cipher.key.data = auth_cipher_key; 2689 ut_params->cipher_xform.cipher.key.length = key_len; 2690 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET; 2691 ut_params->cipher_xform.cipher.iv.length = cipher_iv_len; 2692 2693 debug_hexdump(stdout, "key:", key, key_len); 2694 2695 /* Create Crypto session*/ 2696 ut_params->sess = rte_cryptodev_sym_session_create( 2697 ts_params->session_mpool); 2698 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 2699 2700 if (cipher_op == RTE_CRYPTO_CIPHER_OP_DECRYPT) { 2701 ut_params->auth_xform.next = NULL; 2702 ut_params->cipher_xform.next = &ut_params->auth_xform; 2703 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess, 2704 &ut_params->cipher_xform, 2705 ts_params->session_priv_mpool); 2706 2707 } else 2708 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess, 2709 &ut_params->auth_xform, 2710 ts_params->session_priv_mpool); 2711 2712 if (status == -ENOTSUP) 2713 return TEST_SKIPPED; 2714 2715 TEST_ASSERT_EQUAL(status, 0, "session init failed"); 2716 2717 return 0; 2718 } 2719 2720 static int 2721 create_wireless_algo_hash_operation(const uint8_t *auth_tag, 2722 unsigned int auth_tag_len, 2723 const uint8_t *iv, unsigned int iv_len, 2724 unsigned int data_pad_len, 2725 enum rte_crypto_auth_operation op, 2726 unsigned int auth_len, unsigned int auth_offset) 2727 { 2728 struct crypto_testsuite_params *ts_params = &testsuite_params; 2729 2730 struct crypto_unittest_params *ut_params = &unittest_params; 2731 2732 /* Generate Crypto op data structure */ 2733 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 2734 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 2735 TEST_ASSERT_NOT_NULL(ut_params->op, 2736 "Failed to allocate pktmbuf offload"); 2737 2738 /* Set crypto operation data parameters */ 2739 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 2740 2741 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 2742 2743 /* set crypto operation source mbuf */ 2744 sym_op->m_src = ut_params->ibuf; 2745 2746 /* iv */ 2747 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET), 2748 iv, iv_len); 2749 /* digest */ 2750 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( 2751 ut_params->ibuf, auth_tag_len); 2752 2753 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, 2754 "no room to append auth tag"); 2755 ut_params->digest = sym_op->auth.digest.data; 2756 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( 2757 ut_params->ibuf, data_pad_len); 2758 if (op == RTE_CRYPTO_AUTH_OP_GENERATE) 2759 memset(sym_op->auth.digest.data, 0, auth_tag_len); 2760 else 2761 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len); 2762 2763 debug_hexdump(stdout, "digest:", 2764 sym_op->auth.digest.data, 2765 auth_tag_len); 2766 2767 sym_op->auth.data.length = auth_len; 2768 sym_op->auth.data.offset = auth_offset; 2769 2770 return 0; 2771 } 2772 2773 static int 2774 create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata, 2775 enum rte_crypto_auth_operation op) 2776 { 2777 struct crypto_testsuite_params *ts_params = &testsuite_params; 2778 struct crypto_unittest_params *ut_params = &unittest_params; 2779 2780 const uint8_t *auth_tag = tdata->digest.data; 2781 const unsigned int auth_tag_len = tdata->digest.len; 2782 unsigned int plaintext_len = ceil_byte_length(tdata->plaintext.len); 2783 unsigned int data_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); 2784 2785 const uint8_t *cipher_iv = tdata->cipher_iv.data; 2786 const uint8_t cipher_iv_len = tdata->cipher_iv.len; 2787 const uint8_t *auth_iv = tdata->auth_iv.data; 2788 const uint8_t auth_iv_len = tdata->auth_iv.len; 2789 const unsigned int cipher_len = tdata->validCipherLenInBits.len; 2790 const unsigned int auth_len = tdata->validAuthLenInBits.len; 2791 2792 /* Generate Crypto op data structure */ 2793 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 2794 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 2795 TEST_ASSERT_NOT_NULL(ut_params->op, 2796 "Failed to allocate pktmbuf offload"); 2797 /* Set crypto operation data parameters */ 2798 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 2799 2800 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 2801 2802 /* set crypto operation source mbuf */ 2803 sym_op->m_src = ut_params->ibuf; 2804 2805 /* digest */ 2806 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( 2807 ut_params->ibuf, auth_tag_len); 2808 2809 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, 2810 "no room to append auth tag"); 2811 ut_params->digest = sym_op->auth.digest.data; 2812 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( 2813 ut_params->ibuf, data_pad_len); 2814 if (op == RTE_CRYPTO_AUTH_OP_GENERATE) 2815 memset(sym_op->auth.digest.data, 0, auth_tag_len); 2816 else 2817 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len); 2818 2819 debug_hexdump(stdout, "digest:", 2820 sym_op->auth.digest.data, 2821 auth_tag_len); 2822 2823 /* Copy cipher and auth IVs at the end of the crypto operation */ 2824 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, 2825 IV_OFFSET); 2826 rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len); 2827 iv_ptr += cipher_iv_len; 2828 rte_memcpy(iv_ptr, auth_iv, auth_iv_len); 2829 2830 sym_op->cipher.data.length = cipher_len; 2831 sym_op->cipher.data.offset = 0; 2832 sym_op->auth.data.length = auth_len; 2833 sym_op->auth.data.offset = 0; 2834 2835 return 0; 2836 } 2837 2838 static int 2839 create_zuc_cipher_hash_generate_operation( 2840 const struct wireless_test_data *tdata) 2841 { 2842 return create_wireless_cipher_hash_operation(tdata, 2843 RTE_CRYPTO_AUTH_OP_GENERATE); 2844 } 2845 2846 static int 2847 create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag, 2848 const unsigned auth_tag_len, 2849 const uint8_t *auth_iv, uint8_t auth_iv_len, 2850 unsigned data_pad_len, 2851 enum rte_crypto_auth_operation op, 2852 const uint8_t *cipher_iv, uint8_t cipher_iv_len, 2853 const unsigned cipher_len, const unsigned cipher_offset, 2854 const unsigned auth_len, const unsigned auth_offset) 2855 { 2856 struct crypto_testsuite_params *ts_params = &testsuite_params; 2857 struct crypto_unittest_params *ut_params = &unittest_params; 2858 2859 enum rte_crypto_cipher_algorithm cipher_algo = 2860 ut_params->cipher_xform.cipher.algo; 2861 enum rte_crypto_auth_algorithm auth_algo = 2862 ut_params->auth_xform.auth.algo; 2863 2864 /* Generate Crypto op data structure */ 2865 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 2866 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 2867 TEST_ASSERT_NOT_NULL(ut_params->op, 2868 "Failed to allocate pktmbuf offload"); 2869 /* Set crypto operation data parameters */ 2870 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 2871 2872 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 2873 2874 /* set crypto operation source mbuf */ 2875 sym_op->m_src = ut_params->ibuf; 2876 2877 /* digest */ 2878 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( 2879 ut_params->ibuf, auth_tag_len); 2880 2881 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, 2882 "no room to append auth tag"); 2883 ut_params->digest = sym_op->auth.digest.data; 2884 2885 if (rte_pktmbuf_is_contiguous(ut_params->ibuf)) { 2886 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( 2887 ut_params->ibuf, data_pad_len); 2888 } else { 2889 struct rte_mbuf *m = ut_params->ibuf; 2890 unsigned int offset = data_pad_len; 2891 2892 while (offset > m->data_len && m->next != NULL) { 2893 offset -= m->data_len; 2894 m = m->next; 2895 } 2896 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( 2897 m, offset); 2898 } 2899 2900 if (op == RTE_CRYPTO_AUTH_OP_GENERATE) 2901 memset(sym_op->auth.digest.data, 0, auth_tag_len); 2902 else 2903 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len); 2904 2905 debug_hexdump(stdout, "digest:", 2906 sym_op->auth.digest.data, 2907 auth_tag_len); 2908 2909 /* Copy cipher and auth IVs at the end of the crypto operation */ 2910 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, 2911 IV_OFFSET); 2912 rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len); 2913 iv_ptr += cipher_iv_len; 2914 rte_memcpy(iv_ptr, auth_iv, auth_iv_len); 2915 2916 if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 || 2917 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 || 2918 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) { 2919 sym_op->cipher.data.length = cipher_len; 2920 sym_op->cipher.data.offset = cipher_offset; 2921 } else { 2922 sym_op->cipher.data.length = cipher_len >> 3; 2923 sym_op->cipher.data.offset = cipher_offset >> 3; 2924 } 2925 2926 if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 || 2927 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 || 2928 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) { 2929 sym_op->auth.data.length = auth_len; 2930 sym_op->auth.data.offset = auth_offset; 2931 } else { 2932 sym_op->auth.data.length = auth_len >> 3; 2933 sym_op->auth.data.offset = auth_offset >> 3; 2934 } 2935 2936 return 0; 2937 } 2938 2939 static int 2940 create_wireless_algo_auth_cipher_operation( 2941 const uint8_t *auth_tag, unsigned int auth_tag_len, 2942 const uint8_t *cipher_iv, uint8_t cipher_iv_len, 2943 const uint8_t *auth_iv, uint8_t auth_iv_len, 2944 unsigned int data_pad_len, 2945 unsigned int cipher_len, unsigned int cipher_offset, 2946 unsigned int auth_len, unsigned int auth_offset, 2947 uint8_t op_mode, uint8_t do_sgl, uint8_t verify) 2948 { 2949 struct crypto_testsuite_params *ts_params = &testsuite_params; 2950 struct crypto_unittest_params *ut_params = &unittest_params; 2951 2952 enum rte_crypto_cipher_algorithm cipher_algo = 2953 ut_params->cipher_xform.cipher.algo; 2954 enum rte_crypto_auth_algorithm auth_algo = 2955 ut_params->auth_xform.auth.algo; 2956 2957 /* Generate Crypto op data structure */ 2958 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 2959 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 2960 TEST_ASSERT_NOT_NULL(ut_params->op, 2961 "Failed to allocate pktmbuf offload"); 2962 2963 /* Set crypto operation data parameters */ 2964 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 2965 2966 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 2967 2968 /* set crypto operation mbufs */ 2969 sym_op->m_src = ut_params->ibuf; 2970 if (op_mode == OUT_OF_PLACE) 2971 sym_op->m_dst = ut_params->obuf; 2972 2973 /* digest */ 2974 if (!do_sgl) { 2975 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset( 2976 (op_mode == IN_PLACE ? 2977 ut_params->ibuf : ut_params->obuf), 2978 uint8_t *, data_pad_len); 2979 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( 2980 (op_mode == IN_PLACE ? 2981 ut_params->ibuf : ut_params->obuf), 2982 data_pad_len); 2983 memset(sym_op->auth.digest.data, 0, auth_tag_len); 2984 } else { 2985 uint16_t remaining_off = (auth_offset >> 3) + (auth_len >> 3); 2986 struct rte_mbuf *sgl_buf = (op_mode == IN_PLACE ? 2987 sym_op->m_src : sym_op->m_dst); 2988 while (remaining_off >= rte_pktmbuf_data_len(sgl_buf)) { 2989 remaining_off -= rte_pktmbuf_data_len(sgl_buf); 2990 sgl_buf = sgl_buf->next; 2991 } 2992 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(sgl_buf, 2993 uint8_t *, remaining_off); 2994 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(sgl_buf, 2995 remaining_off); 2996 memset(sym_op->auth.digest.data, 0, remaining_off); 2997 while (sgl_buf->next != NULL) { 2998 memset(rte_pktmbuf_mtod(sgl_buf, uint8_t *), 2999 0, rte_pktmbuf_data_len(sgl_buf)); 3000 sgl_buf = sgl_buf->next; 3001 } 3002 } 3003 3004 /* Copy digest for the verification */ 3005 if (verify) 3006 memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len); 3007 3008 /* Copy cipher and auth IVs at the end of the crypto operation */ 3009 uint8_t *iv_ptr = rte_crypto_op_ctod_offset( 3010 ut_params->op, uint8_t *, IV_OFFSET); 3011 3012 rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len); 3013 iv_ptr += cipher_iv_len; 3014 rte_memcpy(iv_ptr, auth_iv, auth_iv_len); 3015 3016 /* Only copy over the offset data needed from src to dst in OOP, 3017 * if the auth and cipher offsets are not aligned 3018 */ 3019 if (op_mode == OUT_OF_PLACE) { 3020 if (cipher_offset > auth_offset) 3021 rte_memcpy( 3022 rte_pktmbuf_mtod_offset( 3023 sym_op->m_dst, 3024 uint8_t *, auth_offset >> 3), 3025 rte_pktmbuf_mtod_offset( 3026 sym_op->m_src, 3027 uint8_t *, auth_offset >> 3), 3028 ((cipher_offset >> 3) - (auth_offset >> 3))); 3029 } 3030 3031 if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 || 3032 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 || 3033 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) { 3034 sym_op->cipher.data.length = cipher_len; 3035 sym_op->cipher.data.offset = cipher_offset; 3036 } else { 3037 sym_op->cipher.data.length = cipher_len >> 3; 3038 sym_op->cipher.data.offset = cipher_offset >> 3; 3039 } 3040 3041 if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 || 3042 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 || 3043 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) { 3044 sym_op->auth.data.length = auth_len; 3045 sym_op->auth.data.offset = auth_offset; 3046 } else { 3047 sym_op->auth.data.length = auth_len >> 3; 3048 sym_op->auth.data.offset = auth_offset >> 3; 3049 } 3050 3051 return 0; 3052 } 3053 3054 static int 3055 test_snow3g_authentication(const struct snow3g_hash_test_data *tdata) 3056 { 3057 struct crypto_testsuite_params *ts_params = &testsuite_params; 3058 struct crypto_unittest_params *ut_params = &unittest_params; 3059 3060 int retval; 3061 unsigned plaintext_pad_len; 3062 unsigned plaintext_len; 3063 uint8_t *plaintext; 3064 struct rte_cryptodev_info dev_info; 3065 3066 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 3067 uint64_t feat_flags = dev_info.feature_flags; 3068 3069 if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) && 3070 ((tdata->validAuthLenInBits.len % 8) != 0)) { 3071 printf("Device doesn't support NON-Byte Aligned Data.\n"); 3072 return TEST_SKIPPED; 3073 } 3074 3075 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 3076 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 3077 printf("Device doesn't support RAW data-path APIs.\n"); 3078 return TEST_SKIPPED; 3079 } 3080 3081 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 3082 return TEST_SKIPPED; 3083 3084 /* Verify the capabilities */ 3085 struct rte_cryptodev_sym_capability_idx cap_idx; 3086 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; 3087 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2; 3088 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 3089 &cap_idx) == NULL) 3090 return TEST_SKIPPED; 3091 3092 /* Create SNOW 3G session */ 3093 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0], 3094 tdata->key.data, tdata->key.len, 3095 tdata->auth_iv.len, tdata->digest.len, 3096 RTE_CRYPTO_AUTH_OP_GENERATE, 3097 RTE_CRYPTO_AUTH_SNOW3G_UIA2); 3098 if (retval < 0) 3099 return retval; 3100 3101 /* alloc mbuf and set payload */ 3102 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 3103 3104 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 3105 rte_pktmbuf_tailroom(ut_params->ibuf)); 3106 3107 plaintext_len = ceil_byte_length(tdata->plaintext.len); 3108 /* Append data which is padded to a multiple of */ 3109 /* the algorithms block size */ 3110 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); 3111 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 3112 plaintext_pad_len); 3113 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 3114 3115 /* Create SNOW 3G operation */ 3116 retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len, 3117 tdata->auth_iv.data, tdata->auth_iv.len, 3118 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE, 3119 tdata->validAuthLenInBits.len, 3120 0); 3121 if (retval < 0) 3122 return retval; 3123 3124 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 3125 process_sym_raw_dp_op(ts_params->valid_devs[0], 0, 3126 ut_params->op, 0, 1, 1, 0); 3127 else 3128 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 3129 ut_params->op); 3130 ut_params->obuf = ut_params->op->sym->m_src; 3131 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 3132 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 3133 + plaintext_pad_len; 3134 3135 /* Validate obuf */ 3136 TEST_ASSERT_BUFFERS_ARE_EQUAL( 3137 ut_params->digest, 3138 tdata->digest.data, 3139 DIGEST_BYTE_LENGTH_SNOW3G_UIA2, 3140 "SNOW 3G Generated auth tag not as expected"); 3141 3142 return 0; 3143 } 3144 3145 static int 3146 test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata) 3147 { 3148 struct crypto_testsuite_params *ts_params = &testsuite_params; 3149 struct crypto_unittest_params *ut_params = &unittest_params; 3150 3151 int retval; 3152 unsigned plaintext_pad_len; 3153 unsigned plaintext_len; 3154 uint8_t *plaintext; 3155 struct rte_cryptodev_info dev_info; 3156 3157 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 3158 uint64_t feat_flags = dev_info.feature_flags; 3159 3160 if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) && 3161 ((tdata->validAuthLenInBits.len % 8) != 0)) { 3162 printf("Device doesn't support NON-Byte Aligned Data.\n"); 3163 return TEST_SKIPPED; 3164 } 3165 3166 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 3167 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 3168 printf("Device doesn't support RAW data-path APIs.\n"); 3169 return TEST_SKIPPED; 3170 } 3171 3172 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 3173 return TEST_SKIPPED; 3174 3175 /* Verify the capabilities */ 3176 struct rte_cryptodev_sym_capability_idx cap_idx; 3177 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; 3178 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2; 3179 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 3180 &cap_idx) == NULL) 3181 return TEST_SKIPPED; 3182 3183 /* Create SNOW 3G session */ 3184 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0], 3185 tdata->key.data, tdata->key.len, 3186 tdata->auth_iv.len, tdata->digest.len, 3187 RTE_CRYPTO_AUTH_OP_VERIFY, 3188 RTE_CRYPTO_AUTH_SNOW3G_UIA2); 3189 if (retval < 0) 3190 return retval; 3191 /* alloc mbuf and set payload */ 3192 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 3193 3194 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 3195 rte_pktmbuf_tailroom(ut_params->ibuf)); 3196 3197 plaintext_len = ceil_byte_length(tdata->plaintext.len); 3198 /* Append data which is padded to a multiple of */ 3199 /* the algorithms block size */ 3200 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); 3201 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 3202 plaintext_pad_len); 3203 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 3204 3205 /* Create SNOW 3G operation */ 3206 retval = create_wireless_algo_hash_operation(tdata->digest.data, 3207 tdata->digest.len, 3208 tdata->auth_iv.data, tdata->auth_iv.len, 3209 plaintext_pad_len, 3210 RTE_CRYPTO_AUTH_OP_VERIFY, 3211 tdata->validAuthLenInBits.len, 3212 0); 3213 if (retval < 0) 3214 return retval; 3215 3216 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 3217 process_sym_raw_dp_op(ts_params->valid_devs[0], 0, 3218 ut_params->op, 0, 1, 1, 0); 3219 else 3220 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 3221 ut_params->op); 3222 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 3223 ut_params->obuf = ut_params->op->sym->m_src; 3224 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 3225 + plaintext_pad_len; 3226 3227 /* Validate obuf */ 3228 if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS) 3229 return 0; 3230 else 3231 return -1; 3232 3233 return 0; 3234 } 3235 3236 static int 3237 test_kasumi_authentication(const struct kasumi_hash_test_data *tdata) 3238 { 3239 struct crypto_testsuite_params *ts_params = &testsuite_params; 3240 struct crypto_unittest_params *ut_params = &unittest_params; 3241 3242 int retval; 3243 unsigned plaintext_pad_len; 3244 unsigned plaintext_len; 3245 uint8_t *plaintext; 3246 struct rte_cryptodev_info dev_info; 3247 3248 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 3249 uint64_t feat_flags = dev_info.feature_flags; 3250 3251 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 3252 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 3253 printf("Device doesn't support RAW data-path APIs.\n"); 3254 return TEST_SKIPPED; 3255 } 3256 3257 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 3258 return TEST_SKIPPED; 3259 3260 /* Verify the capabilities */ 3261 struct rte_cryptodev_sym_capability_idx cap_idx; 3262 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; 3263 cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9; 3264 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 3265 &cap_idx) == NULL) 3266 return TEST_SKIPPED; 3267 3268 /* Create KASUMI session */ 3269 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0], 3270 tdata->key.data, tdata->key.len, 3271 0, tdata->digest.len, 3272 RTE_CRYPTO_AUTH_OP_GENERATE, 3273 RTE_CRYPTO_AUTH_KASUMI_F9); 3274 if (retval < 0) 3275 return retval; 3276 3277 /* alloc mbuf and set payload */ 3278 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 3279 3280 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 3281 rte_pktmbuf_tailroom(ut_params->ibuf)); 3282 3283 plaintext_len = ceil_byte_length(tdata->plaintext.len); 3284 /* Append data which is padded to a multiple of */ 3285 /* the algorithms block size */ 3286 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); 3287 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 3288 plaintext_pad_len); 3289 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 3290 3291 /* Create KASUMI operation */ 3292 retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len, 3293 NULL, 0, 3294 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE, 3295 tdata->plaintext.len, 3296 0); 3297 if (retval < 0) 3298 return retval; 3299 3300 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 3301 process_cpu_crypt_auth_op(ts_params->valid_devs[0], 3302 ut_params->op); 3303 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 3304 process_sym_raw_dp_op(ts_params->valid_devs[0], 0, 3305 ut_params->op, 0, 1, 1, 0); 3306 else 3307 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 3308 ut_params->op); 3309 3310 ut_params->obuf = ut_params->op->sym->m_src; 3311 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 3312 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 3313 + plaintext_pad_len; 3314 3315 /* Validate obuf */ 3316 TEST_ASSERT_BUFFERS_ARE_EQUAL( 3317 ut_params->digest, 3318 tdata->digest.data, 3319 DIGEST_BYTE_LENGTH_KASUMI_F9, 3320 "KASUMI Generated auth tag not as expected"); 3321 3322 return 0; 3323 } 3324 3325 static int 3326 test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata) 3327 { 3328 struct crypto_testsuite_params *ts_params = &testsuite_params; 3329 struct crypto_unittest_params *ut_params = &unittest_params; 3330 3331 int retval; 3332 unsigned plaintext_pad_len; 3333 unsigned plaintext_len; 3334 uint8_t *plaintext; 3335 struct rte_cryptodev_info dev_info; 3336 3337 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 3338 uint64_t feat_flags = dev_info.feature_flags; 3339 3340 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 3341 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 3342 printf("Device doesn't support RAW data-path APIs.\n"); 3343 return TEST_SKIPPED; 3344 } 3345 3346 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 3347 return TEST_SKIPPED; 3348 3349 /* Verify the capabilities */ 3350 struct rte_cryptodev_sym_capability_idx cap_idx; 3351 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; 3352 cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9; 3353 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 3354 &cap_idx) == NULL) 3355 return TEST_SKIPPED; 3356 3357 /* Create KASUMI session */ 3358 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0], 3359 tdata->key.data, tdata->key.len, 3360 0, tdata->digest.len, 3361 RTE_CRYPTO_AUTH_OP_VERIFY, 3362 RTE_CRYPTO_AUTH_KASUMI_F9); 3363 if (retval < 0) 3364 return retval; 3365 /* alloc mbuf and set payload */ 3366 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 3367 3368 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 3369 rte_pktmbuf_tailroom(ut_params->ibuf)); 3370 3371 plaintext_len = ceil_byte_length(tdata->plaintext.len); 3372 /* Append data which is padded to a multiple */ 3373 /* of the algorithms block size */ 3374 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); 3375 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 3376 plaintext_pad_len); 3377 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 3378 3379 /* Create KASUMI operation */ 3380 retval = create_wireless_algo_hash_operation(tdata->digest.data, 3381 tdata->digest.len, 3382 NULL, 0, 3383 plaintext_pad_len, 3384 RTE_CRYPTO_AUTH_OP_VERIFY, 3385 tdata->plaintext.len, 3386 0); 3387 if (retval < 0) 3388 return retval; 3389 3390 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 3391 process_sym_raw_dp_op(ts_params->valid_devs[0], 0, 3392 ut_params->op, 0, 1, 1, 0); 3393 else 3394 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 3395 ut_params->op); 3396 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 3397 ut_params->obuf = ut_params->op->sym->m_src; 3398 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 3399 + plaintext_pad_len; 3400 3401 /* Validate obuf */ 3402 if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS) 3403 return 0; 3404 else 3405 return -1; 3406 3407 return 0; 3408 } 3409 3410 static int 3411 test_snow3g_hash_generate_test_case_1(void) 3412 { 3413 return test_snow3g_authentication(&snow3g_hash_test_case_1); 3414 } 3415 3416 static int 3417 test_snow3g_hash_generate_test_case_2(void) 3418 { 3419 return test_snow3g_authentication(&snow3g_hash_test_case_2); 3420 } 3421 3422 static int 3423 test_snow3g_hash_generate_test_case_3(void) 3424 { 3425 return test_snow3g_authentication(&snow3g_hash_test_case_3); 3426 } 3427 3428 static int 3429 test_snow3g_hash_generate_test_case_4(void) 3430 { 3431 return test_snow3g_authentication(&snow3g_hash_test_case_4); 3432 } 3433 3434 static int 3435 test_snow3g_hash_generate_test_case_5(void) 3436 { 3437 return test_snow3g_authentication(&snow3g_hash_test_case_5); 3438 } 3439 3440 static int 3441 test_snow3g_hash_generate_test_case_6(void) 3442 { 3443 return test_snow3g_authentication(&snow3g_hash_test_case_6); 3444 } 3445 3446 static int 3447 test_snow3g_hash_verify_test_case_1(void) 3448 { 3449 return test_snow3g_authentication_verify(&snow3g_hash_test_case_1); 3450 3451 } 3452 3453 static int 3454 test_snow3g_hash_verify_test_case_2(void) 3455 { 3456 return test_snow3g_authentication_verify(&snow3g_hash_test_case_2); 3457 } 3458 3459 static int 3460 test_snow3g_hash_verify_test_case_3(void) 3461 { 3462 return test_snow3g_authentication_verify(&snow3g_hash_test_case_3); 3463 } 3464 3465 static int 3466 test_snow3g_hash_verify_test_case_4(void) 3467 { 3468 return test_snow3g_authentication_verify(&snow3g_hash_test_case_4); 3469 } 3470 3471 static int 3472 test_snow3g_hash_verify_test_case_5(void) 3473 { 3474 return test_snow3g_authentication_verify(&snow3g_hash_test_case_5); 3475 } 3476 3477 static int 3478 test_snow3g_hash_verify_test_case_6(void) 3479 { 3480 return test_snow3g_authentication_verify(&snow3g_hash_test_case_6); 3481 } 3482 3483 static int 3484 test_kasumi_hash_generate_test_case_1(void) 3485 { 3486 return test_kasumi_authentication(&kasumi_hash_test_case_1); 3487 } 3488 3489 static int 3490 test_kasumi_hash_generate_test_case_2(void) 3491 { 3492 return test_kasumi_authentication(&kasumi_hash_test_case_2); 3493 } 3494 3495 static int 3496 test_kasumi_hash_generate_test_case_3(void) 3497 { 3498 return test_kasumi_authentication(&kasumi_hash_test_case_3); 3499 } 3500 3501 static int 3502 test_kasumi_hash_generate_test_case_4(void) 3503 { 3504 return test_kasumi_authentication(&kasumi_hash_test_case_4); 3505 } 3506 3507 static int 3508 test_kasumi_hash_generate_test_case_5(void) 3509 { 3510 return test_kasumi_authentication(&kasumi_hash_test_case_5); 3511 } 3512 3513 static int 3514 test_kasumi_hash_generate_test_case_6(void) 3515 { 3516 return test_kasumi_authentication(&kasumi_hash_test_case_6); 3517 } 3518 3519 static int 3520 test_kasumi_hash_verify_test_case_1(void) 3521 { 3522 return test_kasumi_authentication_verify(&kasumi_hash_test_case_1); 3523 } 3524 3525 static int 3526 test_kasumi_hash_verify_test_case_2(void) 3527 { 3528 return test_kasumi_authentication_verify(&kasumi_hash_test_case_2); 3529 } 3530 3531 static int 3532 test_kasumi_hash_verify_test_case_3(void) 3533 { 3534 return test_kasumi_authentication_verify(&kasumi_hash_test_case_3); 3535 } 3536 3537 static int 3538 test_kasumi_hash_verify_test_case_4(void) 3539 { 3540 return test_kasumi_authentication_verify(&kasumi_hash_test_case_4); 3541 } 3542 3543 static int 3544 test_kasumi_hash_verify_test_case_5(void) 3545 { 3546 return test_kasumi_authentication_verify(&kasumi_hash_test_case_5); 3547 } 3548 3549 static int 3550 test_kasumi_encryption(const struct kasumi_test_data *tdata) 3551 { 3552 struct crypto_testsuite_params *ts_params = &testsuite_params; 3553 struct crypto_unittest_params *ut_params = &unittest_params; 3554 3555 int retval; 3556 uint8_t *plaintext, *ciphertext; 3557 unsigned plaintext_pad_len; 3558 unsigned plaintext_len; 3559 struct rte_cryptodev_info dev_info; 3560 3561 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 3562 uint64_t feat_flags = dev_info.feature_flags; 3563 3564 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 3565 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 3566 printf("Device doesn't support RAW data-path APIs.\n"); 3567 return TEST_SKIPPED; 3568 } 3569 3570 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 3571 return TEST_SKIPPED; 3572 3573 /* Verify the capabilities */ 3574 struct rte_cryptodev_sym_capability_idx cap_idx; 3575 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 3576 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8; 3577 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 3578 &cap_idx) == NULL) 3579 return TEST_SKIPPED; 3580 3581 /* Create KASUMI session */ 3582 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], 3583 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 3584 RTE_CRYPTO_CIPHER_KASUMI_F8, 3585 tdata->key.data, tdata->key.len, 3586 tdata->cipher_iv.len); 3587 if (retval < 0) 3588 return retval; 3589 3590 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 3591 3592 /* Clear mbuf payload */ 3593 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 3594 rte_pktmbuf_tailroom(ut_params->ibuf)); 3595 3596 plaintext_len = ceil_byte_length(tdata->plaintext.len); 3597 /* Append data which is padded to a multiple */ 3598 /* of the algorithms block size */ 3599 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); 3600 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 3601 plaintext_pad_len); 3602 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 3603 3604 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len); 3605 3606 /* Create KASUMI operation */ 3607 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data, 3608 tdata->cipher_iv.len, 3609 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8), 3610 tdata->validCipherOffsetInBits.len); 3611 if (retval < 0) 3612 return retval; 3613 3614 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 3615 process_sym_raw_dp_op(ts_params->valid_devs[0], 0, 3616 ut_params->op, 1, 0, 1, tdata->cipher_iv.len); 3617 else 3618 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 3619 ut_params->op); 3620 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 3621 3622 ut_params->obuf = ut_params->op->sym->m_dst; 3623 if (ut_params->obuf) 3624 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); 3625 else 3626 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3); 3627 3628 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len); 3629 3630 const uint8_t *reference_ciphertext = tdata->ciphertext.data + 3631 (tdata->validCipherOffsetInBits.len >> 3); 3632 /* Validate obuf */ 3633 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 3634 ciphertext, 3635 reference_ciphertext, 3636 tdata->validCipherLenInBits.len, 3637 "KASUMI Ciphertext data not as expected"); 3638 return 0; 3639 } 3640 3641 static int 3642 test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata) 3643 { 3644 struct crypto_testsuite_params *ts_params = &testsuite_params; 3645 struct crypto_unittest_params *ut_params = &unittest_params; 3646 3647 int retval; 3648 3649 unsigned int plaintext_pad_len; 3650 unsigned int plaintext_len; 3651 3652 uint8_t buffer[10000]; 3653 const uint8_t *ciphertext; 3654 3655 struct rte_cryptodev_info dev_info; 3656 3657 /* Verify the capabilities */ 3658 struct rte_cryptodev_sym_capability_idx cap_idx; 3659 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 3660 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8; 3661 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 3662 &cap_idx) == NULL) 3663 return TEST_SKIPPED; 3664 3665 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 3666 3667 uint64_t feat_flags = dev_info.feature_flags; 3668 3669 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) { 3670 printf("Device doesn't support in-place scatter-gather. " 3671 "Test Skipped.\n"); 3672 return TEST_SKIPPED; 3673 } 3674 3675 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 3676 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 3677 printf("Device doesn't support RAW data-path APIs.\n"); 3678 return TEST_SKIPPED; 3679 } 3680 3681 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 3682 return TEST_SKIPPED; 3683 3684 /* Create KASUMI session */ 3685 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], 3686 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 3687 RTE_CRYPTO_CIPHER_KASUMI_F8, 3688 tdata->key.data, tdata->key.len, 3689 tdata->cipher_iv.len); 3690 if (retval < 0) 3691 return retval; 3692 3693 plaintext_len = ceil_byte_length(tdata->plaintext.len); 3694 3695 3696 /* Append data which is padded to a multiple */ 3697 /* of the algorithms block size */ 3698 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); 3699 3700 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool, 3701 plaintext_pad_len, 10, 0); 3702 3703 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data); 3704 3705 /* Create KASUMI operation */ 3706 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data, 3707 tdata->cipher_iv.len, 3708 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8), 3709 tdata->validCipherOffsetInBits.len); 3710 if (retval < 0) 3711 return retval; 3712 3713 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 3714 process_sym_raw_dp_op(ts_params->valid_devs[0], 0, 3715 ut_params->op, 1, 0, 1, tdata->cipher_iv.len); 3716 else 3717 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 3718 ut_params->op); 3719 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 3720 3721 ut_params->obuf = ut_params->op->sym->m_dst; 3722 3723 if (ut_params->obuf) 3724 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0, 3725 plaintext_len, buffer); 3726 else 3727 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 3728 tdata->validCipherOffsetInBits.len >> 3, 3729 plaintext_len, buffer); 3730 3731 /* Validate obuf */ 3732 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len); 3733 3734 const uint8_t *reference_ciphertext = tdata->ciphertext.data + 3735 (tdata->validCipherOffsetInBits.len >> 3); 3736 /* Validate obuf */ 3737 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 3738 ciphertext, 3739 reference_ciphertext, 3740 tdata->validCipherLenInBits.len, 3741 "KASUMI Ciphertext data not as expected"); 3742 return 0; 3743 } 3744 3745 static int 3746 test_kasumi_encryption_oop(const struct kasumi_test_data *tdata) 3747 { 3748 struct crypto_testsuite_params *ts_params = &testsuite_params; 3749 struct crypto_unittest_params *ut_params = &unittest_params; 3750 3751 int retval; 3752 uint8_t *plaintext, *ciphertext; 3753 unsigned plaintext_pad_len; 3754 unsigned plaintext_len; 3755 3756 /* Verify the capabilities */ 3757 struct rte_cryptodev_sym_capability_idx cap_idx; 3758 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 3759 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8; 3760 /* Data-path service does not support OOP */ 3761 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 3762 &cap_idx) == NULL) 3763 return TEST_SKIPPED; 3764 3765 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 3766 return TEST_SKIPPED; 3767 3768 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 3769 return TEST_SKIPPED; 3770 3771 /* Create KASUMI session */ 3772 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], 3773 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 3774 RTE_CRYPTO_CIPHER_KASUMI_F8, 3775 tdata->key.data, tdata->key.len, 3776 tdata->cipher_iv.len); 3777 if (retval < 0) 3778 return retval; 3779 3780 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 3781 ut_params->obuf = 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 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len); 3794 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 3795 3796 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len); 3797 3798 /* Create KASUMI operation */ 3799 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data, 3800 tdata->cipher_iv.len, 3801 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8), 3802 tdata->validCipherOffsetInBits.len); 3803 if (retval < 0) 3804 return retval; 3805 3806 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 3807 ut_params->op); 3808 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 3809 3810 ut_params->obuf = ut_params->op->sym->m_dst; 3811 if (ut_params->obuf) 3812 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); 3813 else 3814 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3); 3815 3816 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len); 3817 3818 const uint8_t *reference_ciphertext = tdata->ciphertext.data + 3819 (tdata->validCipherOffsetInBits.len >> 3); 3820 /* Validate obuf */ 3821 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 3822 ciphertext, 3823 reference_ciphertext, 3824 tdata->validCipherLenInBits.len, 3825 "KASUMI Ciphertext data not as expected"); 3826 return 0; 3827 } 3828 3829 static int 3830 test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata) 3831 { 3832 struct crypto_testsuite_params *ts_params = &testsuite_params; 3833 struct crypto_unittest_params *ut_params = &unittest_params; 3834 3835 int retval; 3836 unsigned int plaintext_pad_len; 3837 unsigned int plaintext_len; 3838 3839 const uint8_t *ciphertext; 3840 uint8_t buffer[2048]; 3841 3842 struct rte_cryptodev_info dev_info; 3843 3844 /* Verify the capabilities */ 3845 struct rte_cryptodev_sym_capability_idx cap_idx; 3846 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 3847 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8; 3848 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 3849 &cap_idx) == NULL) 3850 return TEST_SKIPPED; 3851 3852 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 3853 return TEST_SKIPPED; 3854 3855 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 3856 return TEST_SKIPPED; 3857 3858 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 3859 3860 uint64_t feat_flags = dev_info.feature_flags; 3861 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) { 3862 printf("Device doesn't support out-of-place scatter-gather " 3863 "in both input and output mbufs. " 3864 "Test Skipped.\n"); 3865 return TEST_SKIPPED; 3866 } 3867 3868 /* Create KASUMI session */ 3869 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], 3870 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 3871 RTE_CRYPTO_CIPHER_KASUMI_F8, 3872 tdata->key.data, tdata->key.len, 3873 tdata->cipher_iv.len); 3874 if (retval < 0) 3875 return retval; 3876 3877 plaintext_len = ceil_byte_length(tdata->plaintext.len); 3878 /* Append data which is padded to a multiple */ 3879 /* of the algorithms block size */ 3880 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); 3881 3882 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool, 3883 plaintext_pad_len, 10, 0); 3884 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool, 3885 plaintext_pad_len, 3, 0); 3886 3887 /* Append data which is padded to a multiple */ 3888 /* of the algorithms block size */ 3889 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data); 3890 3891 /* Create KASUMI operation */ 3892 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data, 3893 tdata->cipher_iv.len, 3894 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8), 3895 tdata->validCipherOffsetInBits.len); 3896 if (retval < 0) 3897 return retval; 3898 3899 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 3900 ut_params->op); 3901 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 3902 3903 ut_params->obuf = ut_params->op->sym->m_dst; 3904 if (ut_params->obuf) 3905 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0, 3906 plaintext_pad_len, buffer); 3907 else 3908 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 3909 tdata->validCipherOffsetInBits.len >> 3, 3910 plaintext_pad_len, buffer); 3911 3912 const uint8_t *reference_ciphertext = tdata->ciphertext.data + 3913 (tdata->validCipherOffsetInBits.len >> 3); 3914 /* Validate obuf */ 3915 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 3916 ciphertext, 3917 reference_ciphertext, 3918 tdata->validCipherLenInBits.len, 3919 "KASUMI Ciphertext data not as expected"); 3920 return 0; 3921 } 3922 3923 3924 static int 3925 test_kasumi_decryption_oop(const struct kasumi_test_data *tdata) 3926 { 3927 struct crypto_testsuite_params *ts_params = &testsuite_params; 3928 struct crypto_unittest_params *ut_params = &unittest_params; 3929 3930 int retval; 3931 uint8_t *ciphertext, *plaintext; 3932 unsigned ciphertext_pad_len; 3933 unsigned ciphertext_len; 3934 3935 /* Verify the capabilities */ 3936 struct rte_cryptodev_sym_capability_idx cap_idx; 3937 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 3938 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8; 3939 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 3940 &cap_idx) == NULL) 3941 return TEST_SKIPPED; 3942 3943 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 3944 return TEST_SKIPPED; 3945 3946 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 3947 return TEST_SKIPPED; 3948 3949 /* Create KASUMI session */ 3950 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], 3951 RTE_CRYPTO_CIPHER_OP_DECRYPT, 3952 RTE_CRYPTO_CIPHER_KASUMI_F8, 3953 tdata->key.data, tdata->key.len, 3954 tdata->cipher_iv.len); 3955 if (retval < 0) 3956 return retval; 3957 3958 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 3959 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 3960 3961 /* Clear mbuf payload */ 3962 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 3963 rte_pktmbuf_tailroom(ut_params->ibuf)); 3964 3965 ciphertext_len = ceil_byte_length(tdata->ciphertext.len); 3966 /* Append data which is padded to a multiple */ 3967 /* of the algorithms block size */ 3968 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8); 3969 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 3970 ciphertext_pad_len); 3971 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len); 3972 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len); 3973 3974 debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len); 3975 3976 /* Create KASUMI operation */ 3977 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data, 3978 tdata->cipher_iv.len, 3979 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8), 3980 tdata->validCipherOffsetInBits.len); 3981 if (retval < 0) 3982 return retval; 3983 3984 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 3985 ut_params->op); 3986 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 3987 3988 ut_params->obuf = ut_params->op->sym->m_dst; 3989 if (ut_params->obuf) 3990 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); 3991 else 3992 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3); 3993 3994 debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len); 3995 3996 const uint8_t *reference_plaintext = tdata->plaintext.data + 3997 (tdata->validCipherOffsetInBits.len >> 3); 3998 /* Validate obuf */ 3999 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 4000 plaintext, 4001 reference_plaintext, 4002 tdata->validCipherLenInBits.len, 4003 "KASUMI Plaintext data not as expected"); 4004 return 0; 4005 } 4006 4007 static int 4008 test_kasumi_decryption(const struct kasumi_test_data *tdata) 4009 { 4010 struct crypto_testsuite_params *ts_params = &testsuite_params; 4011 struct crypto_unittest_params *ut_params = &unittest_params; 4012 4013 int retval; 4014 uint8_t *ciphertext, *plaintext; 4015 unsigned ciphertext_pad_len; 4016 unsigned ciphertext_len; 4017 struct rte_cryptodev_info dev_info; 4018 4019 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 4020 uint64_t feat_flags = dev_info.feature_flags; 4021 4022 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 4023 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 4024 printf("Device doesn't support RAW data-path APIs.\n"); 4025 return TEST_SKIPPED; 4026 } 4027 4028 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 4029 return TEST_SKIPPED; 4030 4031 /* Verify the capabilities */ 4032 struct rte_cryptodev_sym_capability_idx cap_idx; 4033 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 4034 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8; 4035 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 4036 &cap_idx) == NULL) 4037 return TEST_SKIPPED; 4038 4039 /* Create KASUMI session */ 4040 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], 4041 RTE_CRYPTO_CIPHER_OP_DECRYPT, 4042 RTE_CRYPTO_CIPHER_KASUMI_F8, 4043 tdata->key.data, tdata->key.len, 4044 tdata->cipher_iv.len); 4045 if (retval < 0) 4046 return retval; 4047 4048 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 4049 4050 /* Clear mbuf payload */ 4051 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 4052 rte_pktmbuf_tailroom(ut_params->ibuf)); 4053 4054 ciphertext_len = ceil_byte_length(tdata->ciphertext.len); 4055 /* Append data which is padded to a multiple */ 4056 /* of the algorithms block size */ 4057 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8); 4058 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 4059 ciphertext_pad_len); 4060 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len); 4061 4062 debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len); 4063 4064 /* Create KASUMI operation */ 4065 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data, 4066 tdata->cipher_iv.len, 4067 tdata->ciphertext.len, 4068 tdata->validCipherOffsetInBits.len); 4069 if (retval < 0) 4070 return retval; 4071 4072 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 4073 process_sym_raw_dp_op(ts_params->valid_devs[0], 0, 4074 ut_params->op, 1, 0, 1, 0); 4075 else 4076 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 4077 ut_params->op); 4078 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 4079 4080 ut_params->obuf = ut_params->op->sym->m_dst; 4081 if (ut_params->obuf) 4082 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); 4083 else 4084 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3); 4085 4086 debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len); 4087 4088 const uint8_t *reference_plaintext = tdata->plaintext.data + 4089 (tdata->validCipherOffsetInBits.len >> 3); 4090 /* Validate obuf */ 4091 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 4092 plaintext, 4093 reference_plaintext, 4094 tdata->validCipherLenInBits.len, 4095 "KASUMI Plaintext data not as expected"); 4096 return 0; 4097 } 4098 4099 static int 4100 test_snow3g_encryption(const struct snow3g_test_data *tdata) 4101 { 4102 struct crypto_testsuite_params *ts_params = &testsuite_params; 4103 struct crypto_unittest_params *ut_params = &unittest_params; 4104 4105 int retval; 4106 uint8_t *plaintext, *ciphertext; 4107 unsigned plaintext_pad_len; 4108 unsigned plaintext_len; 4109 struct rte_cryptodev_info dev_info; 4110 4111 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 4112 uint64_t feat_flags = dev_info.feature_flags; 4113 4114 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 4115 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 4116 printf("Device doesn't support RAW data-path APIs.\n"); 4117 return TEST_SKIPPED; 4118 } 4119 4120 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 4121 return TEST_SKIPPED; 4122 4123 /* Verify the capabilities */ 4124 struct rte_cryptodev_sym_capability_idx cap_idx; 4125 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 4126 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2; 4127 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 4128 &cap_idx) == NULL) 4129 return TEST_SKIPPED; 4130 4131 /* Create SNOW 3G session */ 4132 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], 4133 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 4134 RTE_CRYPTO_CIPHER_SNOW3G_UEA2, 4135 tdata->key.data, tdata->key.len, 4136 tdata->cipher_iv.len); 4137 if (retval < 0) 4138 return retval; 4139 4140 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 4141 4142 /* Clear mbuf payload */ 4143 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 4144 rte_pktmbuf_tailroom(ut_params->ibuf)); 4145 4146 plaintext_len = ceil_byte_length(tdata->plaintext.len); 4147 /* Append data which is padded to a multiple of */ 4148 /* the algorithms block size */ 4149 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); 4150 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 4151 plaintext_pad_len); 4152 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 4153 4154 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len); 4155 4156 /* Create SNOW 3G operation */ 4157 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data, 4158 tdata->cipher_iv.len, 4159 tdata->validCipherLenInBits.len, 4160 0); 4161 if (retval < 0) 4162 return retval; 4163 4164 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 4165 process_sym_raw_dp_op(ts_params->valid_devs[0], 0, 4166 ut_params->op, 1, 0, 1, tdata->cipher_iv.len); 4167 else 4168 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 4169 ut_params->op); 4170 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 4171 4172 ut_params->obuf = ut_params->op->sym->m_dst; 4173 if (ut_params->obuf) 4174 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); 4175 else 4176 ciphertext = plaintext; 4177 4178 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len); 4179 4180 /* Validate obuf */ 4181 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 4182 ciphertext, 4183 tdata->ciphertext.data, 4184 tdata->validDataLenInBits.len, 4185 "SNOW 3G Ciphertext data not as expected"); 4186 return 0; 4187 } 4188 4189 4190 static int 4191 test_snow3g_encryption_oop(const struct snow3g_test_data *tdata) 4192 { 4193 struct crypto_testsuite_params *ts_params = &testsuite_params; 4194 struct crypto_unittest_params *ut_params = &unittest_params; 4195 uint8_t *plaintext, *ciphertext; 4196 4197 int retval; 4198 unsigned plaintext_pad_len; 4199 unsigned plaintext_len; 4200 4201 /* Verify the capabilities */ 4202 struct rte_cryptodev_sym_capability_idx cap_idx; 4203 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 4204 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2; 4205 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 4206 &cap_idx) == NULL) 4207 return TEST_SKIPPED; 4208 4209 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 4210 return TEST_SKIPPED; 4211 4212 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 4213 return TEST_SKIPPED; 4214 4215 /* Create SNOW 3G session */ 4216 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], 4217 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 4218 RTE_CRYPTO_CIPHER_SNOW3G_UEA2, 4219 tdata->key.data, tdata->key.len, 4220 tdata->cipher_iv.len); 4221 if (retval < 0) 4222 return retval; 4223 4224 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 4225 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 4226 4227 TEST_ASSERT_NOT_NULL(ut_params->ibuf, 4228 "Failed to allocate input buffer in mempool"); 4229 TEST_ASSERT_NOT_NULL(ut_params->obuf, 4230 "Failed to allocate output buffer in mempool"); 4231 4232 /* Clear mbuf payload */ 4233 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 4234 rte_pktmbuf_tailroom(ut_params->ibuf)); 4235 4236 plaintext_len = ceil_byte_length(tdata->plaintext.len); 4237 /* Append data which is padded to a multiple of */ 4238 /* the algorithms block size */ 4239 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); 4240 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 4241 plaintext_pad_len); 4242 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len); 4243 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 4244 4245 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len); 4246 4247 /* Create SNOW 3G operation */ 4248 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data, 4249 tdata->cipher_iv.len, 4250 tdata->validCipherLenInBits.len, 4251 0); 4252 if (retval < 0) 4253 return retval; 4254 4255 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 4256 ut_params->op); 4257 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 4258 4259 ut_params->obuf = ut_params->op->sym->m_dst; 4260 if (ut_params->obuf) 4261 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); 4262 else 4263 ciphertext = plaintext; 4264 4265 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len); 4266 4267 /* Validate obuf */ 4268 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 4269 ciphertext, 4270 tdata->ciphertext.data, 4271 tdata->validDataLenInBits.len, 4272 "SNOW 3G Ciphertext data not as expected"); 4273 return 0; 4274 } 4275 4276 static int 4277 test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata) 4278 { 4279 struct crypto_testsuite_params *ts_params = &testsuite_params; 4280 struct crypto_unittest_params *ut_params = &unittest_params; 4281 4282 int retval; 4283 unsigned int plaintext_pad_len; 4284 unsigned int plaintext_len; 4285 uint8_t buffer[10000]; 4286 const uint8_t *ciphertext; 4287 4288 struct rte_cryptodev_info dev_info; 4289 4290 /* Verify the capabilities */ 4291 struct rte_cryptodev_sym_capability_idx cap_idx; 4292 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 4293 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2; 4294 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 4295 &cap_idx) == NULL) 4296 return TEST_SKIPPED; 4297 4298 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 4299 return TEST_SKIPPED; 4300 4301 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 4302 return TEST_SKIPPED; 4303 4304 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 4305 4306 uint64_t feat_flags = dev_info.feature_flags; 4307 4308 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) { 4309 printf("Device doesn't support out-of-place scatter-gather " 4310 "in both input and output mbufs. " 4311 "Test Skipped.\n"); 4312 return TEST_SKIPPED; 4313 } 4314 4315 /* Create SNOW 3G session */ 4316 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], 4317 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 4318 RTE_CRYPTO_CIPHER_SNOW3G_UEA2, 4319 tdata->key.data, tdata->key.len, 4320 tdata->cipher_iv.len); 4321 if (retval < 0) 4322 return retval; 4323 4324 plaintext_len = ceil_byte_length(tdata->plaintext.len); 4325 /* Append data which is padded to a multiple of */ 4326 /* the algorithms block size */ 4327 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); 4328 4329 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool, 4330 plaintext_pad_len, 10, 0); 4331 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool, 4332 plaintext_pad_len, 3, 0); 4333 4334 TEST_ASSERT_NOT_NULL(ut_params->ibuf, 4335 "Failed to allocate input buffer in mempool"); 4336 TEST_ASSERT_NOT_NULL(ut_params->obuf, 4337 "Failed to allocate output buffer in mempool"); 4338 4339 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data); 4340 4341 /* Create SNOW 3G operation */ 4342 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data, 4343 tdata->cipher_iv.len, 4344 tdata->validCipherLenInBits.len, 4345 0); 4346 if (retval < 0) 4347 return retval; 4348 4349 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 4350 ut_params->op); 4351 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 4352 4353 ut_params->obuf = ut_params->op->sym->m_dst; 4354 if (ut_params->obuf) 4355 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0, 4356 plaintext_len, buffer); 4357 else 4358 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0, 4359 plaintext_len, buffer); 4360 4361 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len); 4362 4363 /* Validate obuf */ 4364 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 4365 ciphertext, 4366 tdata->ciphertext.data, 4367 tdata->validDataLenInBits.len, 4368 "SNOW 3G Ciphertext data not as expected"); 4369 4370 return 0; 4371 } 4372 4373 /* Shift right a buffer by "offset" bits, "offset" < 8 */ 4374 static void 4375 buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset) 4376 { 4377 uint8_t curr_byte, prev_byte; 4378 uint32_t length_in_bytes = ceil_byte_length(length + offset); 4379 uint8_t lower_byte_mask = (1 << offset) - 1; 4380 unsigned i; 4381 4382 prev_byte = buffer[0]; 4383 buffer[0] >>= offset; 4384 4385 for (i = 1; i < length_in_bytes; i++) { 4386 curr_byte = buffer[i]; 4387 buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) | 4388 (curr_byte >> offset); 4389 prev_byte = curr_byte; 4390 } 4391 } 4392 4393 static int 4394 test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata) 4395 { 4396 struct crypto_testsuite_params *ts_params = &testsuite_params; 4397 struct crypto_unittest_params *ut_params = &unittest_params; 4398 uint8_t *plaintext, *ciphertext; 4399 int retval; 4400 uint32_t plaintext_len; 4401 uint32_t plaintext_pad_len; 4402 uint8_t extra_offset = 4; 4403 uint8_t *expected_ciphertext_shifted; 4404 struct rte_cryptodev_info dev_info; 4405 4406 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 4407 uint64_t feat_flags = dev_info.feature_flags; 4408 4409 if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) && 4410 ((tdata->validDataLenInBits.len % 8) != 0)) { 4411 printf("Device doesn't support NON-Byte Aligned Data.\n"); 4412 return TEST_SKIPPED; 4413 } 4414 4415 /* Verify the capabilities */ 4416 struct rte_cryptodev_sym_capability_idx cap_idx; 4417 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 4418 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2; 4419 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 4420 &cap_idx) == NULL) 4421 return TEST_SKIPPED; 4422 4423 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 4424 return TEST_SKIPPED; 4425 4426 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 4427 return TEST_SKIPPED; 4428 4429 /* Create SNOW 3G session */ 4430 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], 4431 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 4432 RTE_CRYPTO_CIPHER_SNOW3G_UEA2, 4433 tdata->key.data, tdata->key.len, 4434 tdata->cipher_iv.len); 4435 if (retval < 0) 4436 return retval; 4437 4438 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 4439 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 4440 4441 TEST_ASSERT_NOT_NULL(ut_params->ibuf, 4442 "Failed to allocate input buffer in mempool"); 4443 TEST_ASSERT_NOT_NULL(ut_params->obuf, 4444 "Failed to allocate output buffer in mempool"); 4445 4446 /* Clear mbuf payload */ 4447 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 4448 rte_pktmbuf_tailroom(ut_params->ibuf)); 4449 4450 plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset); 4451 /* 4452 * Append data which is padded to a 4453 * multiple of the algorithms block size 4454 */ 4455 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); 4456 4457 plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf, 4458 plaintext_pad_len); 4459 4460 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len); 4461 4462 memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3)); 4463 buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset); 4464 4465 #ifdef RTE_APP_TEST_DEBUG 4466 rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len); 4467 #endif 4468 /* Create SNOW 3G operation */ 4469 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data, 4470 tdata->cipher_iv.len, 4471 tdata->validCipherLenInBits.len, 4472 extra_offset); 4473 if (retval < 0) 4474 return retval; 4475 4476 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 4477 ut_params->op); 4478 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 4479 4480 ut_params->obuf = ut_params->op->sym->m_dst; 4481 if (ut_params->obuf) 4482 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); 4483 else 4484 ciphertext = plaintext; 4485 4486 #ifdef RTE_APP_TEST_DEBUG 4487 rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len); 4488 #endif 4489 4490 expected_ciphertext_shifted = rte_malloc(NULL, plaintext_len, 8); 4491 4492 TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted, 4493 "failed to reserve memory for ciphertext shifted\n"); 4494 4495 memcpy(expected_ciphertext_shifted, tdata->ciphertext.data, 4496 ceil_byte_length(tdata->ciphertext.len)); 4497 buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len, 4498 extra_offset); 4499 /* Validate obuf */ 4500 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET( 4501 ciphertext, 4502 expected_ciphertext_shifted, 4503 tdata->validDataLenInBits.len, 4504 extra_offset, 4505 "SNOW 3G Ciphertext data not as expected"); 4506 return 0; 4507 } 4508 4509 static int test_snow3g_decryption(const struct snow3g_test_data *tdata) 4510 { 4511 struct crypto_testsuite_params *ts_params = &testsuite_params; 4512 struct crypto_unittest_params *ut_params = &unittest_params; 4513 4514 int retval; 4515 4516 uint8_t *plaintext, *ciphertext; 4517 unsigned ciphertext_pad_len; 4518 unsigned ciphertext_len; 4519 struct rte_cryptodev_info dev_info; 4520 4521 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 4522 uint64_t feat_flags = dev_info.feature_flags; 4523 4524 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 4525 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 4526 printf("Device doesn't support RAW data-path APIs.\n"); 4527 return TEST_SKIPPED; 4528 } 4529 4530 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 4531 return TEST_SKIPPED; 4532 4533 /* Verify the capabilities */ 4534 struct rte_cryptodev_sym_capability_idx cap_idx; 4535 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 4536 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2; 4537 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 4538 &cap_idx) == NULL) 4539 return TEST_SKIPPED; 4540 4541 /* Create SNOW 3G session */ 4542 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], 4543 RTE_CRYPTO_CIPHER_OP_DECRYPT, 4544 RTE_CRYPTO_CIPHER_SNOW3G_UEA2, 4545 tdata->key.data, tdata->key.len, 4546 tdata->cipher_iv.len); 4547 if (retval < 0) 4548 return retval; 4549 4550 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 4551 4552 /* Clear mbuf payload */ 4553 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 4554 rte_pktmbuf_tailroom(ut_params->ibuf)); 4555 4556 ciphertext_len = ceil_byte_length(tdata->ciphertext.len); 4557 /* Append data which is padded to a multiple of */ 4558 /* the algorithms block size */ 4559 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16); 4560 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 4561 ciphertext_pad_len); 4562 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len); 4563 4564 debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len); 4565 4566 /* Create SNOW 3G operation */ 4567 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data, 4568 tdata->cipher_iv.len, 4569 tdata->validCipherLenInBits.len, 4570 tdata->cipher.offset_bits); 4571 if (retval < 0) 4572 return retval; 4573 4574 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 4575 process_sym_raw_dp_op(ts_params->valid_devs[0], 0, 4576 ut_params->op, 1, 0, 1, tdata->cipher_iv.len); 4577 else 4578 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 4579 ut_params->op); 4580 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 4581 ut_params->obuf = ut_params->op->sym->m_dst; 4582 if (ut_params->obuf) 4583 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); 4584 else 4585 plaintext = ciphertext; 4586 4587 debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len); 4588 4589 /* Validate obuf */ 4590 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext, 4591 tdata->plaintext.data, 4592 tdata->validDataLenInBits.len, 4593 "SNOW 3G Plaintext data not as expected"); 4594 return 0; 4595 } 4596 4597 static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata) 4598 { 4599 struct crypto_testsuite_params *ts_params = &testsuite_params; 4600 struct crypto_unittest_params *ut_params = &unittest_params; 4601 4602 int retval; 4603 4604 uint8_t *plaintext, *ciphertext; 4605 unsigned ciphertext_pad_len; 4606 unsigned ciphertext_len; 4607 4608 /* Verify the capabilities */ 4609 struct rte_cryptodev_sym_capability_idx cap_idx; 4610 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 4611 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2; 4612 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 4613 &cap_idx) == NULL) 4614 return TEST_SKIPPED; 4615 4616 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 4617 return TEST_SKIPPED; 4618 4619 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 4620 return TEST_SKIPPED; 4621 4622 /* Create SNOW 3G session */ 4623 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], 4624 RTE_CRYPTO_CIPHER_OP_DECRYPT, 4625 RTE_CRYPTO_CIPHER_SNOW3G_UEA2, 4626 tdata->key.data, tdata->key.len, 4627 tdata->cipher_iv.len); 4628 if (retval < 0) 4629 return retval; 4630 4631 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 4632 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 4633 4634 TEST_ASSERT_NOT_NULL(ut_params->ibuf, 4635 "Failed to allocate input buffer"); 4636 TEST_ASSERT_NOT_NULL(ut_params->obuf, 4637 "Failed to allocate output buffer"); 4638 4639 /* Clear mbuf payload */ 4640 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 4641 rte_pktmbuf_tailroom(ut_params->ibuf)); 4642 4643 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0, 4644 rte_pktmbuf_tailroom(ut_params->obuf)); 4645 4646 ciphertext_len = ceil_byte_length(tdata->ciphertext.len); 4647 /* Append data which is padded to a multiple of */ 4648 /* the algorithms block size */ 4649 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16); 4650 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 4651 ciphertext_pad_len); 4652 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len); 4653 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len); 4654 4655 debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len); 4656 4657 /* Create SNOW 3G operation */ 4658 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data, 4659 tdata->cipher_iv.len, 4660 tdata->validCipherLenInBits.len, 4661 0); 4662 if (retval < 0) 4663 return retval; 4664 4665 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 4666 ut_params->op); 4667 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 4668 ut_params->obuf = ut_params->op->sym->m_dst; 4669 if (ut_params->obuf) 4670 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); 4671 else 4672 plaintext = ciphertext; 4673 4674 debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len); 4675 4676 /* Validate obuf */ 4677 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext, 4678 tdata->plaintext.data, 4679 tdata->validDataLenInBits.len, 4680 "SNOW 3G Plaintext data not as expected"); 4681 return 0; 4682 } 4683 4684 static int 4685 test_zuc_cipher_auth(const struct wireless_test_data *tdata) 4686 { 4687 struct crypto_testsuite_params *ts_params = &testsuite_params; 4688 struct crypto_unittest_params *ut_params = &unittest_params; 4689 4690 int retval; 4691 4692 uint8_t *plaintext, *ciphertext; 4693 unsigned int plaintext_pad_len; 4694 unsigned int plaintext_len; 4695 4696 struct rte_cryptodev_info dev_info; 4697 struct rte_cryptodev_sym_capability_idx cap_idx; 4698 4699 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 4700 uint64_t feat_flags = dev_info.feature_flags; 4701 4702 if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) && 4703 ((tdata->validAuthLenInBits.len % 8 != 0) || 4704 (tdata->validDataLenInBits.len % 8 != 0))) { 4705 printf("Device doesn't support NON-Byte Aligned Data.\n"); 4706 return TEST_SKIPPED; 4707 } 4708 4709 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 4710 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 4711 printf("Device doesn't support RAW data-path APIs.\n"); 4712 return TEST_SKIPPED; 4713 } 4714 4715 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 4716 return TEST_SKIPPED; 4717 4718 /* Check if device supports ZUC EEA3 */ 4719 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 4720 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3; 4721 4722 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 4723 &cap_idx) == NULL) 4724 return TEST_SKIPPED; 4725 4726 /* Check if device supports ZUC EIA3 */ 4727 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; 4728 cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3; 4729 4730 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 4731 &cap_idx) == NULL) 4732 return TEST_SKIPPED; 4733 4734 /* Create ZUC session */ 4735 retval = create_zuc_cipher_auth_encrypt_generate_session( 4736 ts_params->valid_devs[0], 4737 tdata); 4738 if (retval != 0) 4739 return retval; 4740 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 4741 4742 /* clear mbuf payload */ 4743 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 4744 rte_pktmbuf_tailroom(ut_params->ibuf)); 4745 4746 plaintext_len = ceil_byte_length(tdata->plaintext.len); 4747 /* Append data which is padded to a multiple of */ 4748 /* the algorithms block size */ 4749 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); 4750 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 4751 plaintext_pad_len); 4752 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 4753 4754 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len); 4755 4756 /* Create ZUC operation */ 4757 retval = create_zuc_cipher_hash_generate_operation(tdata); 4758 if (retval < 0) 4759 return retval; 4760 4761 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 4762 process_sym_raw_dp_op(ts_params->valid_devs[0], 0, 4763 ut_params->op, 1, 1, 1, tdata->cipher_iv.len); 4764 else 4765 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 4766 ut_params->op); 4767 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 4768 ut_params->obuf = ut_params->op->sym->m_src; 4769 if (ut_params->obuf) 4770 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); 4771 else 4772 ciphertext = plaintext; 4773 4774 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len); 4775 /* Validate obuf */ 4776 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 4777 ciphertext, 4778 tdata->ciphertext.data, 4779 tdata->validDataLenInBits.len, 4780 "ZUC Ciphertext data not as expected"); 4781 4782 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 4783 + plaintext_pad_len; 4784 4785 /* Validate obuf */ 4786 TEST_ASSERT_BUFFERS_ARE_EQUAL( 4787 ut_params->digest, 4788 tdata->digest.data, 4789 4, 4790 "ZUC Generated auth tag not as expected"); 4791 return 0; 4792 } 4793 4794 static int 4795 test_snow3g_cipher_auth(const struct snow3g_test_data *tdata) 4796 { 4797 struct crypto_testsuite_params *ts_params = &testsuite_params; 4798 struct crypto_unittest_params *ut_params = &unittest_params; 4799 4800 int retval; 4801 4802 uint8_t *plaintext, *ciphertext; 4803 unsigned plaintext_pad_len; 4804 unsigned plaintext_len; 4805 struct rte_cryptodev_info dev_info; 4806 4807 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 4808 uint64_t feat_flags = dev_info.feature_flags; 4809 4810 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 4811 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 4812 printf("Device doesn't support RAW data-path APIs.\n"); 4813 return TEST_SKIPPED; 4814 } 4815 4816 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 4817 return TEST_SKIPPED; 4818 4819 /* Verify the capabilities */ 4820 struct rte_cryptodev_sym_capability_idx cap_idx; 4821 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; 4822 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2; 4823 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 4824 &cap_idx) == NULL) 4825 return TEST_SKIPPED; 4826 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 4827 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2; 4828 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 4829 &cap_idx) == NULL) 4830 return TEST_SKIPPED; 4831 4832 /* Create SNOW 3G session */ 4833 retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0], 4834 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 4835 RTE_CRYPTO_AUTH_OP_GENERATE, 4836 RTE_CRYPTO_AUTH_SNOW3G_UIA2, 4837 RTE_CRYPTO_CIPHER_SNOW3G_UEA2, 4838 tdata->key.data, tdata->key.len, 4839 tdata->auth_iv.len, tdata->digest.len, 4840 tdata->cipher_iv.len); 4841 if (retval != 0) 4842 return retval; 4843 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 4844 4845 /* clear mbuf payload */ 4846 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 4847 rte_pktmbuf_tailroom(ut_params->ibuf)); 4848 4849 plaintext_len = ceil_byte_length(tdata->plaintext.len); 4850 /* Append data which is padded to a multiple of */ 4851 /* the algorithms block size */ 4852 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); 4853 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 4854 plaintext_pad_len); 4855 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 4856 4857 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len); 4858 4859 /* Create SNOW 3G operation */ 4860 retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data, 4861 tdata->digest.len, tdata->auth_iv.data, 4862 tdata->auth_iv.len, 4863 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE, 4864 tdata->cipher_iv.data, tdata->cipher_iv.len, 4865 tdata->validCipherLenInBits.len, 4866 0, 4867 tdata->validAuthLenInBits.len, 4868 0 4869 ); 4870 if (retval < 0) 4871 return retval; 4872 4873 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 4874 process_sym_raw_dp_op(ts_params->valid_devs[0], 0, 4875 ut_params->op, 1, 1, 1, tdata->cipher_iv.len); 4876 else 4877 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 4878 ut_params->op); 4879 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 4880 ut_params->obuf = ut_params->op->sym->m_src; 4881 if (ut_params->obuf) 4882 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); 4883 else 4884 ciphertext = plaintext; 4885 4886 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len); 4887 /* Validate obuf */ 4888 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 4889 ciphertext, 4890 tdata->ciphertext.data, 4891 tdata->validDataLenInBits.len, 4892 "SNOW 3G Ciphertext data not as expected"); 4893 4894 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 4895 + plaintext_pad_len; 4896 4897 /* Validate obuf */ 4898 TEST_ASSERT_BUFFERS_ARE_EQUAL( 4899 ut_params->digest, 4900 tdata->digest.data, 4901 DIGEST_BYTE_LENGTH_SNOW3G_UIA2, 4902 "SNOW 3G Generated auth tag not as expected"); 4903 return 0; 4904 } 4905 4906 static int 4907 test_snow3g_auth_cipher(const struct snow3g_test_data *tdata, 4908 uint8_t op_mode, uint8_t verify) 4909 { 4910 struct crypto_testsuite_params *ts_params = &testsuite_params; 4911 struct crypto_unittest_params *ut_params = &unittest_params; 4912 4913 int retval; 4914 4915 uint8_t *plaintext = NULL, *ciphertext = NULL; 4916 unsigned int plaintext_pad_len; 4917 unsigned int plaintext_len; 4918 unsigned int ciphertext_pad_len; 4919 unsigned int ciphertext_len; 4920 4921 struct rte_cryptodev_info dev_info; 4922 4923 /* Verify the capabilities */ 4924 struct rte_cryptodev_sym_capability_idx cap_idx; 4925 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; 4926 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2; 4927 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 4928 &cap_idx) == NULL) 4929 return TEST_SKIPPED; 4930 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 4931 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2; 4932 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 4933 &cap_idx) == NULL) 4934 return TEST_SKIPPED; 4935 4936 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 4937 return TEST_SKIPPED; 4938 4939 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 4940 4941 uint64_t feat_flags = dev_info.feature_flags; 4942 4943 if (op_mode == OUT_OF_PLACE) { 4944 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) { 4945 printf("Device doesn't support digest encrypted.\n"); 4946 return TEST_SKIPPED; 4947 } 4948 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 4949 return TEST_SKIPPED; 4950 } 4951 4952 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 4953 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 4954 printf("Device doesn't support RAW data-path APIs.\n"); 4955 return TEST_SKIPPED; 4956 } 4957 4958 /* Create SNOW 3G session */ 4959 retval = create_wireless_algo_auth_cipher_session( 4960 ts_params->valid_devs[0], 4961 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT 4962 : RTE_CRYPTO_CIPHER_OP_ENCRYPT), 4963 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY 4964 : RTE_CRYPTO_AUTH_OP_GENERATE), 4965 RTE_CRYPTO_AUTH_SNOW3G_UIA2, 4966 RTE_CRYPTO_CIPHER_SNOW3G_UEA2, 4967 tdata->key.data, tdata->key.len, 4968 tdata->auth_iv.len, tdata->digest.len, 4969 tdata->cipher_iv.len); 4970 if (retval != 0) 4971 return retval; 4972 4973 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 4974 if (op_mode == OUT_OF_PLACE) 4975 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 4976 4977 /* clear mbuf payload */ 4978 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 4979 rte_pktmbuf_tailroom(ut_params->ibuf)); 4980 if (op_mode == OUT_OF_PLACE) 4981 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0, 4982 rte_pktmbuf_tailroom(ut_params->obuf)); 4983 4984 ciphertext_len = ceil_byte_length(tdata->ciphertext.len); 4985 plaintext_len = ceil_byte_length(tdata->plaintext.len); 4986 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16); 4987 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); 4988 4989 if (verify) { 4990 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 4991 ciphertext_pad_len); 4992 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len); 4993 if (op_mode == OUT_OF_PLACE) 4994 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len); 4995 debug_hexdump(stdout, "ciphertext:", ciphertext, 4996 ciphertext_len); 4997 } else { 4998 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 4999 plaintext_pad_len); 5000 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 5001 if (op_mode == OUT_OF_PLACE) 5002 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len); 5003 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len); 5004 } 5005 5006 /* Create SNOW 3G operation */ 5007 retval = create_wireless_algo_auth_cipher_operation( 5008 tdata->digest.data, tdata->digest.len, 5009 tdata->cipher_iv.data, tdata->cipher_iv.len, 5010 tdata->auth_iv.data, tdata->auth_iv.len, 5011 (tdata->digest.offset_bytes == 0 ? 5012 (verify ? ciphertext_pad_len : plaintext_pad_len) 5013 : tdata->digest.offset_bytes), 5014 tdata->validCipherLenInBits.len, 5015 tdata->cipher.offset_bits, 5016 tdata->validAuthLenInBits.len, 5017 tdata->auth.offset_bits, 5018 op_mode, 0, verify); 5019 5020 if (retval < 0) 5021 return retval; 5022 5023 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 5024 process_sym_raw_dp_op(ts_params->valid_devs[0], 0, 5025 ut_params->op, 1, 1, 1, tdata->cipher_iv.len); 5026 else 5027 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 5028 ut_params->op); 5029 5030 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 5031 5032 ut_params->obuf = (op_mode == IN_PLACE ? 5033 ut_params->op->sym->m_src : ut_params->op->sym->m_dst); 5034 5035 if (verify) { 5036 if (ut_params->obuf) 5037 plaintext = rte_pktmbuf_mtod(ut_params->obuf, 5038 uint8_t *); 5039 else 5040 plaintext = ciphertext + 5041 (tdata->cipher.offset_bits >> 3); 5042 5043 debug_hexdump(stdout, "plaintext:", plaintext, 5044 (tdata->plaintext.len >> 3) - tdata->digest.len); 5045 debug_hexdump(stdout, "plaintext expected:", 5046 tdata->plaintext.data, 5047 (tdata->plaintext.len >> 3) - tdata->digest.len); 5048 } else { 5049 if (ut_params->obuf) 5050 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, 5051 uint8_t *); 5052 else 5053 ciphertext = plaintext; 5054 5055 debug_hexdump(stdout, "ciphertext:", ciphertext, 5056 ciphertext_len); 5057 debug_hexdump(stdout, "ciphertext expected:", 5058 tdata->ciphertext.data, tdata->ciphertext.len >> 3); 5059 5060 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 5061 + (tdata->digest.offset_bytes == 0 ? 5062 plaintext_pad_len : tdata->digest.offset_bytes); 5063 5064 debug_hexdump(stdout, "digest:", ut_params->digest, 5065 tdata->digest.len); 5066 debug_hexdump(stdout, "digest expected:", tdata->digest.data, 5067 tdata->digest.len); 5068 } 5069 5070 /* Validate obuf */ 5071 if (verify) { 5072 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET( 5073 plaintext, 5074 tdata->plaintext.data, 5075 (tdata->plaintext.len - tdata->cipher.offset_bits - 5076 (tdata->digest.len << 3)), 5077 tdata->cipher.offset_bits, 5078 "SNOW 3G Plaintext data not as expected"); 5079 } else { 5080 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET( 5081 ciphertext, 5082 tdata->ciphertext.data, 5083 (tdata->validDataLenInBits.len - 5084 tdata->cipher.offset_bits), 5085 tdata->cipher.offset_bits, 5086 "SNOW 3G Ciphertext data not as expected"); 5087 5088 TEST_ASSERT_BUFFERS_ARE_EQUAL( 5089 ut_params->digest, 5090 tdata->digest.data, 5091 DIGEST_BYTE_LENGTH_SNOW3G_UIA2, 5092 "SNOW 3G Generated auth tag not as expected"); 5093 } 5094 return 0; 5095 } 5096 5097 static int 5098 test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata, 5099 uint8_t op_mode, uint8_t verify) 5100 { 5101 struct crypto_testsuite_params *ts_params = &testsuite_params; 5102 struct crypto_unittest_params *ut_params = &unittest_params; 5103 5104 int retval; 5105 5106 const uint8_t *plaintext = NULL; 5107 const uint8_t *ciphertext = NULL; 5108 const uint8_t *digest = NULL; 5109 unsigned int plaintext_pad_len; 5110 unsigned int plaintext_len; 5111 unsigned int ciphertext_pad_len; 5112 unsigned int ciphertext_len; 5113 uint8_t buffer[10000]; 5114 uint8_t digest_buffer[10000]; 5115 5116 struct rte_cryptodev_info dev_info; 5117 5118 /* Verify the capabilities */ 5119 struct rte_cryptodev_sym_capability_idx cap_idx; 5120 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; 5121 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2; 5122 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 5123 &cap_idx) == NULL) 5124 return TEST_SKIPPED; 5125 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 5126 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2; 5127 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 5128 &cap_idx) == NULL) 5129 return TEST_SKIPPED; 5130 5131 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 5132 return TEST_SKIPPED; 5133 5134 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 5135 5136 uint64_t feat_flags = dev_info.feature_flags; 5137 5138 if (op_mode == IN_PLACE) { 5139 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) { 5140 printf("Device doesn't support in-place scatter-gather " 5141 "in both input and output mbufs.\n"); 5142 return TEST_SKIPPED; 5143 } 5144 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 5145 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 5146 printf("Device doesn't support RAW data-path APIs.\n"); 5147 return TEST_SKIPPED; 5148 } 5149 } else { 5150 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 5151 return TEST_SKIPPED; 5152 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) { 5153 printf("Device doesn't support out-of-place scatter-gather " 5154 "in both input and output mbufs.\n"); 5155 return TEST_SKIPPED; 5156 } 5157 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) { 5158 printf("Device doesn't support digest encrypted.\n"); 5159 return TEST_SKIPPED; 5160 } 5161 } 5162 5163 /* Create SNOW 3G session */ 5164 retval = create_wireless_algo_auth_cipher_session( 5165 ts_params->valid_devs[0], 5166 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT 5167 : RTE_CRYPTO_CIPHER_OP_ENCRYPT), 5168 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY 5169 : RTE_CRYPTO_AUTH_OP_GENERATE), 5170 RTE_CRYPTO_AUTH_SNOW3G_UIA2, 5171 RTE_CRYPTO_CIPHER_SNOW3G_UEA2, 5172 tdata->key.data, tdata->key.len, 5173 tdata->auth_iv.len, tdata->digest.len, 5174 tdata->cipher_iv.len); 5175 5176 if (retval != 0) 5177 return retval; 5178 5179 ciphertext_len = ceil_byte_length(tdata->ciphertext.len); 5180 plaintext_len = ceil_byte_length(tdata->plaintext.len); 5181 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16); 5182 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); 5183 5184 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool, 5185 plaintext_pad_len, 15, 0); 5186 TEST_ASSERT_NOT_NULL(ut_params->ibuf, 5187 "Failed to allocate input buffer in mempool"); 5188 5189 if (op_mode == OUT_OF_PLACE) { 5190 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool, 5191 plaintext_pad_len, 15, 0); 5192 TEST_ASSERT_NOT_NULL(ut_params->obuf, 5193 "Failed to allocate output buffer in mempool"); 5194 } 5195 5196 if (verify) { 5197 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len, 5198 tdata->ciphertext.data); 5199 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0, 5200 ciphertext_len, buffer); 5201 debug_hexdump(stdout, "ciphertext:", ciphertext, 5202 ciphertext_len); 5203 } else { 5204 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, 5205 tdata->plaintext.data); 5206 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0, 5207 plaintext_len, buffer); 5208 debug_hexdump(stdout, "plaintext:", plaintext, 5209 plaintext_len); 5210 } 5211 memset(buffer, 0, sizeof(buffer)); 5212 5213 /* Create SNOW 3G operation */ 5214 retval = create_wireless_algo_auth_cipher_operation( 5215 tdata->digest.data, tdata->digest.len, 5216 tdata->cipher_iv.data, tdata->cipher_iv.len, 5217 tdata->auth_iv.data, tdata->auth_iv.len, 5218 (tdata->digest.offset_bytes == 0 ? 5219 (verify ? ciphertext_pad_len : plaintext_pad_len) 5220 : tdata->digest.offset_bytes), 5221 tdata->validCipherLenInBits.len, 5222 tdata->cipher.offset_bits, 5223 tdata->validAuthLenInBits.len, 5224 tdata->auth.offset_bits, 5225 op_mode, 1, verify); 5226 5227 if (retval < 0) 5228 return retval; 5229 5230 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 5231 process_sym_raw_dp_op(ts_params->valid_devs[0], 0, 5232 ut_params->op, 1, 1, 1, tdata->cipher_iv.len); 5233 else 5234 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 5235 ut_params->op); 5236 5237 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 5238 5239 ut_params->obuf = (op_mode == IN_PLACE ? 5240 ut_params->op->sym->m_src : ut_params->op->sym->m_dst); 5241 5242 if (verify) { 5243 if (ut_params->obuf) 5244 plaintext = rte_pktmbuf_read(ut_params->obuf, 0, 5245 plaintext_len, buffer); 5246 else 5247 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0, 5248 plaintext_len, buffer); 5249 5250 debug_hexdump(stdout, "plaintext:", plaintext, 5251 (tdata->plaintext.len >> 3) - tdata->digest.len); 5252 debug_hexdump(stdout, "plaintext expected:", 5253 tdata->plaintext.data, 5254 (tdata->plaintext.len >> 3) - tdata->digest.len); 5255 } else { 5256 if (ut_params->obuf) 5257 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0, 5258 ciphertext_len, buffer); 5259 else 5260 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0, 5261 ciphertext_len, buffer); 5262 5263 debug_hexdump(stdout, "ciphertext:", ciphertext, 5264 ciphertext_len); 5265 debug_hexdump(stdout, "ciphertext expected:", 5266 tdata->ciphertext.data, tdata->ciphertext.len >> 3); 5267 5268 if (ut_params->obuf) 5269 digest = rte_pktmbuf_read(ut_params->obuf, 5270 (tdata->digest.offset_bytes == 0 ? 5271 plaintext_pad_len : tdata->digest.offset_bytes), 5272 tdata->digest.len, digest_buffer); 5273 else 5274 digest = rte_pktmbuf_read(ut_params->ibuf, 5275 (tdata->digest.offset_bytes == 0 ? 5276 plaintext_pad_len : tdata->digest.offset_bytes), 5277 tdata->digest.len, digest_buffer); 5278 5279 debug_hexdump(stdout, "digest:", digest, 5280 tdata->digest.len); 5281 debug_hexdump(stdout, "digest expected:", 5282 tdata->digest.data, tdata->digest.len); 5283 } 5284 5285 /* Validate obuf */ 5286 if (verify) { 5287 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET( 5288 plaintext, 5289 tdata->plaintext.data, 5290 (tdata->plaintext.len - tdata->cipher.offset_bits - 5291 (tdata->digest.len << 3)), 5292 tdata->cipher.offset_bits, 5293 "SNOW 3G Plaintext data not as expected"); 5294 } else { 5295 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET( 5296 ciphertext, 5297 tdata->ciphertext.data, 5298 (tdata->validDataLenInBits.len - 5299 tdata->cipher.offset_bits), 5300 tdata->cipher.offset_bits, 5301 "SNOW 3G Ciphertext data not as expected"); 5302 5303 TEST_ASSERT_BUFFERS_ARE_EQUAL( 5304 digest, 5305 tdata->digest.data, 5306 DIGEST_BYTE_LENGTH_SNOW3G_UIA2, 5307 "SNOW 3G Generated auth tag not as expected"); 5308 } 5309 return 0; 5310 } 5311 5312 static int 5313 test_kasumi_auth_cipher(const struct kasumi_test_data *tdata, 5314 uint8_t op_mode, uint8_t verify) 5315 { 5316 struct crypto_testsuite_params *ts_params = &testsuite_params; 5317 struct crypto_unittest_params *ut_params = &unittest_params; 5318 5319 int retval; 5320 5321 uint8_t *plaintext = NULL, *ciphertext = NULL; 5322 unsigned int plaintext_pad_len; 5323 unsigned int plaintext_len; 5324 unsigned int ciphertext_pad_len; 5325 unsigned int ciphertext_len; 5326 5327 struct rte_cryptodev_info dev_info; 5328 5329 /* Verify the capabilities */ 5330 struct rte_cryptodev_sym_capability_idx cap_idx; 5331 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; 5332 cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9; 5333 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 5334 &cap_idx) == NULL) 5335 return TEST_SKIPPED; 5336 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 5337 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8; 5338 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 5339 &cap_idx) == NULL) 5340 return TEST_SKIPPED; 5341 5342 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 5343 5344 uint64_t feat_flags = dev_info.feature_flags; 5345 5346 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 5347 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 5348 printf("Device doesn't support RAW data-path APIs.\n"); 5349 return TEST_SKIPPED; 5350 } 5351 5352 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 5353 return TEST_SKIPPED; 5354 5355 if (op_mode == OUT_OF_PLACE) { 5356 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 5357 return TEST_SKIPPED; 5358 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) { 5359 printf("Device doesn't support digest encrypted.\n"); 5360 return TEST_SKIPPED; 5361 } 5362 } 5363 5364 /* Create KASUMI session */ 5365 retval = create_wireless_algo_auth_cipher_session( 5366 ts_params->valid_devs[0], 5367 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT 5368 : RTE_CRYPTO_CIPHER_OP_ENCRYPT), 5369 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY 5370 : RTE_CRYPTO_AUTH_OP_GENERATE), 5371 RTE_CRYPTO_AUTH_KASUMI_F9, 5372 RTE_CRYPTO_CIPHER_KASUMI_F8, 5373 tdata->key.data, tdata->key.len, 5374 0, tdata->digest.len, 5375 tdata->cipher_iv.len); 5376 5377 if (retval != 0) 5378 return retval; 5379 5380 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 5381 if (op_mode == OUT_OF_PLACE) 5382 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 5383 5384 /* clear mbuf payload */ 5385 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 5386 rte_pktmbuf_tailroom(ut_params->ibuf)); 5387 if (op_mode == OUT_OF_PLACE) 5388 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0, 5389 rte_pktmbuf_tailroom(ut_params->obuf)); 5390 5391 ciphertext_len = ceil_byte_length(tdata->ciphertext.len); 5392 plaintext_len = ceil_byte_length(tdata->plaintext.len); 5393 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16); 5394 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); 5395 5396 if (verify) { 5397 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 5398 ciphertext_pad_len); 5399 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len); 5400 if (op_mode == OUT_OF_PLACE) 5401 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len); 5402 debug_hexdump(stdout, "ciphertext:", ciphertext, 5403 ciphertext_len); 5404 } else { 5405 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 5406 plaintext_pad_len); 5407 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 5408 if (op_mode == OUT_OF_PLACE) 5409 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len); 5410 debug_hexdump(stdout, "plaintext:", plaintext, 5411 plaintext_len); 5412 } 5413 5414 /* Create KASUMI operation */ 5415 retval = create_wireless_algo_auth_cipher_operation( 5416 tdata->digest.data, tdata->digest.len, 5417 tdata->cipher_iv.data, tdata->cipher_iv.len, 5418 NULL, 0, 5419 (tdata->digest.offset_bytes == 0 ? 5420 (verify ? ciphertext_pad_len : plaintext_pad_len) 5421 : tdata->digest.offset_bytes), 5422 tdata->validCipherLenInBits.len, 5423 tdata->validCipherOffsetInBits.len, 5424 tdata->validAuthLenInBits.len, 5425 0, 5426 op_mode, 0, verify); 5427 5428 if (retval < 0) 5429 return retval; 5430 5431 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 5432 process_sym_raw_dp_op(ts_params->valid_devs[0], 0, 5433 ut_params->op, 1, 1, 1, tdata->cipher_iv.len); 5434 else 5435 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 5436 ut_params->op); 5437 5438 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 5439 5440 ut_params->obuf = (op_mode == IN_PLACE ? 5441 ut_params->op->sym->m_src : ut_params->op->sym->m_dst); 5442 5443 5444 if (verify) { 5445 if (ut_params->obuf) 5446 plaintext = rte_pktmbuf_mtod(ut_params->obuf, 5447 uint8_t *); 5448 else 5449 plaintext = ciphertext; 5450 5451 debug_hexdump(stdout, "plaintext:", plaintext, 5452 (tdata->plaintext.len >> 3) - tdata->digest.len); 5453 debug_hexdump(stdout, "plaintext expected:", 5454 tdata->plaintext.data, 5455 (tdata->plaintext.len >> 3) - tdata->digest.len); 5456 } else { 5457 if (ut_params->obuf) 5458 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, 5459 uint8_t *); 5460 else 5461 ciphertext = plaintext; 5462 5463 debug_hexdump(stdout, "ciphertext:", ciphertext, 5464 ciphertext_len); 5465 debug_hexdump(stdout, "ciphertext expected:", 5466 tdata->ciphertext.data, tdata->ciphertext.len >> 3); 5467 5468 ut_params->digest = rte_pktmbuf_mtod( 5469 ut_params->obuf, uint8_t *) + 5470 (tdata->digest.offset_bytes == 0 ? 5471 plaintext_pad_len : tdata->digest.offset_bytes); 5472 5473 debug_hexdump(stdout, "digest:", ut_params->digest, 5474 tdata->digest.len); 5475 debug_hexdump(stdout, "digest expected:", 5476 tdata->digest.data, tdata->digest.len); 5477 } 5478 5479 /* Validate obuf */ 5480 if (verify) { 5481 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 5482 plaintext, 5483 tdata->plaintext.data, 5484 tdata->plaintext.len >> 3, 5485 "KASUMI Plaintext data not as expected"); 5486 } else { 5487 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 5488 ciphertext, 5489 tdata->ciphertext.data, 5490 tdata->ciphertext.len >> 3, 5491 "KASUMI Ciphertext data not as expected"); 5492 5493 TEST_ASSERT_BUFFERS_ARE_EQUAL( 5494 ut_params->digest, 5495 tdata->digest.data, 5496 DIGEST_BYTE_LENGTH_KASUMI_F9, 5497 "KASUMI Generated auth tag not as expected"); 5498 } 5499 return 0; 5500 } 5501 5502 static int 5503 test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata, 5504 uint8_t op_mode, uint8_t verify) 5505 { 5506 struct crypto_testsuite_params *ts_params = &testsuite_params; 5507 struct crypto_unittest_params *ut_params = &unittest_params; 5508 5509 int retval; 5510 5511 const uint8_t *plaintext = NULL; 5512 const uint8_t *ciphertext = NULL; 5513 const uint8_t *digest = NULL; 5514 unsigned int plaintext_pad_len; 5515 unsigned int plaintext_len; 5516 unsigned int ciphertext_pad_len; 5517 unsigned int ciphertext_len; 5518 uint8_t buffer[10000]; 5519 uint8_t digest_buffer[10000]; 5520 5521 struct rte_cryptodev_info dev_info; 5522 5523 /* Verify the capabilities */ 5524 struct rte_cryptodev_sym_capability_idx cap_idx; 5525 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; 5526 cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9; 5527 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 5528 &cap_idx) == NULL) 5529 return TEST_SKIPPED; 5530 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 5531 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8; 5532 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 5533 &cap_idx) == NULL) 5534 return TEST_SKIPPED; 5535 5536 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 5537 return TEST_SKIPPED; 5538 5539 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 5540 5541 uint64_t feat_flags = dev_info.feature_flags; 5542 5543 if (op_mode == IN_PLACE) { 5544 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) { 5545 printf("Device doesn't support in-place scatter-gather " 5546 "in both input and output mbufs.\n"); 5547 return TEST_SKIPPED; 5548 } 5549 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 5550 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 5551 printf("Device doesn't support RAW data-path APIs.\n"); 5552 return TEST_SKIPPED; 5553 } 5554 } else { 5555 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 5556 return TEST_SKIPPED; 5557 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) { 5558 printf("Device doesn't support out-of-place scatter-gather " 5559 "in both input and output mbufs.\n"); 5560 return TEST_SKIPPED; 5561 } 5562 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) { 5563 printf("Device doesn't support digest encrypted.\n"); 5564 return TEST_SKIPPED; 5565 } 5566 } 5567 5568 /* Create KASUMI session */ 5569 retval = create_wireless_algo_auth_cipher_session( 5570 ts_params->valid_devs[0], 5571 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT 5572 : RTE_CRYPTO_CIPHER_OP_ENCRYPT), 5573 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY 5574 : RTE_CRYPTO_AUTH_OP_GENERATE), 5575 RTE_CRYPTO_AUTH_KASUMI_F9, 5576 RTE_CRYPTO_CIPHER_KASUMI_F8, 5577 tdata->key.data, tdata->key.len, 5578 0, tdata->digest.len, 5579 tdata->cipher_iv.len); 5580 5581 if (retval != 0) 5582 return retval; 5583 5584 ciphertext_len = ceil_byte_length(tdata->ciphertext.len); 5585 plaintext_len = ceil_byte_length(tdata->plaintext.len); 5586 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16); 5587 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); 5588 5589 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool, 5590 plaintext_pad_len, 15, 0); 5591 TEST_ASSERT_NOT_NULL(ut_params->ibuf, 5592 "Failed to allocate input buffer in mempool"); 5593 5594 if (op_mode == OUT_OF_PLACE) { 5595 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool, 5596 plaintext_pad_len, 15, 0); 5597 TEST_ASSERT_NOT_NULL(ut_params->obuf, 5598 "Failed to allocate output buffer in mempool"); 5599 } 5600 5601 if (verify) { 5602 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len, 5603 tdata->ciphertext.data); 5604 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0, 5605 ciphertext_len, buffer); 5606 debug_hexdump(stdout, "ciphertext:", ciphertext, 5607 ciphertext_len); 5608 } else { 5609 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, 5610 tdata->plaintext.data); 5611 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0, 5612 plaintext_len, buffer); 5613 debug_hexdump(stdout, "plaintext:", plaintext, 5614 plaintext_len); 5615 } 5616 memset(buffer, 0, sizeof(buffer)); 5617 5618 /* Create KASUMI operation */ 5619 retval = create_wireless_algo_auth_cipher_operation( 5620 tdata->digest.data, tdata->digest.len, 5621 tdata->cipher_iv.data, tdata->cipher_iv.len, 5622 NULL, 0, 5623 (tdata->digest.offset_bytes == 0 ? 5624 (verify ? ciphertext_pad_len : plaintext_pad_len) 5625 : tdata->digest.offset_bytes), 5626 tdata->validCipherLenInBits.len, 5627 tdata->validCipherOffsetInBits.len, 5628 tdata->validAuthLenInBits.len, 5629 0, 5630 op_mode, 1, verify); 5631 5632 if (retval < 0) 5633 return retval; 5634 5635 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 5636 process_sym_raw_dp_op(ts_params->valid_devs[0], 0, 5637 ut_params->op, 1, 1, 1, tdata->cipher_iv.len); 5638 else 5639 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 5640 ut_params->op); 5641 5642 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 5643 5644 ut_params->obuf = (op_mode == IN_PLACE ? 5645 ut_params->op->sym->m_src : ut_params->op->sym->m_dst); 5646 5647 if (verify) { 5648 if (ut_params->obuf) 5649 plaintext = rte_pktmbuf_read(ut_params->obuf, 0, 5650 plaintext_len, buffer); 5651 else 5652 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0, 5653 plaintext_len, buffer); 5654 5655 debug_hexdump(stdout, "plaintext:", plaintext, 5656 (tdata->plaintext.len >> 3) - tdata->digest.len); 5657 debug_hexdump(stdout, "plaintext expected:", 5658 tdata->plaintext.data, 5659 (tdata->plaintext.len >> 3) - tdata->digest.len); 5660 } else { 5661 if (ut_params->obuf) 5662 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0, 5663 ciphertext_len, buffer); 5664 else 5665 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0, 5666 ciphertext_len, buffer); 5667 5668 debug_hexdump(stdout, "ciphertext:", ciphertext, 5669 ciphertext_len); 5670 debug_hexdump(stdout, "ciphertext expected:", 5671 tdata->ciphertext.data, tdata->ciphertext.len >> 3); 5672 5673 if (ut_params->obuf) 5674 digest = rte_pktmbuf_read(ut_params->obuf, 5675 (tdata->digest.offset_bytes == 0 ? 5676 plaintext_pad_len : tdata->digest.offset_bytes), 5677 tdata->digest.len, digest_buffer); 5678 else 5679 digest = rte_pktmbuf_read(ut_params->ibuf, 5680 (tdata->digest.offset_bytes == 0 ? 5681 plaintext_pad_len : tdata->digest.offset_bytes), 5682 tdata->digest.len, digest_buffer); 5683 5684 debug_hexdump(stdout, "digest:", digest, 5685 tdata->digest.len); 5686 debug_hexdump(stdout, "digest expected:", 5687 tdata->digest.data, tdata->digest.len); 5688 } 5689 5690 /* Validate obuf */ 5691 if (verify) { 5692 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 5693 plaintext, 5694 tdata->plaintext.data, 5695 tdata->plaintext.len >> 3, 5696 "KASUMI Plaintext data not as expected"); 5697 } else { 5698 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 5699 ciphertext, 5700 tdata->ciphertext.data, 5701 tdata->validDataLenInBits.len, 5702 "KASUMI Ciphertext data not as expected"); 5703 5704 TEST_ASSERT_BUFFERS_ARE_EQUAL( 5705 digest, 5706 tdata->digest.data, 5707 DIGEST_BYTE_LENGTH_KASUMI_F9, 5708 "KASUMI Generated auth tag not as expected"); 5709 } 5710 return 0; 5711 } 5712 5713 static int 5714 test_kasumi_cipher_auth(const struct kasumi_test_data *tdata) 5715 { 5716 struct crypto_testsuite_params *ts_params = &testsuite_params; 5717 struct crypto_unittest_params *ut_params = &unittest_params; 5718 5719 int retval; 5720 5721 uint8_t *plaintext, *ciphertext; 5722 unsigned plaintext_pad_len; 5723 unsigned plaintext_len; 5724 struct rte_cryptodev_info dev_info; 5725 5726 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 5727 uint64_t feat_flags = dev_info.feature_flags; 5728 5729 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 5730 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 5731 printf("Device doesn't support RAW data-path APIs.\n"); 5732 return TEST_SKIPPED; 5733 } 5734 5735 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 5736 return TEST_SKIPPED; 5737 5738 /* Verify the capabilities */ 5739 struct rte_cryptodev_sym_capability_idx cap_idx; 5740 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; 5741 cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9; 5742 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 5743 &cap_idx) == NULL) 5744 return TEST_SKIPPED; 5745 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 5746 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8; 5747 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 5748 &cap_idx) == NULL) 5749 return TEST_SKIPPED; 5750 5751 /* Create KASUMI session */ 5752 retval = create_wireless_algo_cipher_auth_session( 5753 ts_params->valid_devs[0], 5754 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 5755 RTE_CRYPTO_AUTH_OP_GENERATE, 5756 RTE_CRYPTO_AUTH_KASUMI_F9, 5757 RTE_CRYPTO_CIPHER_KASUMI_F8, 5758 tdata->key.data, tdata->key.len, 5759 0, tdata->digest.len, 5760 tdata->cipher_iv.len); 5761 if (retval != 0) 5762 return retval; 5763 5764 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 5765 5766 /* clear mbuf payload */ 5767 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 5768 rte_pktmbuf_tailroom(ut_params->ibuf)); 5769 5770 plaintext_len = ceil_byte_length(tdata->plaintext.len); 5771 /* Append data which is padded to a multiple of */ 5772 /* the algorithms block size */ 5773 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); 5774 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 5775 plaintext_pad_len); 5776 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 5777 5778 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len); 5779 5780 /* Create KASUMI operation */ 5781 retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data, 5782 tdata->digest.len, NULL, 0, 5783 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE, 5784 tdata->cipher_iv.data, tdata->cipher_iv.len, 5785 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8), 5786 tdata->validCipherOffsetInBits.len, 5787 tdata->validAuthLenInBits.len, 5788 0 5789 ); 5790 if (retval < 0) 5791 return retval; 5792 5793 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 5794 process_sym_raw_dp_op(ts_params->valid_devs[0], 0, 5795 ut_params->op, 1, 1, 1, tdata->cipher_iv.len); 5796 else 5797 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 5798 ut_params->op); 5799 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 5800 5801 if (ut_params->op->sym->m_dst) 5802 ut_params->obuf = ut_params->op->sym->m_dst; 5803 else 5804 ut_params->obuf = ut_params->op->sym->m_src; 5805 5806 ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *, 5807 tdata->validCipherOffsetInBits.len >> 3); 5808 5809 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 5810 + plaintext_pad_len; 5811 5812 const uint8_t *reference_ciphertext = tdata->ciphertext.data + 5813 (tdata->validCipherOffsetInBits.len >> 3); 5814 /* Validate obuf */ 5815 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 5816 ciphertext, 5817 reference_ciphertext, 5818 tdata->validCipherLenInBits.len, 5819 "KASUMI Ciphertext data not as expected"); 5820 5821 /* Validate obuf */ 5822 TEST_ASSERT_BUFFERS_ARE_EQUAL( 5823 ut_params->digest, 5824 tdata->digest.data, 5825 DIGEST_BYTE_LENGTH_SNOW3G_UIA2, 5826 "KASUMI Generated auth tag not as expected"); 5827 return 0; 5828 } 5829 5830 static int 5831 test_zuc_encryption(const struct wireless_test_data *tdata) 5832 { 5833 struct crypto_testsuite_params *ts_params = &testsuite_params; 5834 struct crypto_unittest_params *ut_params = &unittest_params; 5835 5836 int retval; 5837 uint8_t *plaintext, *ciphertext; 5838 unsigned plaintext_pad_len; 5839 unsigned plaintext_len; 5840 struct rte_cryptodev_info dev_info; 5841 5842 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 5843 uint64_t feat_flags = dev_info.feature_flags; 5844 5845 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 5846 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 5847 printf("Device doesn't support RAW data-path APIs.\n"); 5848 return TEST_SKIPPED; 5849 } 5850 5851 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 5852 return TEST_SKIPPED; 5853 5854 struct rte_cryptodev_sym_capability_idx cap_idx; 5855 5856 /* Check if device supports ZUC EEA3 */ 5857 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 5858 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3; 5859 5860 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 5861 &cap_idx) == NULL) 5862 return TEST_SKIPPED; 5863 5864 /* Create ZUC session */ 5865 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], 5866 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 5867 RTE_CRYPTO_CIPHER_ZUC_EEA3, 5868 tdata->key.data, tdata->key.len, 5869 tdata->cipher_iv.len); 5870 if (retval != 0) 5871 return retval; 5872 5873 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 5874 5875 /* Clear mbuf payload */ 5876 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 5877 rte_pktmbuf_tailroom(ut_params->ibuf)); 5878 5879 plaintext_len = ceil_byte_length(tdata->plaintext.len); 5880 /* Append data which is padded to a multiple */ 5881 /* of the algorithms block size */ 5882 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); 5883 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 5884 plaintext_pad_len); 5885 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 5886 5887 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len); 5888 5889 /* Create ZUC operation */ 5890 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data, 5891 tdata->cipher_iv.len, 5892 tdata->plaintext.len, 5893 0); 5894 if (retval < 0) 5895 return retval; 5896 5897 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 5898 process_sym_raw_dp_op(ts_params->valid_devs[0], 0, 5899 ut_params->op, 1, 0, 1, tdata->cipher_iv.len); 5900 else 5901 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 5902 ut_params->op); 5903 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 5904 5905 ut_params->obuf = ut_params->op->sym->m_dst; 5906 if (ut_params->obuf) 5907 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *); 5908 else 5909 ciphertext = plaintext; 5910 5911 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len); 5912 5913 /* Validate obuf */ 5914 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 5915 ciphertext, 5916 tdata->ciphertext.data, 5917 tdata->validCipherLenInBits.len, 5918 "ZUC Ciphertext data not as expected"); 5919 return 0; 5920 } 5921 5922 static int 5923 test_zuc_encryption_sgl(const struct wireless_test_data *tdata) 5924 { 5925 struct crypto_testsuite_params *ts_params = &testsuite_params; 5926 struct crypto_unittest_params *ut_params = &unittest_params; 5927 5928 int retval; 5929 5930 unsigned int plaintext_pad_len; 5931 unsigned int plaintext_len; 5932 const uint8_t *ciphertext; 5933 uint8_t ciphertext_buffer[2048]; 5934 struct rte_cryptodev_info dev_info; 5935 5936 struct rte_cryptodev_sym_capability_idx cap_idx; 5937 5938 /* Check if device supports ZUC EEA3 */ 5939 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 5940 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3; 5941 5942 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 5943 &cap_idx) == NULL) 5944 return TEST_SKIPPED; 5945 5946 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 5947 return TEST_SKIPPED; 5948 5949 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 5950 5951 uint64_t feat_flags = dev_info.feature_flags; 5952 5953 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) { 5954 printf("Device doesn't support in-place scatter-gather. " 5955 "Test Skipped.\n"); 5956 return TEST_SKIPPED; 5957 } 5958 5959 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 5960 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 5961 printf("Device doesn't support RAW data-path APIs.\n"); 5962 return TEST_SKIPPED; 5963 } 5964 5965 plaintext_len = ceil_byte_length(tdata->plaintext.len); 5966 5967 /* Append data which is padded to a multiple */ 5968 /* of the algorithms block size */ 5969 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); 5970 5971 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool, 5972 plaintext_pad_len, 10, 0); 5973 5974 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, 5975 tdata->plaintext.data); 5976 5977 /* Create ZUC session */ 5978 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], 5979 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 5980 RTE_CRYPTO_CIPHER_ZUC_EEA3, 5981 tdata->key.data, tdata->key.len, 5982 tdata->cipher_iv.len); 5983 if (retval < 0) 5984 return retval; 5985 5986 /* Clear mbuf payload */ 5987 5988 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data); 5989 5990 /* Create ZUC operation */ 5991 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data, 5992 tdata->cipher_iv.len, tdata->plaintext.len, 5993 0); 5994 if (retval < 0) 5995 return retval; 5996 5997 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 5998 process_sym_raw_dp_op(ts_params->valid_devs[0], 0, 5999 ut_params->op, 1, 0, 1, tdata->cipher_iv.len); 6000 else 6001 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 6002 ut_params->op); 6003 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 6004 6005 ut_params->obuf = ut_params->op->sym->m_dst; 6006 if (ut_params->obuf) 6007 ciphertext = rte_pktmbuf_read(ut_params->obuf, 6008 0, plaintext_len, ciphertext_buffer); 6009 else 6010 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 6011 0, plaintext_len, ciphertext_buffer); 6012 6013 /* Validate obuf */ 6014 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len); 6015 6016 /* Validate obuf */ 6017 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 6018 ciphertext, 6019 tdata->ciphertext.data, 6020 tdata->validCipherLenInBits.len, 6021 "ZUC Ciphertext data not as expected"); 6022 6023 return 0; 6024 } 6025 6026 static int 6027 test_zuc_authentication(const struct wireless_test_data *tdata) 6028 { 6029 struct crypto_testsuite_params *ts_params = &testsuite_params; 6030 struct crypto_unittest_params *ut_params = &unittest_params; 6031 6032 int retval; 6033 unsigned plaintext_pad_len; 6034 unsigned plaintext_len; 6035 uint8_t *plaintext; 6036 6037 struct rte_cryptodev_sym_capability_idx cap_idx; 6038 struct rte_cryptodev_info dev_info; 6039 6040 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 6041 uint64_t feat_flags = dev_info.feature_flags; 6042 6043 if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) && 6044 (tdata->validAuthLenInBits.len % 8 != 0)) { 6045 printf("Device doesn't support NON-Byte Aligned Data.\n"); 6046 return TEST_SKIPPED; 6047 } 6048 6049 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 6050 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 6051 printf("Device doesn't support RAW data-path APIs.\n"); 6052 return TEST_SKIPPED; 6053 } 6054 6055 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 6056 return TEST_SKIPPED; 6057 6058 /* Check if device supports ZUC EIA3 */ 6059 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; 6060 cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3; 6061 6062 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 6063 &cap_idx) == NULL) 6064 return TEST_SKIPPED; 6065 6066 /* Create ZUC session */ 6067 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0], 6068 tdata->key.data, tdata->key.len, 6069 tdata->auth_iv.len, tdata->digest.len, 6070 RTE_CRYPTO_AUTH_OP_GENERATE, 6071 RTE_CRYPTO_AUTH_ZUC_EIA3); 6072 if (retval != 0) 6073 return retval; 6074 6075 /* alloc mbuf and set payload */ 6076 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 6077 6078 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 6079 rte_pktmbuf_tailroom(ut_params->ibuf)); 6080 6081 plaintext_len = ceil_byte_length(tdata->plaintext.len); 6082 /* Append data which is padded to a multiple of */ 6083 /* the algorithms block size */ 6084 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8); 6085 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 6086 plaintext_pad_len); 6087 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 6088 6089 /* Create ZUC operation */ 6090 retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len, 6091 tdata->auth_iv.data, tdata->auth_iv.len, 6092 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE, 6093 tdata->validAuthLenInBits.len, 6094 0); 6095 if (retval < 0) 6096 return retval; 6097 6098 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 6099 process_sym_raw_dp_op(ts_params->valid_devs[0], 0, 6100 ut_params->op, 0, 1, 1, 0); 6101 else 6102 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 6103 ut_params->op); 6104 ut_params->obuf = ut_params->op->sym->m_src; 6105 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 6106 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 6107 + plaintext_pad_len; 6108 6109 /* Validate obuf */ 6110 TEST_ASSERT_BUFFERS_ARE_EQUAL( 6111 ut_params->digest, 6112 tdata->digest.data, 6113 tdata->digest.len, 6114 "ZUC Generated auth tag not as expected"); 6115 6116 return 0; 6117 } 6118 6119 static int 6120 test_zuc_auth_cipher(const struct wireless_test_data *tdata, 6121 uint8_t op_mode, uint8_t verify) 6122 { 6123 struct crypto_testsuite_params *ts_params = &testsuite_params; 6124 struct crypto_unittest_params *ut_params = &unittest_params; 6125 6126 int retval; 6127 6128 uint8_t *plaintext = NULL, *ciphertext = NULL; 6129 unsigned int plaintext_pad_len; 6130 unsigned int plaintext_len; 6131 unsigned int ciphertext_pad_len; 6132 unsigned int ciphertext_len; 6133 6134 struct rte_cryptodev_info dev_info; 6135 struct rte_cryptodev_sym_capability_idx cap_idx; 6136 6137 /* Check if device supports ZUC EIA3 */ 6138 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; 6139 cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3; 6140 6141 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 6142 &cap_idx) == NULL) 6143 return TEST_SKIPPED; 6144 6145 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 6146 6147 uint64_t feat_flags = dev_info.feature_flags; 6148 6149 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) { 6150 printf("Device doesn't support digest encrypted.\n"); 6151 return TEST_SKIPPED; 6152 } 6153 if (op_mode == IN_PLACE) { 6154 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) { 6155 printf("Device doesn't support in-place scatter-gather " 6156 "in both input and output mbufs.\n"); 6157 return TEST_SKIPPED; 6158 } 6159 6160 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 6161 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 6162 printf("Device doesn't support RAW data-path APIs.\n"); 6163 return TEST_SKIPPED; 6164 } 6165 } else { 6166 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 6167 return TEST_SKIPPED; 6168 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) { 6169 printf("Device doesn't support out-of-place scatter-gather " 6170 "in both input and output mbufs.\n"); 6171 return TEST_SKIPPED; 6172 } 6173 } 6174 6175 /* Create ZUC session */ 6176 retval = create_wireless_algo_auth_cipher_session( 6177 ts_params->valid_devs[0], 6178 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT 6179 : RTE_CRYPTO_CIPHER_OP_ENCRYPT), 6180 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY 6181 : RTE_CRYPTO_AUTH_OP_GENERATE), 6182 RTE_CRYPTO_AUTH_ZUC_EIA3, 6183 RTE_CRYPTO_CIPHER_ZUC_EEA3, 6184 tdata->key.data, tdata->key.len, 6185 tdata->auth_iv.len, tdata->digest.len, 6186 tdata->cipher_iv.len); 6187 6188 if (retval != 0) 6189 return retval; 6190 6191 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 6192 if (op_mode == OUT_OF_PLACE) 6193 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 6194 6195 /* clear mbuf payload */ 6196 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 6197 rte_pktmbuf_tailroom(ut_params->ibuf)); 6198 if (op_mode == OUT_OF_PLACE) 6199 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0, 6200 rte_pktmbuf_tailroom(ut_params->obuf)); 6201 6202 ciphertext_len = ceil_byte_length(tdata->ciphertext.len); 6203 plaintext_len = ceil_byte_length(tdata->plaintext.len); 6204 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16); 6205 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); 6206 6207 if (verify) { 6208 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 6209 ciphertext_pad_len); 6210 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len); 6211 if (op_mode == OUT_OF_PLACE) 6212 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len); 6213 debug_hexdump(stdout, "ciphertext:", ciphertext, 6214 ciphertext_len); 6215 } else { 6216 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 6217 plaintext_pad_len); 6218 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 6219 if (op_mode == OUT_OF_PLACE) 6220 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len); 6221 debug_hexdump(stdout, "plaintext:", plaintext, 6222 plaintext_len); 6223 } 6224 6225 /* Create ZUC operation */ 6226 retval = create_wireless_algo_auth_cipher_operation( 6227 tdata->digest.data, tdata->digest.len, 6228 tdata->cipher_iv.data, tdata->cipher_iv.len, 6229 tdata->auth_iv.data, tdata->auth_iv.len, 6230 (tdata->digest.offset_bytes == 0 ? 6231 (verify ? ciphertext_pad_len : plaintext_pad_len) 6232 : tdata->digest.offset_bytes), 6233 tdata->validCipherLenInBits.len, 6234 tdata->validCipherOffsetInBits.len, 6235 tdata->validAuthLenInBits.len, 6236 0, 6237 op_mode, 0, verify); 6238 6239 if (retval < 0) 6240 return retval; 6241 6242 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 6243 process_sym_raw_dp_op(ts_params->valid_devs[0], 0, 6244 ut_params->op, 1, 1, 1, tdata->cipher_iv.len); 6245 else 6246 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 6247 ut_params->op); 6248 6249 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 6250 6251 ut_params->obuf = (op_mode == IN_PLACE ? 6252 ut_params->op->sym->m_src : ut_params->op->sym->m_dst); 6253 6254 6255 if (verify) { 6256 if (ut_params->obuf) 6257 plaintext = rte_pktmbuf_mtod(ut_params->obuf, 6258 uint8_t *); 6259 else 6260 plaintext = ciphertext; 6261 6262 debug_hexdump(stdout, "plaintext:", plaintext, 6263 (tdata->plaintext.len >> 3) - tdata->digest.len); 6264 debug_hexdump(stdout, "plaintext expected:", 6265 tdata->plaintext.data, 6266 (tdata->plaintext.len >> 3) - tdata->digest.len); 6267 } else { 6268 if (ut_params->obuf) 6269 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, 6270 uint8_t *); 6271 else 6272 ciphertext = plaintext; 6273 6274 debug_hexdump(stdout, "ciphertext:", ciphertext, 6275 ciphertext_len); 6276 debug_hexdump(stdout, "ciphertext expected:", 6277 tdata->ciphertext.data, tdata->ciphertext.len >> 3); 6278 6279 ut_params->digest = rte_pktmbuf_mtod( 6280 ut_params->obuf, uint8_t *) + 6281 (tdata->digest.offset_bytes == 0 ? 6282 plaintext_pad_len : tdata->digest.offset_bytes); 6283 6284 debug_hexdump(stdout, "digest:", ut_params->digest, 6285 tdata->digest.len); 6286 debug_hexdump(stdout, "digest expected:", 6287 tdata->digest.data, tdata->digest.len); 6288 } 6289 6290 /* Validate obuf */ 6291 if (verify) { 6292 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 6293 plaintext, 6294 tdata->plaintext.data, 6295 tdata->plaintext.len >> 3, 6296 "ZUC Plaintext data not as expected"); 6297 } else { 6298 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 6299 ciphertext, 6300 tdata->ciphertext.data, 6301 tdata->ciphertext.len >> 3, 6302 "ZUC Ciphertext data not as expected"); 6303 6304 TEST_ASSERT_BUFFERS_ARE_EQUAL( 6305 ut_params->digest, 6306 tdata->digest.data, 6307 DIGEST_BYTE_LENGTH_KASUMI_F9, 6308 "ZUC Generated auth tag not as expected"); 6309 } 6310 return 0; 6311 } 6312 6313 static int 6314 test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata, 6315 uint8_t op_mode, uint8_t verify) 6316 { 6317 struct crypto_testsuite_params *ts_params = &testsuite_params; 6318 struct crypto_unittest_params *ut_params = &unittest_params; 6319 6320 int retval; 6321 6322 const uint8_t *plaintext = NULL; 6323 const uint8_t *ciphertext = NULL; 6324 const uint8_t *digest = NULL; 6325 unsigned int plaintext_pad_len; 6326 unsigned int plaintext_len; 6327 unsigned int ciphertext_pad_len; 6328 unsigned int ciphertext_len; 6329 uint8_t buffer[10000]; 6330 uint8_t digest_buffer[10000]; 6331 6332 struct rte_cryptodev_info dev_info; 6333 struct rte_cryptodev_sym_capability_idx cap_idx; 6334 6335 /* Check if device supports ZUC EIA3 */ 6336 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; 6337 cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3; 6338 6339 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 6340 &cap_idx) == NULL) 6341 return TEST_SKIPPED; 6342 6343 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 6344 6345 uint64_t feat_flags = dev_info.feature_flags; 6346 6347 if (op_mode == IN_PLACE) { 6348 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) { 6349 printf("Device doesn't support in-place scatter-gather " 6350 "in both input and output mbufs.\n"); 6351 return TEST_SKIPPED; 6352 } 6353 6354 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 6355 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 6356 printf("Device doesn't support RAW data-path APIs.\n"); 6357 return TEST_SKIPPED; 6358 } 6359 } else { 6360 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 6361 return TEST_SKIPPED; 6362 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) { 6363 printf("Device doesn't support out-of-place scatter-gather " 6364 "in both input and output mbufs.\n"); 6365 return TEST_SKIPPED; 6366 } 6367 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) { 6368 printf("Device doesn't support digest encrypted.\n"); 6369 return TEST_SKIPPED; 6370 } 6371 } 6372 6373 /* Create ZUC session */ 6374 retval = create_wireless_algo_auth_cipher_session( 6375 ts_params->valid_devs[0], 6376 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT 6377 : RTE_CRYPTO_CIPHER_OP_ENCRYPT), 6378 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY 6379 : RTE_CRYPTO_AUTH_OP_GENERATE), 6380 RTE_CRYPTO_AUTH_ZUC_EIA3, 6381 RTE_CRYPTO_CIPHER_ZUC_EEA3, 6382 tdata->key.data, tdata->key.len, 6383 tdata->auth_iv.len, tdata->digest.len, 6384 tdata->cipher_iv.len); 6385 6386 if (retval != 0) 6387 return retval; 6388 6389 ciphertext_len = ceil_byte_length(tdata->ciphertext.len); 6390 plaintext_len = ceil_byte_length(tdata->plaintext.len); 6391 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16); 6392 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); 6393 6394 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool, 6395 plaintext_pad_len, 15, 0); 6396 TEST_ASSERT_NOT_NULL(ut_params->ibuf, 6397 "Failed to allocate input buffer in mempool"); 6398 6399 if (op_mode == OUT_OF_PLACE) { 6400 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool, 6401 plaintext_pad_len, 15, 0); 6402 TEST_ASSERT_NOT_NULL(ut_params->obuf, 6403 "Failed to allocate output buffer in mempool"); 6404 } 6405 6406 if (verify) { 6407 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len, 6408 tdata->ciphertext.data); 6409 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0, 6410 ciphertext_len, buffer); 6411 debug_hexdump(stdout, "ciphertext:", ciphertext, 6412 ciphertext_len); 6413 } else { 6414 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, 6415 tdata->plaintext.data); 6416 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0, 6417 plaintext_len, buffer); 6418 debug_hexdump(stdout, "plaintext:", plaintext, 6419 plaintext_len); 6420 } 6421 memset(buffer, 0, sizeof(buffer)); 6422 6423 /* Create ZUC operation */ 6424 retval = create_wireless_algo_auth_cipher_operation( 6425 tdata->digest.data, tdata->digest.len, 6426 tdata->cipher_iv.data, tdata->cipher_iv.len, 6427 NULL, 0, 6428 (tdata->digest.offset_bytes == 0 ? 6429 (verify ? ciphertext_pad_len : plaintext_pad_len) 6430 : tdata->digest.offset_bytes), 6431 tdata->validCipherLenInBits.len, 6432 tdata->validCipherOffsetInBits.len, 6433 tdata->validAuthLenInBits.len, 6434 0, 6435 op_mode, 1, verify); 6436 6437 if (retval < 0) 6438 return retval; 6439 6440 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 6441 process_sym_raw_dp_op(ts_params->valid_devs[0], 0, 6442 ut_params->op, 1, 1, 1, tdata->cipher_iv.len); 6443 else 6444 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 6445 ut_params->op); 6446 6447 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 6448 6449 ut_params->obuf = (op_mode == IN_PLACE ? 6450 ut_params->op->sym->m_src : ut_params->op->sym->m_dst); 6451 6452 if (verify) { 6453 if (ut_params->obuf) 6454 plaintext = rte_pktmbuf_read(ut_params->obuf, 0, 6455 plaintext_len, buffer); 6456 else 6457 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0, 6458 plaintext_len, buffer); 6459 6460 debug_hexdump(stdout, "plaintext:", plaintext, 6461 (tdata->plaintext.len >> 3) - tdata->digest.len); 6462 debug_hexdump(stdout, "plaintext expected:", 6463 tdata->plaintext.data, 6464 (tdata->plaintext.len >> 3) - tdata->digest.len); 6465 } else { 6466 if (ut_params->obuf) 6467 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0, 6468 ciphertext_len, buffer); 6469 else 6470 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0, 6471 ciphertext_len, buffer); 6472 6473 debug_hexdump(stdout, "ciphertext:", ciphertext, 6474 ciphertext_len); 6475 debug_hexdump(stdout, "ciphertext expected:", 6476 tdata->ciphertext.data, tdata->ciphertext.len >> 3); 6477 6478 if (ut_params->obuf) 6479 digest = rte_pktmbuf_read(ut_params->obuf, 6480 (tdata->digest.offset_bytes == 0 ? 6481 plaintext_pad_len : tdata->digest.offset_bytes), 6482 tdata->digest.len, digest_buffer); 6483 else 6484 digest = rte_pktmbuf_read(ut_params->ibuf, 6485 (tdata->digest.offset_bytes == 0 ? 6486 plaintext_pad_len : tdata->digest.offset_bytes), 6487 tdata->digest.len, digest_buffer); 6488 6489 debug_hexdump(stdout, "digest:", digest, 6490 tdata->digest.len); 6491 debug_hexdump(stdout, "digest expected:", 6492 tdata->digest.data, tdata->digest.len); 6493 } 6494 6495 /* Validate obuf */ 6496 if (verify) { 6497 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 6498 plaintext, 6499 tdata->plaintext.data, 6500 tdata->plaintext.len >> 3, 6501 "ZUC Plaintext data not as expected"); 6502 } else { 6503 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 6504 ciphertext, 6505 tdata->ciphertext.data, 6506 tdata->validDataLenInBits.len, 6507 "ZUC Ciphertext data not as expected"); 6508 6509 TEST_ASSERT_BUFFERS_ARE_EQUAL( 6510 digest, 6511 tdata->digest.data, 6512 DIGEST_BYTE_LENGTH_KASUMI_F9, 6513 "ZUC Generated auth tag not as expected"); 6514 } 6515 return 0; 6516 } 6517 6518 static int 6519 test_kasumi_encryption_test_case_1(void) 6520 { 6521 return test_kasumi_encryption(&kasumi_test_case_1); 6522 } 6523 6524 static int 6525 test_kasumi_encryption_test_case_1_sgl(void) 6526 { 6527 return test_kasumi_encryption_sgl(&kasumi_test_case_1); 6528 } 6529 6530 static int 6531 test_kasumi_encryption_test_case_1_oop(void) 6532 { 6533 return test_kasumi_encryption_oop(&kasumi_test_case_1); 6534 } 6535 6536 static int 6537 test_kasumi_encryption_test_case_1_oop_sgl(void) 6538 { 6539 return test_kasumi_encryption_oop_sgl(&kasumi_test_case_1); 6540 } 6541 6542 static int 6543 test_kasumi_encryption_test_case_2(void) 6544 { 6545 return test_kasumi_encryption(&kasumi_test_case_2); 6546 } 6547 6548 static int 6549 test_kasumi_encryption_test_case_3(void) 6550 { 6551 return test_kasumi_encryption(&kasumi_test_case_3); 6552 } 6553 6554 static int 6555 test_kasumi_encryption_test_case_4(void) 6556 { 6557 return test_kasumi_encryption(&kasumi_test_case_4); 6558 } 6559 6560 static int 6561 test_kasumi_encryption_test_case_5(void) 6562 { 6563 return test_kasumi_encryption(&kasumi_test_case_5); 6564 } 6565 6566 static int 6567 test_kasumi_decryption_test_case_1(void) 6568 { 6569 return test_kasumi_decryption(&kasumi_test_case_1); 6570 } 6571 6572 static int 6573 test_kasumi_decryption_test_case_1_oop(void) 6574 { 6575 return test_kasumi_decryption_oop(&kasumi_test_case_1); 6576 } 6577 6578 static int 6579 test_kasumi_decryption_test_case_2(void) 6580 { 6581 return test_kasumi_decryption(&kasumi_test_case_2); 6582 } 6583 6584 static int 6585 test_kasumi_decryption_test_case_3(void) 6586 { 6587 /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */ 6588 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 6589 return TEST_SKIPPED; 6590 return test_kasumi_decryption(&kasumi_test_case_3); 6591 } 6592 6593 static int 6594 test_kasumi_decryption_test_case_4(void) 6595 { 6596 return test_kasumi_decryption(&kasumi_test_case_4); 6597 } 6598 6599 static int 6600 test_kasumi_decryption_test_case_5(void) 6601 { 6602 return test_kasumi_decryption(&kasumi_test_case_5); 6603 } 6604 static int 6605 test_snow3g_encryption_test_case_1(void) 6606 { 6607 return test_snow3g_encryption(&snow3g_test_case_1); 6608 } 6609 6610 static int 6611 test_snow3g_encryption_test_case_1_oop(void) 6612 { 6613 return test_snow3g_encryption_oop(&snow3g_test_case_1); 6614 } 6615 6616 static int 6617 test_snow3g_encryption_test_case_1_oop_sgl(void) 6618 { 6619 return test_snow3g_encryption_oop_sgl(&snow3g_test_case_1); 6620 } 6621 6622 6623 static int 6624 test_snow3g_encryption_test_case_1_offset_oop(void) 6625 { 6626 return test_snow3g_encryption_offset_oop(&snow3g_test_case_1); 6627 } 6628 6629 static int 6630 test_snow3g_encryption_test_case_2(void) 6631 { 6632 return test_snow3g_encryption(&snow3g_test_case_2); 6633 } 6634 6635 static int 6636 test_snow3g_encryption_test_case_3(void) 6637 { 6638 return test_snow3g_encryption(&snow3g_test_case_3); 6639 } 6640 6641 static int 6642 test_snow3g_encryption_test_case_4(void) 6643 { 6644 return test_snow3g_encryption(&snow3g_test_case_4); 6645 } 6646 6647 static int 6648 test_snow3g_encryption_test_case_5(void) 6649 { 6650 return test_snow3g_encryption(&snow3g_test_case_5); 6651 } 6652 6653 static int 6654 test_snow3g_decryption_test_case_1(void) 6655 { 6656 return test_snow3g_decryption(&snow3g_test_case_1); 6657 } 6658 6659 static int 6660 test_snow3g_decryption_test_case_1_oop(void) 6661 { 6662 return test_snow3g_decryption_oop(&snow3g_test_case_1); 6663 } 6664 6665 static int 6666 test_snow3g_decryption_test_case_2(void) 6667 { 6668 return test_snow3g_decryption(&snow3g_test_case_2); 6669 } 6670 6671 static int 6672 test_snow3g_decryption_test_case_3(void) 6673 { 6674 return test_snow3g_decryption(&snow3g_test_case_3); 6675 } 6676 6677 static int 6678 test_snow3g_decryption_test_case_4(void) 6679 { 6680 return test_snow3g_decryption(&snow3g_test_case_4); 6681 } 6682 6683 static int 6684 test_snow3g_decryption_test_case_5(void) 6685 { 6686 return test_snow3g_decryption(&snow3g_test_case_5); 6687 } 6688 6689 /* 6690 * Function prepares snow3g_hash_test_data from snow3g_test_data. 6691 * Pattern digest from snow3g_test_data must be allocated as 6692 * 4 last bytes in plaintext. 6693 */ 6694 static void 6695 snow3g_hash_test_vector_setup(const struct snow3g_test_data *pattern, 6696 struct snow3g_hash_test_data *output) 6697 { 6698 if ((pattern != NULL) && (output != NULL)) { 6699 output->key.len = pattern->key.len; 6700 6701 memcpy(output->key.data, 6702 pattern->key.data, pattern->key.len); 6703 6704 output->auth_iv.len = pattern->auth_iv.len; 6705 6706 memcpy(output->auth_iv.data, 6707 pattern->auth_iv.data, pattern->auth_iv.len); 6708 6709 output->plaintext.len = pattern->plaintext.len; 6710 6711 memcpy(output->plaintext.data, 6712 pattern->plaintext.data, pattern->plaintext.len >> 3); 6713 6714 output->digest.len = pattern->digest.len; 6715 6716 memcpy(output->digest.data, 6717 &pattern->plaintext.data[pattern->digest.offset_bytes], 6718 pattern->digest.len); 6719 6720 output->validAuthLenInBits.len = 6721 pattern->validAuthLenInBits.len; 6722 } 6723 } 6724 6725 /* 6726 * Test case verify computed cipher and digest from snow3g_test_case_7 data. 6727 */ 6728 static int 6729 test_snow3g_decryption_with_digest_test_case_1(void) 6730 { 6731 struct snow3g_hash_test_data snow3g_hash_data; 6732 struct rte_cryptodev_info dev_info; 6733 struct crypto_testsuite_params *ts_params = &testsuite_params; 6734 6735 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 6736 uint64_t feat_flags = dev_info.feature_flags; 6737 6738 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) { 6739 printf("Device doesn't support encrypted digest operations.\n"); 6740 return TEST_SKIPPED; 6741 } 6742 6743 /* 6744 * Function prepare data for hash veryfication test case. 6745 * Digest is allocated in 4 last bytes in plaintext, pattern. 6746 */ 6747 snow3g_hash_test_vector_setup(&snow3g_test_case_7, &snow3g_hash_data); 6748 6749 return test_snow3g_decryption(&snow3g_test_case_7) & 6750 test_snow3g_authentication_verify(&snow3g_hash_data); 6751 } 6752 6753 static int 6754 test_snow3g_cipher_auth_test_case_1(void) 6755 { 6756 return test_snow3g_cipher_auth(&snow3g_test_case_3); 6757 } 6758 6759 static int 6760 test_snow3g_auth_cipher_test_case_1(void) 6761 { 6762 return test_snow3g_auth_cipher( 6763 &snow3g_auth_cipher_test_case_1, IN_PLACE, 0); 6764 } 6765 6766 static int 6767 test_snow3g_auth_cipher_test_case_2(void) 6768 { 6769 return test_snow3g_auth_cipher( 6770 &snow3g_auth_cipher_test_case_2, IN_PLACE, 0); 6771 } 6772 6773 static int 6774 test_snow3g_auth_cipher_test_case_2_oop(void) 6775 { 6776 return test_snow3g_auth_cipher( 6777 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 0); 6778 } 6779 6780 static int 6781 test_snow3g_auth_cipher_part_digest_enc(void) 6782 { 6783 return test_snow3g_auth_cipher( 6784 &snow3g_auth_cipher_partial_digest_encryption, 6785 IN_PLACE, 0); 6786 } 6787 6788 static int 6789 test_snow3g_auth_cipher_part_digest_enc_oop(void) 6790 { 6791 return test_snow3g_auth_cipher( 6792 &snow3g_auth_cipher_partial_digest_encryption, 6793 OUT_OF_PLACE, 0); 6794 } 6795 6796 static int 6797 test_snow3g_auth_cipher_test_case_3_sgl(void) 6798 { 6799 /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */ 6800 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 6801 return TEST_SKIPPED; 6802 return test_snow3g_auth_cipher_sgl( 6803 &snow3g_auth_cipher_test_case_3, IN_PLACE, 0); 6804 } 6805 6806 static int 6807 test_snow3g_auth_cipher_test_case_3_oop_sgl(void) 6808 { 6809 return test_snow3g_auth_cipher_sgl( 6810 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 0); 6811 } 6812 6813 static int 6814 test_snow3g_auth_cipher_part_digest_enc_sgl(void) 6815 { 6816 /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */ 6817 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 6818 return TEST_SKIPPED; 6819 return test_snow3g_auth_cipher_sgl( 6820 &snow3g_auth_cipher_partial_digest_encryption, 6821 IN_PLACE, 0); 6822 } 6823 6824 static int 6825 test_snow3g_auth_cipher_part_digest_enc_oop_sgl(void) 6826 { 6827 return test_snow3g_auth_cipher_sgl( 6828 &snow3g_auth_cipher_partial_digest_encryption, 6829 OUT_OF_PLACE, 0); 6830 } 6831 6832 static int 6833 test_snow3g_auth_cipher_verify_test_case_1(void) 6834 { 6835 return test_snow3g_auth_cipher( 6836 &snow3g_auth_cipher_test_case_1, IN_PLACE, 1); 6837 } 6838 6839 static int 6840 test_snow3g_auth_cipher_verify_test_case_2(void) 6841 { 6842 return test_snow3g_auth_cipher( 6843 &snow3g_auth_cipher_test_case_2, IN_PLACE, 1); 6844 } 6845 6846 static int 6847 test_snow3g_auth_cipher_verify_test_case_2_oop(void) 6848 { 6849 return test_snow3g_auth_cipher( 6850 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 1); 6851 } 6852 6853 static int 6854 test_snow3g_auth_cipher_verify_part_digest_enc(void) 6855 { 6856 return test_snow3g_auth_cipher( 6857 &snow3g_auth_cipher_partial_digest_encryption, 6858 IN_PLACE, 1); 6859 } 6860 6861 static int 6862 test_snow3g_auth_cipher_verify_part_digest_enc_oop(void) 6863 { 6864 return test_snow3g_auth_cipher( 6865 &snow3g_auth_cipher_partial_digest_encryption, 6866 OUT_OF_PLACE, 1); 6867 } 6868 6869 static int 6870 test_snow3g_auth_cipher_verify_test_case_3_sgl(void) 6871 { 6872 return test_snow3g_auth_cipher_sgl( 6873 &snow3g_auth_cipher_test_case_3, IN_PLACE, 1); 6874 } 6875 6876 static int 6877 test_snow3g_auth_cipher_verify_test_case_3_oop_sgl(void) 6878 { 6879 return test_snow3g_auth_cipher_sgl( 6880 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 1); 6881 } 6882 6883 static int 6884 test_snow3g_auth_cipher_verify_part_digest_enc_sgl(void) 6885 { 6886 return test_snow3g_auth_cipher_sgl( 6887 &snow3g_auth_cipher_partial_digest_encryption, 6888 IN_PLACE, 1); 6889 } 6890 6891 static int 6892 test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl(void) 6893 { 6894 return test_snow3g_auth_cipher_sgl( 6895 &snow3g_auth_cipher_partial_digest_encryption, 6896 OUT_OF_PLACE, 1); 6897 } 6898 6899 static int 6900 test_snow3g_auth_cipher_with_digest_test_case_1(void) 6901 { 6902 return test_snow3g_auth_cipher( 6903 &snow3g_test_case_7, IN_PLACE, 0); 6904 } 6905 6906 static int 6907 test_kasumi_auth_cipher_test_case_1(void) 6908 { 6909 return test_kasumi_auth_cipher( 6910 &kasumi_test_case_3, IN_PLACE, 0); 6911 } 6912 6913 static int 6914 test_kasumi_auth_cipher_test_case_2(void) 6915 { 6916 return test_kasumi_auth_cipher( 6917 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0); 6918 } 6919 6920 static int 6921 test_kasumi_auth_cipher_test_case_2_oop(void) 6922 { 6923 return test_kasumi_auth_cipher( 6924 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0); 6925 } 6926 6927 static int 6928 test_kasumi_auth_cipher_test_case_2_sgl(void) 6929 { 6930 return test_kasumi_auth_cipher_sgl( 6931 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0); 6932 } 6933 6934 static int 6935 test_kasumi_auth_cipher_test_case_2_oop_sgl(void) 6936 { 6937 return test_kasumi_auth_cipher_sgl( 6938 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0); 6939 } 6940 6941 static int 6942 test_kasumi_auth_cipher_verify_test_case_1(void) 6943 { 6944 return test_kasumi_auth_cipher( 6945 &kasumi_test_case_3, IN_PLACE, 1); 6946 } 6947 6948 static int 6949 test_kasumi_auth_cipher_verify_test_case_2(void) 6950 { 6951 return test_kasumi_auth_cipher( 6952 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1); 6953 } 6954 6955 static int 6956 test_kasumi_auth_cipher_verify_test_case_2_oop(void) 6957 { 6958 return test_kasumi_auth_cipher( 6959 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1); 6960 } 6961 6962 static int 6963 test_kasumi_auth_cipher_verify_test_case_2_sgl(void) 6964 { 6965 return test_kasumi_auth_cipher_sgl( 6966 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1); 6967 } 6968 6969 static int 6970 test_kasumi_auth_cipher_verify_test_case_2_oop_sgl(void) 6971 { 6972 return test_kasumi_auth_cipher_sgl( 6973 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1); 6974 } 6975 6976 static int 6977 test_kasumi_cipher_auth_test_case_1(void) 6978 { 6979 return test_kasumi_cipher_auth(&kasumi_test_case_6); 6980 } 6981 6982 static int 6983 test_zuc_encryption_test_case_1(void) 6984 { 6985 return test_zuc_encryption(&zuc_test_case_cipher_193b); 6986 } 6987 6988 static int 6989 test_zuc_encryption_test_case_2(void) 6990 { 6991 return test_zuc_encryption(&zuc_test_case_cipher_800b); 6992 } 6993 6994 static int 6995 test_zuc_encryption_test_case_3(void) 6996 { 6997 return test_zuc_encryption(&zuc_test_case_cipher_1570b); 6998 } 6999 7000 static int 7001 test_zuc_encryption_test_case_4(void) 7002 { 7003 return test_zuc_encryption(&zuc_test_case_cipher_2798b); 7004 } 7005 7006 static int 7007 test_zuc_encryption_test_case_5(void) 7008 { 7009 return test_zuc_encryption(&zuc_test_case_cipher_4019b); 7010 } 7011 7012 static int 7013 test_zuc_encryption_test_case_6_sgl(void) 7014 { 7015 return test_zuc_encryption_sgl(&zuc_test_case_cipher_193b); 7016 } 7017 7018 static int 7019 test_zuc_encryption_test_case_7(void) 7020 { 7021 return test_zuc_encryption(&zuc_test_case_cipher_800b_key_256b); 7022 } 7023 7024 static int 7025 test_zuc_hash_generate_test_case_1(void) 7026 { 7027 return test_zuc_authentication(&zuc_test_case_auth_1b); 7028 } 7029 7030 static int 7031 test_zuc_hash_generate_test_case_2(void) 7032 { 7033 return test_zuc_authentication(&zuc_test_case_auth_90b); 7034 } 7035 7036 static int 7037 test_zuc_hash_generate_test_case_3(void) 7038 { 7039 return test_zuc_authentication(&zuc_test_case_auth_577b); 7040 } 7041 7042 static int 7043 test_zuc_hash_generate_test_case_4(void) 7044 { 7045 return test_zuc_authentication(&zuc_test_case_auth_2079b); 7046 } 7047 7048 static int 7049 test_zuc_hash_generate_test_case_5(void) 7050 { 7051 return test_zuc_authentication(&zuc_test_auth_5670b); 7052 } 7053 7054 static int 7055 test_zuc_hash_generate_test_case_6(void) 7056 { 7057 return test_zuc_authentication(&zuc_test_case_auth_128b); 7058 } 7059 7060 static int 7061 test_zuc_hash_generate_test_case_7(void) 7062 { 7063 return test_zuc_authentication(&zuc_test_case_auth_2080b); 7064 } 7065 7066 static int 7067 test_zuc_hash_generate_test_case_8(void) 7068 { 7069 return test_zuc_authentication(&zuc_test_case_auth_584b); 7070 } 7071 7072 static int 7073 test_zuc_hash_generate_test_case_9(void) 7074 { 7075 return test_zuc_authentication(&zuc_test_case_auth_584b_mac_64b); 7076 } 7077 7078 static int 7079 test_zuc_hash_generate_test_case_10(void) 7080 { 7081 return test_zuc_authentication(&zuc_test_case_auth_2080b_mac_128b); 7082 } 7083 7084 static int 7085 test_zuc_cipher_auth_test_case_1(void) 7086 { 7087 return test_zuc_cipher_auth(&zuc_test_case_cipher_200b_auth_200b); 7088 } 7089 7090 static int 7091 test_zuc_cipher_auth_test_case_2(void) 7092 { 7093 return test_zuc_cipher_auth(&zuc_test_case_cipher_800b_auth_120b); 7094 } 7095 7096 static int 7097 test_zuc_auth_cipher_test_case_1(void) 7098 { 7099 return test_zuc_auth_cipher( 7100 &zuc_auth_cipher_test_case_1, IN_PLACE, 0); 7101 } 7102 7103 static int 7104 test_zuc_auth_cipher_test_case_1_oop(void) 7105 { 7106 return test_zuc_auth_cipher( 7107 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0); 7108 } 7109 7110 static int 7111 test_zuc_auth_cipher_test_case_1_sgl(void) 7112 { 7113 return test_zuc_auth_cipher_sgl( 7114 &zuc_auth_cipher_test_case_1, IN_PLACE, 0); 7115 } 7116 7117 static int 7118 test_zuc_auth_cipher_test_case_1_oop_sgl(void) 7119 { 7120 return test_zuc_auth_cipher_sgl( 7121 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0); 7122 } 7123 7124 static int 7125 test_zuc_auth_cipher_verify_test_case_1(void) 7126 { 7127 return test_zuc_auth_cipher( 7128 &zuc_auth_cipher_test_case_1, IN_PLACE, 1); 7129 } 7130 7131 static int 7132 test_zuc_auth_cipher_verify_test_case_1_oop(void) 7133 { 7134 return test_zuc_auth_cipher( 7135 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1); 7136 } 7137 7138 static int 7139 test_zuc_auth_cipher_verify_test_case_1_sgl(void) 7140 { 7141 return test_zuc_auth_cipher_sgl( 7142 &zuc_auth_cipher_test_case_1, IN_PLACE, 1); 7143 } 7144 7145 static int 7146 test_zuc_auth_cipher_verify_test_case_1_oop_sgl(void) 7147 { 7148 return test_zuc_auth_cipher_sgl( 7149 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1); 7150 } 7151 7152 static int 7153 test_mixed_check_if_unsupported(const struct mixed_cipher_auth_test_data *tdata) 7154 { 7155 uint8_t dev_id = testsuite_params.valid_devs[0]; 7156 7157 struct rte_cryptodev_sym_capability_idx cap_idx; 7158 7159 /* Check if device supports particular cipher algorithm */ 7160 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 7161 cap_idx.algo.cipher = tdata->cipher_algo; 7162 if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL) 7163 return TEST_SKIPPED; 7164 7165 /* Check if device supports particular hash algorithm */ 7166 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; 7167 cap_idx.algo.auth = tdata->auth_algo; 7168 if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL) 7169 return TEST_SKIPPED; 7170 7171 return 0; 7172 } 7173 7174 static int 7175 test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata, 7176 uint8_t op_mode, uint8_t verify) 7177 { 7178 struct crypto_testsuite_params *ts_params = &testsuite_params; 7179 struct crypto_unittest_params *ut_params = &unittest_params; 7180 7181 int retval; 7182 7183 uint8_t *plaintext = NULL, *ciphertext = NULL; 7184 unsigned int plaintext_pad_len; 7185 unsigned int plaintext_len; 7186 unsigned int ciphertext_pad_len; 7187 unsigned int ciphertext_len; 7188 7189 struct rte_cryptodev_info dev_info; 7190 struct rte_crypto_op *op; 7191 7192 /* Check if device supports particular algorithms separately */ 7193 if (test_mixed_check_if_unsupported(tdata)) 7194 return TEST_SKIPPED; 7195 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 7196 return TEST_SKIPPED; 7197 7198 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 7199 7200 uint64_t feat_flags = dev_info.feature_flags; 7201 7202 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) { 7203 printf("Device doesn't support digest encrypted.\n"); 7204 return TEST_SKIPPED; 7205 } 7206 7207 /* Create the session */ 7208 if (verify) 7209 retval = create_wireless_algo_cipher_auth_session( 7210 ts_params->valid_devs[0], 7211 RTE_CRYPTO_CIPHER_OP_DECRYPT, 7212 RTE_CRYPTO_AUTH_OP_VERIFY, 7213 tdata->auth_algo, 7214 tdata->cipher_algo, 7215 tdata->auth_key.data, tdata->auth_key.len, 7216 tdata->auth_iv.len, tdata->digest_enc.len, 7217 tdata->cipher_iv.len); 7218 else 7219 retval = create_wireless_algo_auth_cipher_session( 7220 ts_params->valid_devs[0], 7221 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 7222 RTE_CRYPTO_AUTH_OP_GENERATE, 7223 tdata->auth_algo, 7224 tdata->cipher_algo, 7225 tdata->auth_key.data, tdata->auth_key.len, 7226 tdata->auth_iv.len, tdata->digest_enc.len, 7227 tdata->cipher_iv.len); 7228 if (retval != 0) 7229 return retval; 7230 7231 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 7232 if (op_mode == OUT_OF_PLACE) 7233 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 7234 7235 /* clear mbuf payload */ 7236 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 7237 rte_pktmbuf_tailroom(ut_params->ibuf)); 7238 if (op_mode == OUT_OF_PLACE) { 7239 7240 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0, 7241 rte_pktmbuf_tailroom(ut_params->obuf)); 7242 } 7243 7244 ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits); 7245 plaintext_len = ceil_byte_length(tdata->plaintext.len_bits); 7246 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16); 7247 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); 7248 7249 if (verify) { 7250 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 7251 ciphertext_pad_len); 7252 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len); 7253 if (op_mode == OUT_OF_PLACE) 7254 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len); 7255 debug_hexdump(stdout, "ciphertext:", ciphertext, 7256 ciphertext_len); 7257 } else { 7258 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 7259 plaintext_pad_len); 7260 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 7261 if (op_mode == OUT_OF_PLACE) 7262 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len); 7263 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len); 7264 } 7265 7266 /* Create the operation */ 7267 retval = create_wireless_algo_auth_cipher_operation( 7268 tdata->digest_enc.data, tdata->digest_enc.len, 7269 tdata->cipher_iv.data, tdata->cipher_iv.len, 7270 tdata->auth_iv.data, tdata->auth_iv.len, 7271 (tdata->digest_enc.offset == 0 ? 7272 plaintext_pad_len 7273 : tdata->digest_enc.offset), 7274 tdata->validCipherLen.len_bits, 7275 tdata->cipher.offset_bits, 7276 tdata->validAuthLen.len_bits, 7277 tdata->auth.offset_bits, 7278 op_mode, 0, verify); 7279 7280 if (retval < 0) 7281 return retval; 7282 7283 op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); 7284 7285 /* Check if the op failed because the device doesn't */ 7286 /* support this particular combination of algorithms */ 7287 if (op == NULL && ut_params->op->status == 7288 RTE_CRYPTO_OP_STATUS_INVALID_SESSION) { 7289 printf("Device doesn't support this mixed combination. " 7290 "Test Skipped.\n"); 7291 return TEST_SKIPPED; 7292 } 7293 ut_params->op = op; 7294 7295 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 7296 7297 ut_params->obuf = (op_mode == IN_PLACE ? 7298 ut_params->op->sym->m_src : ut_params->op->sym->m_dst); 7299 7300 if (verify) { 7301 if (ut_params->obuf) 7302 plaintext = rte_pktmbuf_mtod(ut_params->obuf, 7303 uint8_t *); 7304 else 7305 plaintext = ciphertext + 7306 (tdata->cipher.offset_bits >> 3); 7307 7308 debug_hexdump(stdout, "plaintext:", plaintext, 7309 tdata->plaintext.len_bits >> 3); 7310 debug_hexdump(stdout, "plaintext expected:", 7311 tdata->plaintext.data, 7312 tdata->plaintext.len_bits >> 3); 7313 } else { 7314 if (ut_params->obuf) 7315 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, 7316 uint8_t *); 7317 else 7318 ciphertext = plaintext; 7319 7320 debug_hexdump(stdout, "ciphertext:", ciphertext, 7321 ciphertext_len); 7322 debug_hexdump(stdout, "ciphertext expected:", 7323 tdata->ciphertext.data, 7324 tdata->ciphertext.len_bits >> 3); 7325 7326 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *) 7327 + (tdata->digest_enc.offset == 0 ? 7328 plaintext_pad_len : tdata->digest_enc.offset); 7329 7330 debug_hexdump(stdout, "digest:", ut_params->digest, 7331 tdata->digest_enc.len); 7332 debug_hexdump(stdout, "digest expected:", 7333 tdata->digest_enc.data, 7334 tdata->digest_enc.len); 7335 } 7336 7337 /* Validate obuf */ 7338 if (verify) { 7339 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 7340 plaintext, 7341 tdata->plaintext.data, 7342 tdata->plaintext.len_bits >> 3, 7343 "Plaintext data not as expected"); 7344 } else { 7345 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 7346 ciphertext, 7347 tdata->ciphertext.data, 7348 tdata->validDataLen.len_bits, 7349 "Ciphertext data not as expected"); 7350 7351 TEST_ASSERT_BUFFERS_ARE_EQUAL( 7352 ut_params->digest, 7353 tdata->digest_enc.data, 7354 DIGEST_BYTE_LENGTH_SNOW3G_UIA2, 7355 "Generated auth tag not as expected"); 7356 } 7357 7358 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 7359 "crypto op processing failed"); 7360 7361 return 0; 7362 } 7363 7364 static int 7365 test_mixed_auth_cipher_sgl(const struct mixed_cipher_auth_test_data *tdata, 7366 uint8_t op_mode, uint8_t verify) 7367 { 7368 struct crypto_testsuite_params *ts_params = &testsuite_params; 7369 struct crypto_unittest_params *ut_params = &unittest_params; 7370 7371 int retval; 7372 7373 const uint8_t *plaintext = NULL; 7374 const uint8_t *ciphertext = NULL; 7375 const uint8_t *digest = NULL; 7376 unsigned int plaintext_pad_len; 7377 unsigned int plaintext_len; 7378 unsigned int ciphertext_pad_len; 7379 unsigned int ciphertext_len; 7380 uint8_t buffer[10000]; 7381 uint8_t digest_buffer[10000]; 7382 7383 struct rte_cryptodev_info dev_info; 7384 struct rte_crypto_op *op; 7385 7386 /* Check if device supports particular algorithms */ 7387 if (test_mixed_check_if_unsupported(tdata)) 7388 return TEST_SKIPPED; 7389 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 7390 return TEST_SKIPPED; 7391 7392 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 7393 7394 uint64_t feat_flags = dev_info.feature_flags; 7395 7396 if (op_mode == IN_PLACE) { 7397 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) { 7398 printf("Device doesn't support in-place scatter-gather " 7399 "in both input and output mbufs.\n"); 7400 return TEST_SKIPPED; 7401 } 7402 } else { 7403 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) { 7404 printf("Device doesn't support out-of-place scatter-gather " 7405 "in both input and output mbufs.\n"); 7406 return TEST_SKIPPED; 7407 } 7408 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) { 7409 printf("Device doesn't support digest encrypted.\n"); 7410 return TEST_SKIPPED; 7411 } 7412 } 7413 7414 /* Create the session */ 7415 if (verify) 7416 retval = create_wireless_algo_cipher_auth_session( 7417 ts_params->valid_devs[0], 7418 RTE_CRYPTO_CIPHER_OP_DECRYPT, 7419 RTE_CRYPTO_AUTH_OP_VERIFY, 7420 tdata->auth_algo, 7421 tdata->cipher_algo, 7422 tdata->auth_key.data, tdata->auth_key.len, 7423 tdata->auth_iv.len, tdata->digest_enc.len, 7424 tdata->cipher_iv.len); 7425 else 7426 retval = create_wireless_algo_auth_cipher_session( 7427 ts_params->valid_devs[0], 7428 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 7429 RTE_CRYPTO_AUTH_OP_GENERATE, 7430 tdata->auth_algo, 7431 tdata->cipher_algo, 7432 tdata->auth_key.data, tdata->auth_key.len, 7433 tdata->auth_iv.len, tdata->digest_enc.len, 7434 tdata->cipher_iv.len); 7435 if (retval != 0) 7436 return retval; 7437 7438 ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits); 7439 plaintext_len = ceil_byte_length(tdata->plaintext.len_bits); 7440 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16); 7441 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16); 7442 7443 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool, 7444 ciphertext_pad_len, 15, 0); 7445 TEST_ASSERT_NOT_NULL(ut_params->ibuf, 7446 "Failed to allocate input buffer in mempool"); 7447 7448 if (op_mode == OUT_OF_PLACE) { 7449 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool, 7450 plaintext_pad_len, 15, 0); 7451 TEST_ASSERT_NOT_NULL(ut_params->obuf, 7452 "Failed to allocate output buffer in mempool"); 7453 } 7454 7455 if (verify) { 7456 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len, 7457 tdata->ciphertext.data); 7458 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0, 7459 ciphertext_len, buffer); 7460 debug_hexdump(stdout, "ciphertext:", ciphertext, 7461 ciphertext_len); 7462 } else { 7463 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, 7464 tdata->plaintext.data); 7465 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0, 7466 plaintext_len, buffer); 7467 debug_hexdump(stdout, "plaintext:", plaintext, 7468 plaintext_len); 7469 } 7470 memset(buffer, 0, sizeof(buffer)); 7471 7472 /* Create the operation */ 7473 retval = create_wireless_algo_auth_cipher_operation( 7474 tdata->digest_enc.data, tdata->digest_enc.len, 7475 tdata->cipher_iv.data, tdata->cipher_iv.len, 7476 tdata->auth_iv.data, tdata->auth_iv.len, 7477 (tdata->digest_enc.offset == 0 ? 7478 plaintext_pad_len 7479 : tdata->digest_enc.offset), 7480 tdata->validCipherLen.len_bits, 7481 tdata->cipher.offset_bits, 7482 tdata->validAuthLen.len_bits, 7483 tdata->auth.offset_bits, 7484 op_mode, 1, verify); 7485 7486 if (retval < 0) 7487 return retval; 7488 7489 op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); 7490 7491 /* Check if the op failed because the device doesn't */ 7492 /* support this particular combination of algorithms */ 7493 if (op == NULL && ut_params->op->status == 7494 RTE_CRYPTO_OP_STATUS_INVALID_SESSION) { 7495 printf("Device doesn't support this mixed combination. " 7496 "Test Skipped.\n"); 7497 return TEST_SKIPPED; 7498 } 7499 ut_params->op = op; 7500 7501 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); 7502 7503 ut_params->obuf = (op_mode == IN_PLACE ? 7504 ut_params->op->sym->m_src : ut_params->op->sym->m_dst); 7505 7506 if (verify) { 7507 if (ut_params->obuf) 7508 plaintext = rte_pktmbuf_read(ut_params->obuf, 0, 7509 plaintext_len, buffer); 7510 else 7511 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0, 7512 plaintext_len, buffer); 7513 7514 debug_hexdump(stdout, "plaintext:", plaintext, 7515 (tdata->plaintext.len_bits >> 3) - 7516 tdata->digest_enc.len); 7517 debug_hexdump(stdout, "plaintext expected:", 7518 tdata->plaintext.data, 7519 (tdata->plaintext.len_bits >> 3) - 7520 tdata->digest_enc.len); 7521 } else { 7522 if (ut_params->obuf) 7523 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0, 7524 ciphertext_len, buffer); 7525 else 7526 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0, 7527 ciphertext_len, buffer); 7528 7529 debug_hexdump(stdout, "ciphertext:", ciphertext, 7530 ciphertext_len); 7531 debug_hexdump(stdout, "ciphertext expected:", 7532 tdata->ciphertext.data, 7533 tdata->ciphertext.len_bits >> 3); 7534 7535 if (ut_params->obuf) 7536 digest = rte_pktmbuf_read(ut_params->obuf, 7537 (tdata->digest_enc.offset == 0 ? 7538 plaintext_pad_len : 7539 tdata->digest_enc.offset), 7540 tdata->digest_enc.len, digest_buffer); 7541 else 7542 digest = rte_pktmbuf_read(ut_params->ibuf, 7543 (tdata->digest_enc.offset == 0 ? 7544 plaintext_pad_len : 7545 tdata->digest_enc.offset), 7546 tdata->digest_enc.len, digest_buffer); 7547 7548 debug_hexdump(stdout, "digest:", digest, 7549 tdata->digest_enc.len); 7550 debug_hexdump(stdout, "digest expected:", 7551 tdata->digest_enc.data, tdata->digest_enc.len); 7552 } 7553 7554 /* Validate obuf */ 7555 if (verify) { 7556 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 7557 plaintext, 7558 tdata->plaintext.data, 7559 tdata->plaintext.len_bits >> 3, 7560 "Plaintext data not as expected"); 7561 } else { 7562 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT( 7563 ciphertext, 7564 tdata->ciphertext.data, 7565 tdata->validDataLen.len_bits, 7566 "Ciphertext data not as expected"); 7567 TEST_ASSERT_BUFFERS_ARE_EQUAL( 7568 digest, 7569 tdata->digest_enc.data, 7570 tdata->digest_enc.len, 7571 "Generated auth tag not as expected"); 7572 } 7573 7574 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 7575 "crypto op processing failed"); 7576 7577 return 0; 7578 } 7579 7580 /** AUTH AES CMAC + CIPHER AES CTR */ 7581 7582 static int 7583 test_aes_cmac_aes_ctr_digest_enc_test_case_1(void) 7584 { 7585 return test_mixed_auth_cipher( 7586 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0); 7587 } 7588 7589 static int 7590 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void) 7591 { 7592 return test_mixed_auth_cipher( 7593 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0); 7594 } 7595 7596 static int 7597 test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void) 7598 { 7599 return test_mixed_auth_cipher_sgl( 7600 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0); 7601 } 7602 7603 static int 7604 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void) 7605 { 7606 return test_mixed_auth_cipher_sgl( 7607 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0); 7608 } 7609 7610 static int 7611 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1(void) 7612 { 7613 return test_mixed_auth_cipher( 7614 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1); 7615 } 7616 7617 static int 7618 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void) 7619 { 7620 return test_mixed_auth_cipher( 7621 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1); 7622 } 7623 7624 static int 7625 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void) 7626 { 7627 return test_mixed_auth_cipher_sgl( 7628 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1); 7629 } 7630 7631 static int 7632 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void) 7633 { 7634 return test_mixed_auth_cipher_sgl( 7635 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1); 7636 } 7637 7638 /** MIXED AUTH + CIPHER */ 7639 7640 static int 7641 test_auth_zuc_cipher_snow_test_case_1(void) 7642 { 7643 return test_mixed_auth_cipher( 7644 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 0); 7645 } 7646 7647 static int 7648 test_verify_auth_zuc_cipher_snow_test_case_1(void) 7649 { 7650 return test_mixed_auth_cipher( 7651 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 1); 7652 } 7653 7654 static int 7655 test_auth_aes_cmac_cipher_snow_test_case_1(void) 7656 { 7657 return test_mixed_auth_cipher( 7658 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 0); 7659 } 7660 7661 static int 7662 test_verify_auth_aes_cmac_cipher_snow_test_case_1(void) 7663 { 7664 return test_mixed_auth_cipher( 7665 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 1); 7666 } 7667 7668 static int 7669 test_auth_zuc_cipher_aes_ctr_test_case_1(void) 7670 { 7671 return test_mixed_auth_cipher( 7672 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0); 7673 } 7674 7675 static int 7676 test_verify_auth_zuc_cipher_aes_ctr_test_case_1(void) 7677 { 7678 return test_mixed_auth_cipher( 7679 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1); 7680 } 7681 7682 static int 7683 test_auth_snow_cipher_aes_ctr_test_case_1(void) 7684 { 7685 return test_mixed_auth_cipher( 7686 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0); 7687 } 7688 7689 static int 7690 test_verify_auth_snow_cipher_aes_ctr_test_case_1(void) 7691 { 7692 return test_mixed_auth_cipher( 7693 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1); 7694 } 7695 7696 static int 7697 test_auth_snow_cipher_zuc_test_case_1(void) 7698 { 7699 return test_mixed_auth_cipher( 7700 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 0); 7701 } 7702 7703 static int 7704 test_verify_auth_snow_cipher_zuc_test_case_1(void) 7705 { 7706 return test_mixed_auth_cipher( 7707 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 1); 7708 } 7709 7710 static int 7711 test_auth_aes_cmac_cipher_zuc_test_case_1(void) 7712 { 7713 return test_mixed_auth_cipher( 7714 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 0); 7715 } 7716 7717 static int 7718 test_verify_auth_aes_cmac_cipher_zuc_test_case_1(void) 7719 { 7720 return test_mixed_auth_cipher( 7721 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 1); 7722 } 7723 7724 static int 7725 test_auth_null_cipher_snow_test_case_1(void) 7726 { 7727 return test_mixed_auth_cipher( 7728 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 0); 7729 } 7730 7731 static int 7732 test_verify_auth_null_cipher_snow_test_case_1(void) 7733 { 7734 return test_mixed_auth_cipher( 7735 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 1); 7736 } 7737 7738 static int 7739 test_auth_null_cipher_zuc_test_case_1(void) 7740 { 7741 return test_mixed_auth_cipher( 7742 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 0); 7743 } 7744 7745 static int 7746 test_verify_auth_null_cipher_zuc_test_case_1(void) 7747 { 7748 return test_mixed_auth_cipher( 7749 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 1); 7750 } 7751 7752 static int 7753 test_auth_snow_cipher_null_test_case_1(void) 7754 { 7755 return test_mixed_auth_cipher( 7756 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 0); 7757 } 7758 7759 static int 7760 test_verify_auth_snow_cipher_null_test_case_1(void) 7761 { 7762 return test_mixed_auth_cipher( 7763 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 1); 7764 } 7765 7766 static int 7767 test_auth_zuc_cipher_null_test_case_1(void) 7768 { 7769 return test_mixed_auth_cipher( 7770 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 0); 7771 } 7772 7773 static int 7774 test_verify_auth_zuc_cipher_null_test_case_1(void) 7775 { 7776 return test_mixed_auth_cipher( 7777 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 1); 7778 } 7779 7780 static int 7781 test_auth_null_cipher_aes_ctr_test_case_1(void) 7782 { 7783 return test_mixed_auth_cipher( 7784 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0); 7785 } 7786 7787 static int 7788 test_verify_auth_null_cipher_aes_ctr_test_case_1(void) 7789 { 7790 return test_mixed_auth_cipher( 7791 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1); 7792 } 7793 7794 static int 7795 test_auth_aes_cmac_cipher_null_test_case_1(void) 7796 { 7797 return test_mixed_auth_cipher( 7798 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 0); 7799 } 7800 7801 static int 7802 test_verify_auth_aes_cmac_cipher_null_test_case_1(void) 7803 { 7804 return test_mixed_auth_cipher( 7805 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 1); 7806 } 7807 7808 /* ***** AEAD algorithm Tests ***** */ 7809 7810 static int 7811 create_aead_session(uint8_t dev_id, enum rte_crypto_aead_algorithm algo, 7812 enum rte_crypto_aead_operation op, 7813 const uint8_t *key, const uint8_t key_len, 7814 const uint16_t aad_len, const uint8_t auth_len, 7815 uint8_t iv_len) 7816 { 7817 uint8_t aead_key[key_len]; 7818 7819 struct crypto_testsuite_params *ts_params = &testsuite_params; 7820 struct crypto_unittest_params *ut_params = &unittest_params; 7821 7822 memcpy(aead_key, key, key_len); 7823 7824 /* Setup AEAD Parameters */ 7825 ut_params->aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD; 7826 ut_params->aead_xform.next = NULL; 7827 ut_params->aead_xform.aead.algo = algo; 7828 ut_params->aead_xform.aead.op = op; 7829 ut_params->aead_xform.aead.key.data = aead_key; 7830 ut_params->aead_xform.aead.key.length = key_len; 7831 ut_params->aead_xform.aead.iv.offset = IV_OFFSET; 7832 ut_params->aead_xform.aead.iv.length = iv_len; 7833 ut_params->aead_xform.aead.digest_length = auth_len; 7834 ut_params->aead_xform.aead.aad_length = aad_len; 7835 7836 debug_hexdump(stdout, "key:", key, key_len); 7837 7838 /* Create Crypto session*/ 7839 ut_params->sess = rte_cryptodev_sym_session_create( 7840 ts_params->session_mpool); 7841 7842 rte_cryptodev_sym_session_init(dev_id, ut_params->sess, 7843 &ut_params->aead_xform, 7844 ts_params->session_priv_mpool); 7845 7846 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 7847 7848 return 0; 7849 } 7850 7851 static int 7852 create_aead_xform(struct rte_crypto_op *op, 7853 enum rte_crypto_aead_algorithm algo, 7854 enum rte_crypto_aead_operation aead_op, 7855 uint8_t *key, const uint8_t key_len, 7856 const uint8_t aad_len, const uint8_t auth_len, 7857 uint8_t iv_len) 7858 { 7859 TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 1), 7860 "failed to allocate space for crypto transform"); 7861 7862 struct rte_crypto_sym_op *sym_op = op->sym; 7863 7864 /* Setup AEAD Parameters */ 7865 sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_AEAD; 7866 sym_op->xform->next = NULL; 7867 sym_op->xform->aead.algo = algo; 7868 sym_op->xform->aead.op = aead_op; 7869 sym_op->xform->aead.key.data = key; 7870 sym_op->xform->aead.key.length = key_len; 7871 sym_op->xform->aead.iv.offset = IV_OFFSET; 7872 sym_op->xform->aead.iv.length = iv_len; 7873 sym_op->xform->aead.digest_length = auth_len; 7874 sym_op->xform->aead.aad_length = aad_len; 7875 7876 debug_hexdump(stdout, "key:", key, key_len); 7877 7878 return 0; 7879 } 7880 7881 static int 7882 create_aead_operation(enum rte_crypto_aead_operation op, 7883 const struct aead_test_data *tdata) 7884 { 7885 struct crypto_testsuite_params *ts_params = &testsuite_params; 7886 struct crypto_unittest_params *ut_params = &unittest_params; 7887 7888 uint8_t *plaintext, *ciphertext; 7889 unsigned int aad_pad_len, plaintext_pad_len; 7890 7891 /* Generate Crypto op data structure */ 7892 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 7893 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 7894 TEST_ASSERT_NOT_NULL(ut_params->op, 7895 "Failed to allocate symmetric crypto operation struct"); 7896 7897 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 7898 7899 /* Append aad data */ 7900 if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) { 7901 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len + 18, 16); 7902 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 7903 aad_pad_len); 7904 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data, 7905 "no room to append aad"); 7906 7907 sym_op->aead.aad.phys_addr = 7908 rte_pktmbuf_iova(ut_params->ibuf); 7909 /* Copy AAD 18 bytes after the AAD pointer, according to the API */ 7910 memcpy(sym_op->aead.aad.data + 18, tdata->aad.data, tdata->aad.len); 7911 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data, 7912 tdata->aad.len); 7913 7914 /* Append IV at the end of the crypto operation*/ 7915 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, 7916 uint8_t *, IV_OFFSET); 7917 7918 /* Copy IV 1 byte after the IV pointer, according to the API */ 7919 rte_memcpy(iv_ptr + 1, tdata->iv.data, tdata->iv.len); 7920 debug_hexdump(stdout, "iv:", iv_ptr, 7921 tdata->iv.len); 7922 } else { 7923 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16); 7924 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 7925 aad_pad_len); 7926 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data, 7927 "no room to append aad"); 7928 7929 sym_op->aead.aad.phys_addr = 7930 rte_pktmbuf_iova(ut_params->ibuf); 7931 memcpy(sym_op->aead.aad.data, tdata->aad.data, tdata->aad.len); 7932 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data, 7933 tdata->aad.len); 7934 7935 /* Append IV at the end of the crypto operation*/ 7936 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, 7937 uint8_t *, IV_OFFSET); 7938 7939 if (tdata->iv.len == 0) { 7940 rte_memcpy(iv_ptr, tdata->iv.data, AES_GCM_J0_LENGTH); 7941 debug_hexdump(stdout, "iv:", iv_ptr, 7942 AES_GCM_J0_LENGTH); 7943 } else { 7944 rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len); 7945 debug_hexdump(stdout, "iv:", iv_ptr, 7946 tdata->iv.len); 7947 } 7948 } 7949 7950 /* Append plaintext/ciphertext */ 7951 if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) { 7952 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16); 7953 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 7954 plaintext_pad_len); 7955 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext"); 7956 7957 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len); 7958 debug_hexdump(stdout, "plaintext:", plaintext, 7959 tdata->plaintext.len); 7960 7961 if (ut_params->obuf) { 7962 ciphertext = (uint8_t *)rte_pktmbuf_append( 7963 ut_params->obuf, 7964 plaintext_pad_len + aad_pad_len); 7965 TEST_ASSERT_NOT_NULL(ciphertext, 7966 "no room to append ciphertext"); 7967 7968 memset(ciphertext + aad_pad_len, 0, 7969 tdata->ciphertext.len); 7970 } 7971 } else { 7972 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16); 7973 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 7974 plaintext_pad_len); 7975 TEST_ASSERT_NOT_NULL(ciphertext, 7976 "no room to append ciphertext"); 7977 7978 memcpy(ciphertext, tdata->ciphertext.data, 7979 tdata->ciphertext.len); 7980 debug_hexdump(stdout, "ciphertext:", ciphertext, 7981 tdata->ciphertext.len); 7982 7983 if (ut_params->obuf) { 7984 plaintext = (uint8_t *)rte_pktmbuf_append( 7985 ut_params->obuf, 7986 plaintext_pad_len + aad_pad_len); 7987 TEST_ASSERT_NOT_NULL(plaintext, 7988 "no room to append plaintext"); 7989 7990 memset(plaintext + aad_pad_len, 0, 7991 tdata->plaintext.len); 7992 } 7993 } 7994 7995 /* Append digest data */ 7996 if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) { 7997 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append( 7998 ut_params->obuf ? ut_params->obuf : 7999 ut_params->ibuf, 8000 tdata->auth_tag.len); 8001 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data, 8002 "no room to append digest"); 8003 memset(sym_op->aead.digest.data, 0, tdata->auth_tag.len); 8004 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset( 8005 ut_params->obuf ? ut_params->obuf : 8006 ut_params->ibuf, 8007 plaintext_pad_len + 8008 aad_pad_len); 8009 } else { 8010 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append( 8011 ut_params->ibuf, tdata->auth_tag.len); 8012 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data, 8013 "no room to append digest"); 8014 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset( 8015 ut_params->ibuf, 8016 plaintext_pad_len + aad_pad_len); 8017 8018 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data, 8019 tdata->auth_tag.len); 8020 debug_hexdump(stdout, "digest:", 8021 sym_op->aead.digest.data, 8022 tdata->auth_tag.len); 8023 } 8024 8025 sym_op->aead.data.length = tdata->plaintext.len; 8026 sym_op->aead.data.offset = aad_pad_len; 8027 8028 return 0; 8029 } 8030 8031 static int 8032 test_authenticated_encryption(const struct aead_test_data *tdata) 8033 { 8034 struct crypto_testsuite_params *ts_params = &testsuite_params; 8035 struct crypto_unittest_params *ut_params = &unittest_params; 8036 8037 int retval; 8038 uint8_t *ciphertext, *auth_tag; 8039 uint16_t plaintext_pad_len; 8040 uint32_t i; 8041 struct rte_cryptodev_info dev_info; 8042 8043 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 8044 uint64_t feat_flags = dev_info.feature_flags; 8045 8046 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 8047 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 8048 printf("Device doesn't support RAW data-path APIs.\n"); 8049 return TEST_SKIPPED; 8050 } 8051 8052 /* Verify the capabilities */ 8053 struct rte_cryptodev_sym_capability_idx cap_idx; 8054 const struct rte_cryptodev_symmetric_capability *capability; 8055 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD; 8056 cap_idx.algo.aead = tdata->algo; 8057 capability = rte_cryptodev_sym_capability_get( 8058 ts_params->valid_devs[0], &cap_idx); 8059 if (capability == NULL) 8060 return TEST_SKIPPED; 8061 if (rte_cryptodev_sym_capability_check_aead( 8062 capability, tdata->key.len, tdata->auth_tag.len, 8063 tdata->aad.len, tdata->iv.len)) 8064 return TEST_SKIPPED; 8065 8066 /* Create AEAD session */ 8067 retval = create_aead_session(ts_params->valid_devs[0], 8068 tdata->algo, 8069 RTE_CRYPTO_AEAD_OP_ENCRYPT, 8070 tdata->key.data, tdata->key.len, 8071 tdata->aad.len, tdata->auth_tag.len, 8072 tdata->iv.len); 8073 if (retval < 0) 8074 return retval; 8075 8076 if (tdata->aad.len > MBUF_SIZE) { 8077 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool); 8078 /* Populate full size of add data */ 8079 for (i = 32; i < MAX_AAD_LENGTH; i += 32) 8080 memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32); 8081 } else 8082 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 8083 8084 /* clear mbuf payload */ 8085 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 8086 rte_pktmbuf_tailroom(ut_params->ibuf)); 8087 8088 /* Create AEAD operation */ 8089 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata); 8090 if (retval < 0) 8091 return retval; 8092 8093 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 8094 8095 ut_params->op->sym->m_src = ut_params->ibuf; 8096 8097 /* Process crypto operation */ 8098 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 8099 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op); 8100 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 8101 process_sym_raw_dp_op(ts_params->valid_devs[0], 0, 8102 ut_params->op, 0, 0, 0, 0); 8103 else 8104 TEST_ASSERT_NOT_NULL( 8105 process_crypto_request(ts_params->valid_devs[0], 8106 ut_params->op), "failed to process sym crypto op"); 8107 8108 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 8109 "crypto op processing failed"); 8110 8111 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16); 8112 8113 if (ut_params->op->sym->m_dst) { 8114 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst, 8115 uint8_t *); 8116 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst, 8117 uint8_t *, plaintext_pad_len); 8118 } else { 8119 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src, 8120 uint8_t *, 8121 ut_params->op->sym->cipher.data.offset); 8122 auth_tag = ciphertext + plaintext_pad_len; 8123 } 8124 8125 debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len); 8126 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len); 8127 8128 /* Validate obuf */ 8129 TEST_ASSERT_BUFFERS_ARE_EQUAL( 8130 ciphertext, 8131 tdata->ciphertext.data, 8132 tdata->ciphertext.len, 8133 "Ciphertext data not as expected"); 8134 8135 TEST_ASSERT_BUFFERS_ARE_EQUAL( 8136 auth_tag, 8137 tdata->auth_tag.data, 8138 tdata->auth_tag.len, 8139 "Generated auth tag not as expected"); 8140 8141 return 0; 8142 8143 } 8144 8145 #ifdef RTE_LIB_SECURITY 8146 static int 8147 security_proto_supported(enum rte_security_session_action_type action, 8148 enum rte_security_session_protocol proto) 8149 { 8150 struct crypto_testsuite_params *ts_params = &testsuite_params; 8151 8152 const struct rte_security_capability *capabilities; 8153 const struct rte_security_capability *capability; 8154 uint16_t i = 0; 8155 8156 struct rte_security_ctx *ctx = (struct rte_security_ctx *) 8157 rte_cryptodev_get_sec_ctx( 8158 ts_params->valid_devs[0]); 8159 8160 8161 capabilities = rte_security_capabilities_get(ctx); 8162 8163 if (capabilities == NULL) 8164 return -ENOTSUP; 8165 8166 while ((capability = &capabilities[i++])->action != 8167 RTE_SECURITY_ACTION_TYPE_NONE) { 8168 if (capability->action == action && 8169 capability->protocol == proto) 8170 return 0; 8171 } 8172 8173 return -ENOTSUP; 8174 } 8175 8176 /* Basic algorithm run function for async inplace mode. 8177 * Creates a session from input parameters and runs one operation 8178 * on input_vec. Checks the output of the crypto operation against 8179 * output_vec. 8180 */ 8181 static int test_pdcp_proto(int i, int oop, enum rte_crypto_cipher_operation opc, 8182 enum rte_crypto_auth_operation opa, 8183 const uint8_t *input_vec, unsigned int input_vec_len, 8184 const uint8_t *output_vec, 8185 unsigned int output_vec_len, 8186 enum rte_crypto_cipher_algorithm cipher_alg, 8187 const uint8_t *cipher_key, uint32_t cipher_key_len, 8188 enum rte_crypto_auth_algorithm auth_alg, 8189 const uint8_t *auth_key, uint32_t auth_key_len, 8190 uint8_t bearer, enum rte_security_pdcp_domain domain, 8191 uint8_t packet_direction, uint8_t sn_size, 8192 uint32_t hfn, uint32_t hfn_threshold, uint8_t sdap) 8193 { 8194 struct crypto_testsuite_params *ts_params = &testsuite_params; 8195 struct crypto_unittest_params *ut_params = &unittest_params; 8196 uint8_t *plaintext; 8197 int ret = TEST_SUCCESS; 8198 struct rte_security_ctx *ctx = (struct rte_security_ctx *) 8199 rte_cryptodev_get_sec_ctx( 8200 ts_params->valid_devs[0]); 8201 8202 /* Verify the capabilities */ 8203 struct rte_security_capability_idx sec_cap_idx; 8204 8205 sec_cap_idx.action = ut_params->type; 8206 sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP; 8207 sec_cap_idx.pdcp.domain = domain; 8208 if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL) 8209 return TEST_SKIPPED; 8210 8211 /* Generate test mbuf data */ 8212 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 8213 8214 /* clear mbuf payload */ 8215 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 8216 rte_pktmbuf_tailroom(ut_params->ibuf)); 8217 8218 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 8219 input_vec_len); 8220 memcpy(plaintext, input_vec, input_vec_len); 8221 8222 /* Out of place support */ 8223 if (oop) { 8224 /* 8225 * For out-op-place we need to alloc another mbuf 8226 */ 8227 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 8228 rte_pktmbuf_append(ut_params->obuf, output_vec_len); 8229 } 8230 8231 /* Setup Cipher Parameters */ 8232 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 8233 ut_params->cipher_xform.cipher.algo = cipher_alg; 8234 ut_params->cipher_xform.cipher.op = opc; 8235 ut_params->cipher_xform.cipher.key.data = cipher_key; 8236 ut_params->cipher_xform.cipher.key.length = cipher_key_len; 8237 ut_params->cipher_xform.cipher.iv.length = 8238 packet_direction ? 4 : 0; 8239 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET; 8240 8241 /* Setup HMAC Parameters if ICV header is required */ 8242 if (auth_alg != 0) { 8243 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 8244 ut_params->auth_xform.next = NULL; 8245 ut_params->auth_xform.auth.algo = auth_alg; 8246 ut_params->auth_xform.auth.op = opa; 8247 ut_params->auth_xform.auth.key.data = auth_key; 8248 ut_params->auth_xform.auth.key.length = auth_key_len; 8249 8250 ut_params->cipher_xform.next = &ut_params->auth_xform; 8251 } else { 8252 ut_params->cipher_xform.next = NULL; 8253 } 8254 8255 struct rte_security_session_conf sess_conf = { 8256 .action_type = ut_params->type, 8257 .protocol = RTE_SECURITY_PROTOCOL_PDCP, 8258 {.pdcp = { 8259 .bearer = bearer, 8260 .domain = domain, 8261 .pkt_dir = packet_direction, 8262 .sn_size = sn_size, 8263 .hfn = packet_direction ? 0 : hfn, 8264 /** 8265 * hfn can be set as pdcp_test_hfn[i] 8266 * if hfn_ovrd is not set. Here, PDCP 8267 * packet direction is just used to 8268 * run half of the cases with session 8269 * HFN and other half with per packet 8270 * HFN. 8271 */ 8272 .hfn_threshold = hfn_threshold, 8273 .hfn_ovrd = packet_direction ? 1 : 0, 8274 .sdap_enabled = sdap, 8275 } }, 8276 .crypto_xform = &ut_params->cipher_xform 8277 }; 8278 8279 /* Create security session */ 8280 ut_params->sec_session = rte_security_session_create(ctx, 8281 &sess_conf, ts_params->session_mpool, 8282 ts_params->session_priv_mpool); 8283 8284 if (!ut_params->sec_session) { 8285 printf("TestCase %s()-%d line %d failed %s: ", 8286 __func__, i, __LINE__, "Failed to allocate session"); 8287 ret = TEST_FAILED; 8288 goto on_err; 8289 } 8290 8291 /* Generate crypto op data structure */ 8292 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 8293 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 8294 if (!ut_params->op) { 8295 printf("TestCase %s()-%d line %d failed %s: ", 8296 __func__, i, __LINE__, 8297 "Failed to allocate symmetric crypto operation struct"); 8298 ret = TEST_FAILED; 8299 goto on_err; 8300 } 8301 8302 uint32_t *per_pkt_hfn = rte_crypto_op_ctod_offset(ut_params->op, 8303 uint32_t *, IV_OFFSET); 8304 *per_pkt_hfn = packet_direction ? hfn : 0; 8305 8306 rte_security_attach_session(ut_params->op, ut_params->sec_session); 8307 8308 /* set crypto operation source mbuf */ 8309 ut_params->op->sym->m_src = ut_params->ibuf; 8310 if (oop) 8311 ut_params->op->sym->m_dst = ut_params->obuf; 8312 8313 /* Process crypto operation */ 8314 if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) 8315 == NULL) { 8316 printf("TestCase %s()-%d line %d failed %s: ", 8317 __func__, i, __LINE__, 8318 "failed to process sym crypto op"); 8319 ret = TEST_FAILED; 8320 goto on_err; 8321 } 8322 8323 if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) { 8324 printf("TestCase %s()-%d line %d failed %s: ", 8325 __func__, i, __LINE__, "crypto op processing failed"); 8326 ret = TEST_FAILED; 8327 goto on_err; 8328 } 8329 8330 /* Validate obuf */ 8331 uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src, 8332 uint8_t *); 8333 if (oop) { 8334 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst, 8335 uint8_t *); 8336 } 8337 8338 if (memcmp(ciphertext, output_vec, output_vec_len)) { 8339 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i); 8340 rte_hexdump(stdout, "encrypted", ciphertext, output_vec_len); 8341 rte_hexdump(stdout, "reference", output_vec, output_vec_len); 8342 ret = TEST_FAILED; 8343 goto on_err; 8344 } 8345 8346 on_err: 8347 rte_crypto_op_free(ut_params->op); 8348 ut_params->op = NULL; 8349 8350 if (ut_params->sec_session) 8351 rte_security_session_destroy(ctx, ut_params->sec_session); 8352 ut_params->sec_session = NULL; 8353 8354 rte_pktmbuf_free(ut_params->ibuf); 8355 ut_params->ibuf = NULL; 8356 if (oop) { 8357 rte_pktmbuf_free(ut_params->obuf); 8358 ut_params->obuf = NULL; 8359 } 8360 8361 return ret; 8362 } 8363 8364 static int 8365 test_pdcp_proto_SGL(int i, int oop, 8366 enum rte_crypto_cipher_operation opc, 8367 enum rte_crypto_auth_operation opa, 8368 uint8_t *input_vec, 8369 unsigned int input_vec_len, 8370 uint8_t *output_vec, 8371 unsigned int output_vec_len, 8372 uint32_t fragsz, 8373 uint32_t fragsz_oop) 8374 { 8375 struct crypto_testsuite_params *ts_params = &testsuite_params; 8376 struct crypto_unittest_params *ut_params = &unittest_params; 8377 uint8_t *plaintext; 8378 struct rte_mbuf *buf, *buf_oop = NULL; 8379 int ret = TEST_SUCCESS; 8380 int to_trn = 0; 8381 int to_trn_tbl[16]; 8382 int segs = 1; 8383 unsigned int trn_data = 0; 8384 struct rte_security_ctx *ctx = (struct rte_security_ctx *) 8385 rte_cryptodev_get_sec_ctx( 8386 ts_params->valid_devs[0]); 8387 8388 /* Verify the capabilities */ 8389 struct rte_security_capability_idx sec_cap_idx; 8390 8391 sec_cap_idx.action = ut_params->type; 8392 sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP; 8393 sec_cap_idx.pdcp.domain = pdcp_test_params[i].domain; 8394 if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL) 8395 return TEST_SKIPPED; 8396 8397 if (fragsz > input_vec_len) 8398 fragsz = input_vec_len; 8399 8400 uint16_t plaintext_len = fragsz; 8401 uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz; 8402 8403 if (fragsz_oop > output_vec_len) 8404 frag_size_oop = output_vec_len; 8405 8406 int ecx = 0; 8407 if (input_vec_len % fragsz != 0) { 8408 if (input_vec_len / fragsz + 1 > 16) 8409 return 1; 8410 } else if (input_vec_len / fragsz > 16) 8411 return 1; 8412 8413 /* Out of place support */ 8414 if (oop) { 8415 /* 8416 * For out-op-place we need to alloc another mbuf 8417 */ 8418 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 8419 rte_pktmbuf_append(ut_params->obuf, frag_size_oop); 8420 buf_oop = ut_params->obuf; 8421 } 8422 8423 /* Generate test mbuf data */ 8424 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 8425 8426 /* clear mbuf payload */ 8427 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 8428 rte_pktmbuf_tailroom(ut_params->ibuf)); 8429 8430 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 8431 plaintext_len); 8432 memcpy(plaintext, input_vec, plaintext_len); 8433 trn_data += plaintext_len; 8434 8435 buf = ut_params->ibuf; 8436 8437 /* 8438 * Loop until no more fragments 8439 */ 8440 8441 while (trn_data < input_vec_len) { 8442 ++segs; 8443 to_trn = (input_vec_len - trn_data < fragsz) ? 8444 (input_vec_len - trn_data) : fragsz; 8445 8446 to_trn_tbl[ecx++] = to_trn; 8447 8448 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool); 8449 buf = buf->next; 8450 8451 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0, 8452 rte_pktmbuf_tailroom(buf)); 8453 8454 /* OOP */ 8455 if (oop && !fragsz_oop) { 8456 buf_oop->next = 8457 rte_pktmbuf_alloc(ts_params->mbuf_pool); 8458 buf_oop = buf_oop->next; 8459 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *), 8460 0, rte_pktmbuf_tailroom(buf_oop)); 8461 rte_pktmbuf_append(buf_oop, to_trn); 8462 } 8463 8464 plaintext = (uint8_t *)rte_pktmbuf_append(buf, 8465 to_trn); 8466 8467 memcpy(plaintext, input_vec + trn_data, to_trn); 8468 trn_data += to_trn; 8469 } 8470 8471 ut_params->ibuf->nb_segs = segs; 8472 8473 segs = 1; 8474 if (fragsz_oop && oop) { 8475 to_trn = 0; 8476 ecx = 0; 8477 8478 trn_data = frag_size_oop; 8479 while (trn_data < output_vec_len) { 8480 ++segs; 8481 to_trn = 8482 (output_vec_len - trn_data < 8483 frag_size_oop) ? 8484 (output_vec_len - trn_data) : 8485 frag_size_oop; 8486 8487 to_trn_tbl[ecx++] = to_trn; 8488 8489 buf_oop->next = 8490 rte_pktmbuf_alloc(ts_params->mbuf_pool); 8491 buf_oop = buf_oop->next; 8492 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *), 8493 0, rte_pktmbuf_tailroom(buf_oop)); 8494 rte_pktmbuf_append(buf_oop, to_trn); 8495 8496 trn_data += to_trn; 8497 } 8498 ut_params->obuf->nb_segs = segs; 8499 } 8500 8501 /* Setup Cipher Parameters */ 8502 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 8503 ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg; 8504 ut_params->cipher_xform.cipher.op = opc; 8505 ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i]; 8506 ut_params->cipher_xform.cipher.key.length = 8507 pdcp_test_params[i].cipher_key_len; 8508 ut_params->cipher_xform.cipher.iv.length = 0; 8509 8510 /* Setup HMAC Parameters if ICV header is required */ 8511 if (pdcp_test_params[i].auth_alg != 0) { 8512 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 8513 ut_params->auth_xform.next = NULL; 8514 ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg; 8515 ut_params->auth_xform.auth.op = opa; 8516 ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i]; 8517 ut_params->auth_xform.auth.key.length = 8518 pdcp_test_params[i].auth_key_len; 8519 8520 ut_params->cipher_xform.next = &ut_params->auth_xform; 8521 } else { 8522 ut_params->cipher_xform.next = NULL; 8523 } 8524 8525 struct rte_security_session_conf sess_conf = { 8526 .action_type = ut_params->type, 8527 .protocol = RTE_SECURITY_PROTOCOL_PDCP, 8528 {.pdcp = { 8529 .bearer = pdcp_test_bearer[i], 8530 .domain = pdcp_test_params[i].domain, 8531 .pkt_dir = pdcp_test_packet_direction[i], 8532 .sn_size = pdcp_test_data_sn_size[i], 8533 .hfn = pdcp_test_hfn[i], 8534 .hfn_threshold = pdcp_test_hfn_threshold[i], 8535 .hfn_ovrd = 0, 8536 } }, 8537 .crypto_xform = &ut_params->cipher_xform 8538 }; 8539 8540 /* Create security session */ 8541 ut_params->sec_session = rte_security_session_create(ctx, 8542 &sess_conf, ts_params->session_mpool, 8543 ts_params->session_priv_mpool); 8544 8545 if (!ut_params->sec_session) { 8546 printf("TestCase %s()-%d line %d failed %s: ", 8547 __func__, i, __LINE__, "Failed to allocate session"); 8548 ret = TEST_FAILED; 8549 goto on_err; 8550 } 8551 8552 /* Generate crypto op data structure */ 8553 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 8554 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 8555 if (!ut_params->op) { 8556 printf("TestCase %s()-%d line %d failed %s: ", 8557 __func__, i, __LINE__, 8558 "Failed to allocate symmetric crypto operation struct"); 8559 ret = TEST_FAILED; 8560 goto on_err; 8561 } 8562 8563 rte_security_attach_session(ut_params->op, ut_params->sec_session); 8564 8565 /* set crypto operation source mbuf */ 8566 ut_params->op->sym->m_src = ut_params->ibuf; 8567 if (oop) 8568 ut_params->op->sym->m_dst = ut_params->obuf; 8569 8570 /* Process crypto operation */ 8571 if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) 8572 == NULL) { 8573 printf("TestCase %s()-%d line %d failed %s: ", 8574 __func__, i, __LINE__, 8575 "failed to process sym crypto op"); 8576 ret = TEST_FAILED; 8577 goto on_err; 8578 } 8579 8580 if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) { 8581 printf("TestCase %s()-%d line %d failed %s: ", 8582 __func__, i, __LINE__, "crypto op processing failed"); 8583 ret = TEST_FAILED; 8584 goto on_err; 8585 } 8586 8587 /* Validate obuf */ 8588 uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src, 8589 uint8_t *); 8590 if (oop) { 8591 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst, 8592 uint8_t *); 8593 } 8594 if (fragsz_oop) 8595 fragsz = frag_size_oop; 8596 if (memcmp(ciphertext, output_vec, fragsz)) { 8597 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i); 8598 rte_hexdump(stdout, "encrypted", ciphertext, fragsz); 8599 rte_hexdump(stdout, "reference", output_vec, fragsz); 8600 ret = TEST_FAILED; 8601 goto on_err; 8602 } 8603 8604 buf = ut_params->op->sym->m_src->next; 8605 if (oop) 8606 buf = ut_params->op->sym->m_dst->next; 8607 8608 unsigned int off = fragsz; 8609 8610 ecx = 0; 8611 while (buf) { 8612 ciphertext = rte_pktmbuf_mtod(buf, 8613 uint8_t *); 8614 if (memcmp(ciphertext, output_vec + off, to_trn_tbl[ecx])) { 8615 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i); 8616 rte_hexdump(stdout, "encrypted", ciphertext, to_trn_tbl[ecx]); 8617 rte_hexdump(stdout, "reference", output_vec + off, 8618 to_trn_tbl[ecx]); 8619 ret = TEST_FAILED; 8620 goto on_err; 8621 } 8622 off += to_trn_tbl[ecx++]; 8623 buf = buf->next; 8624 } 8625 on_err: 8626 rte_crypto_op_free(ut_params->op); 8627 ut_params->op = NULL; 8628 8629 if (ut_params->sec_session) 8630 rte_security_session_destroy(ctx, ut_params->sec_session); 8631 ut_params->sec_session = NULL; 8632 8633 rte_pktmbuf_free(ut_params->ibuf); 8634 ut_params->ibuf = NULL; 8635 if (oop) { 8636 rte_pktmbuf_free(ut_params->obuf); 8637 ut_params->obuf = NULL; 8638 } 8639 8640 return ret; 8641 } 8642 8643 int 8644 test_pdcp_proto_cplane_encap(int i) 8645 { 8646 return test_pdcp_proto( 8647 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE, 8648 pdcp_test_data_in[i], pdcp_test_data_in_len[i], 8649 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4, 8650 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i], 8651 pdcp_test_params[i].cipher_key_len, 8652 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i], 8653 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i], 8654 pdcp_test_params[i].domain, pdcp_test_packet_direction[i], 8655 pdcp_test_data_sn_size[i], pdcp_test_hfn[i], 8656 pdcp_test_hfn_threshold[i], SDAP_DISABLED); 8657 } 8658 8659 int 8660 test_pdcp_proto_uplane_encap(int i) 8661 { 8662 return test_pdcp_proto( 8663 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE, 8664 pdcp_test_data_in[i], pdcp_test_data_in_len[i], 8665 pdcp_test_data_out[i], pdcp_test_data_in_len[i], 8666 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i], 8667 pdcp_test_params[i].cipher_key_len, 8668 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i], 8669 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i], 8670 pdcp_test_params[i].domain, pdcp_test_packet_direction[i], 8671 pdcp_test_data_sn_size[i], pdcp_test_hfn[i], 8672 pdcp_test_hfn_threshold[i], SDAP_DISABLED); 8673 } 8674 8675 int 8676 test_pdcp_proto_uplane_encap_with_int(int i) 8677 { 8678 return test_pdcp_proto( 8679 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE, 8680 pdcp_test_data_in[i], pdcp_test_data_in_len[i], 8681 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4, 8682 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i], 8683 pdcp_test_params[i].cipher_key_len, 8684 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i], 8685 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i], 8686 pdcp_test_params[i].domain, pdcp_test_packet_direction[i], 8687 pdcp_test_data_sn_size[i], pdcp_test_hfn[i], 8688 pdcp_test_hfn_threshold[i], SDAP_DISABLED); 8689 } 8690 8691 int 8692 test_pdcp_proto_cplane_decap(int i) 8693 { 8694 return test_pdcp_proto( 8695 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY, 8696 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4, 8697 pdcp_test_data_in[i], pdcp_test_data_in_len[i], 8698 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i], 8699 pdcp_test_params[i].cipher_key_len, 8700 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i], 8701 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i], 8702 pdcp_test_params[i].domain, pdcp_test_packet_direction[i], 8703 pdcp_test_data_sn_size[i], pdcp_test_hfn[i], 8704 pdcp_test_hfn_threshold[i], SDAP_DISABLED); 8705 } 8706 8707 int 8708 test_pdcp_proto_uplane_decap(int i) 8709 { 8710 return test_pdcp_proto( 8711 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY, 8712 pdcp_test_data_out[i], pdcp_test_data_in_len[i], 8713 pdcp_test_data_in[i], pdcp_test_data_in_len[i], 8714 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i], 8715 pdcp_test_params[i].cipher_key_len, 8716 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i], 8717 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i], 8718 pdcp_test_params[i].domain, pdcp_test_packet_direction[i], 8719 pdcp_test_data_sn_size[i], pdcp_test_hfn[i], 8720 pdcp_test_hfn_threshold[i], SDAP_DISABLED); 8721 } 8722 8723 int 8724 test_pdcp_proto_uplane_decap_with_int(int i) 8725 { 8726 return test_pdcp_proto( 8727 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY, 8728 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4, 8729 pdcp_test_data_in[i], pdcp_test_data_in_len[i], 8730 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i], 8731 pdcp_test_params[i].cipher_key_len, 8732 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i], 8733 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i], 8734 pdcp_test_params[i].domain, pdcp_test_packet_direction[i], 8735 pdcp_test_data_sn_size[i], pdcp_test_hfn[i], 8736 pdcp_test_hfn_threshold[i], SDAP_DISABLED); 8737 } 8738 8739 static int 8740 test_PDCP_PROTO_SGL_in_place_32B(void) 8741 { 8742 /* i can be used for running any PDCP case 8743 * In this case it is uplane 12-bit AES-SNOW DL encap 8744 */ 8745 int i = PDCP_UPLANE_12BIT_OFFSET + AES_ENC + SNOW_AUTH + DOWNLINK; 8746 return test_pdcp_proto_SGL(i, IN_PLACE, 8747 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 8748 RTE_CRYPTO_AUTH_OP_GENERATE, 8749 pdcp_test_data_in[i], 8750 pdcp_test_data_in_len[i], 8751 pdcp_test_data_out[i], 8752 pdcp_test_data_in_len[i]+4, 8753 32, 0); 8754 } 8755 static int 8756 test_PDCP_PROTO_SGL_oop_32B_128B(void) 8757 { 8758 /* i can be used for running any PDCP case 8759 * In this case it is uplane 18-bit NULL-NULL DL encap 8760 */ 8761 int i = PDCP_UPLANE_18BIT_OFFSET + NULL_ENC + NULL_AUTH + DOWNLINK; 8762 return test_pdcp_proto_SGL(i, OUT_OF_PLACE, 8763 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 8764 RTE_CRYPTO_AUTH_OP_GENERATE, 8765 pdcp_test_data_in[i], 8766 pdcp_test_data_in_len[i], 8767 pdcp_test_data_out[i], 8768 pdcp_test_data_in_len[i]+4, 8769 32, 128); 8770 } 8771 static int 8772 test_PDCP_PROTO_SGL_oop_32B_40B(void) 8773 { 8774 /* i can be used for running any PDCP case 8775 * In this case it is uplane 18-bit AES DL encap 8776 */ 8777 int i = PDCP_UPLANE_OFFSET + AES_ENC + EIGHTEEN_BIT_SEQ_NUM_OFFSET 8778 + DOWNLINK; 8779 return test_pdcp_proto_SGL(i, OUT_OF_PLACE, 8780 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 8781 RTE_CRYPTO_AUTH_OP_GENERATE, 8782 pdcp_test_data_in[i], 8783 pdcp_test_data_in_len[i], 8784 pdcp_test_data_out[i], 8785 pdcp_test_data_in_len[i], 8786 32, 40); 8787 } 8788 static int 8789 test_PDCP_PROTO_SGL_oop_128B_32B(void) 8790 { 8791 /* i can be used for running any PDCP case 8792 * In this case it is cplane 12-bit AES-ZUC DL encap 8793 */ 8794 int i = PDCP_CPLANE_LONG_SN_OFFSET + AES_ENC + ZUC_AUTH + DOWNLINK; 8795 return test_pdcp_proto_SGL(i, OUT_OF_PLACE, 8796 RTE_CRYPTO_CIPHER_OP_ENCRYPT, 8797 RTE_CRYPTO_AUTH_OP_GENERATE, 8798 pdcp_test_data_in[i], 8799 pdcp_test_data_in_len[i], 8800 pdcp_test_data_out[i], 8801 pdcp_test_data_in_len[i]+4, 8802 128, 32); 8803 } 8804 8805 static int 8806 test_PDCP_SDAP_PROTO_encap_all(void) 8807 { 8808 int i = 0, size = 0; 8809 int err, all_err = TEST_SUCCESS; 8810 const struct pdcp_sdap_test *cur_test; 8811 8812 size = RTE_DIM(list_pdcp_sdap_tests); 8813 8814 for (i = 0; i < size; i++) { 8815 cur_test = &list_pdcp_sdap_tests[i]; 8816 err = test_pdcp_proto( 8817 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, 8818 RTE_CRYPTO_AUTH_OP_GENERATE, cur_test->data_in, 8819 cur_test->in_len, cur_test->data_out, 8820 cur_test->in_len + ((cur_test->auth_key) ? 4 : 0), 8821 cur_test->param.cipher_alg, cur_test->cipher_key, 8822 cur_test->param.cipher_key_len, 8823 cur_test->param.auth_alg, 8824 cur_test->auth_key, cur_test->param.auth_key_len, 8825 cur_test->bearer, cur_test->param.domain, 8826 cur_test->packet_direction, cur_test->sn_size, 8827 cur_test->hfn, 8828 cur_test->hfn_threshold, SDAP_ENABLED); 8829 if (err) { 8830 printf("\t%d) %s: Encapsulation failed\n", 8831 cur_test->test_idx, 8832 cur_test->param.name); 8833 err = TEST_FAILED; 8834 } else { 8835 printf("\t%d) %s: Encap PASS\n", cur_test->test_idx, 8836 cur_test->param.name); 8837 err = TEST_SUCCESS; 8838 } 8839 all_err += err; 8840 } 8841 8842 printf("Success: %d, Failure: %d\n", size + all_err, -all_err); 8843 8844 return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED; 8845 } 8846 8847 static int 8848 test_PDCP_PROTO_short_mac(void) 8849 { 8850 int i = 0, size = 0; 8851 int err, all_err = TEST_SUCCESS; 8852 const struct pdcp_short_mac_test *cur_test; 8853 8854 size = RTE_DIM(list_pdcp_smac_tests); 8855 8856 for (i = 0; i < size; i++) { 8857 cur_test = &list_pdcp_smac_tests[i]; 8858 err = test_pdcp_proto( 8859 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, 8860 RTE_CRYPTO_AUTH_OP_GENERATE, cur_test->data_in, 8861 cur_test->in_len, cur_test->data_out, 8862 cur_test->in_len + ((cur_test->auth_key) ? 4 : 0), 8863 RTE_CRYPTO_CIPHER_NULL, NULL, 8864 0, cur_test->param.auth_alg, 8865 cur_test->auth_key, cur_test->param.auth_key_len, 8866 0, cur_test->param.domain, 0, 0, 8867 0, 0, 0); 8868 if (err) { 8869 printf("\t%d) %s: Short MAC test failed\n", 8870 cur_test->test_idx, 8871 cur_test->param.name); 8872 err = TEST_FAILED; 8873 } else { 8874 printf("\t%d) %s: Short MAC test PASS\n", 8875 cur_test->test_idx, 8876 cur_test->param.name); 8877 rte_hexdump(stdout, "MAC I", 8878 cur_test->data_out + cur_test->in_len + 2, 8879 2); 8880 err = TEST_SUCCESS; 8881 } 8882 all_err += err; 8883 } 8884 8885 printf("Success: %d, Failure: %d\n", size + all_err, -all_err); 8886 8887 return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED; 8888 8889 } 8890 8891 static int 8892 test_PDCP_SDAP_PROTO_decap_all(void) 8893 { 8894 int i = 0, size = 0; 8895 int err, all_err = TEST_SUCCESS; 8896 const struct pdcp_sdap_test *cur_test; 8897 8898 size = RTE_DIM(list_pdcp_sdap_tests); 8899 8900 for (i = 0; i < size; i++) { 8901 cur_test = &list_pdcp_sdap_tests[i]; 8902 err = test_pdcp_proto( 8903 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, 8904 RTE_CRYPTO_AUTH_OP_VERIFY, 8905 cur_test->data_out, 8906 cur_test->in_len + ((cur_test->auth_key) ? 4 : 0), 8907 cur_test->data_in, cur_test->in_len, 8908 cur_test->param.cipher_alg, 8909 cur_test->cipher_key, cur_test->param.cipher_key_len, 8910 cur_test->param.auth_alg, cur_test->auth_key, 8911 cur_test->param.auth_key_len, cur_test->bearer, 8912 cur_test->param.domain, cur_test->packet_direction, 8913 cur_test->sn_size, cur_test->hfn, 8914 cur_test->hfn_threshold, SDAP_ENABLED); 8915 if (err) { 8916 printf("\t%d) %s: Decapsulation failed\n", 8917 cur_test->test_idx, 8918 cur_test->param.name); 8919 err = TEST_FAILED; 8920 } else { 8921 printf("\t%d) %s: Decap PASS\n", cur_test->test_idx, 8922 cur_test->param.name); 8923 err = TEST_SUCCESS; 8924 } 8925 all_err += err; 8926 } 8927 8928 printf("Success: %d, Failure: %d\n", size + all_err, -all_err); 8929 8930 return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED; 8931 } 8932 8933 static int 8934 test_ipsec_proto_process(const struct ipsec_test_data td[], 8935 struct ipsec_test_data res_d[], 8936 int nb_td, 8937 bool silent, 8938 const struct ipsec_test_flags *flags) 8939 { 8940 struct crypto_testsuite_params *ts_params = &testsuite_params; 8941 struct crypto_unittest_params *ut_params = &unittest_params; 8942 struct rte_security_capability_idx sec_cap_idx; 8943 const struct rte_security_capability *sec_cap; 8944 struct rte_security_ipsec_xform ipsec_xform; 8945 uint8_t dev_id = ts_params->valid_devs[0]; 8946 enum rte_security_ipsec_sa_direction dir; 8947 struct ipsec_test_data *res_d_tmp = NULL; 8948 uint32_t src = RTE_IPV4(192, 168, 1, 0); 8949 uint32_t dst = RTE_IPV4(192, 168, 1, 1); 8950 int salt_len, i, ret = TEST_SUCCESS; 8951 struct rte_security_ctx *ctx; 8952 uint8_t *input_text; 8953 uint32_t verify; 8954 8955 ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL; 8956 gbl_action_type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL; 8957 8958 /* Use first test data to create session */ 8959 8960 /* Copy IPsec xform */ 8961 memcpy(&ipsec_xform, &td[0].ipsec_xform, sizeof(ipsec_xform)); 8962 8963 dir = ipsec_xform.direction; 8964 verify = flags->tunnel_hdr_verify; 8965 8966 if ((dir == RTE_SECURITY_IPSEC_SA_DIR_INGRESS) && verify) { 8967 if (verify == RTE_SECURITY_IPSEC_TUNNEL_VERIFY_SRC_DST_ADDR) 8968 src += 1; 8969 else if (verify == RTE_SECURITY_IPSEC_TUNNEL_VERIFY_DST_ADDR) 8970 dst += 1; 8971 } 8972 8973 memcpy(&ipsec_xform.tunnel.ipv4.src_ip, &src, sizeof(src)); 8974 memcpy(&ipsec_xform.tunnel.ipv4.dst_ip, &dst, sizeof(dst)); 8975 8976 ctx = rte_cryptodev_get_sec_ctx(dev_id); 8977 8978 sec_cap_idx.action = ut_params->type; 8979 sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_IPSEC; 8980 sec_cap_idx.ipsec.proto = ipsec_xform.proto; 8981 sec_cap_idx.ipsec.mode = ipsec_xform.mode; 8982 sec_cap_idx.ipsec.direction = ipsec_xform.direction; 8983 8984 if (flags->udp_encap) 8985 ipsec_xform.options.udp_encap = 1; 8986 8987 sec_cap = rte_security_capability_get(ctx, &sec_cap_idx); 8988 if (sec_cap == NULL) 8989 return TEST_SKIPPED; 8990 8991 /* Copy cipher session parameters */ 8992 if (td[0].aead) { 8993 memcpy(&ut_params->aead_xform, &td[0].xform.aead, 8994 sizeof(ut_params->aead_xform)); 8995 ut_params->aead_xform.aead.key.data = td[0].key.data; 8996 ut_params->aead_xform.aead.iv.offset = IV_OFFSET; 8997 8998 /* Verify crypto capabilities */ 8999 if (test_ipsec_crypto_caps_aead_verify( 9000 sec_cap, 9001 &ut_params->aead_xform) != 0) { 9002 if (!silent) 9003 RTE_LOG(INFO, USER1, 9004 "Crypto capabilities not supported\n"); 9005 return TEST_SKIPPED; 9006 } 9007 } else { 9008 /* Only AEAD supported now */ 9009 return TEST_SKIPPED; 9010 } 9011 9012 if (test_ipsec_sec_caps_verify(&ipsec_xform, sec_cap, silent) != 0) 9013 return TEST_SKIPPED; 9014 9015 salt_len = RTE_MIN(sizeof(ipsec_xform.salt), td[0].salt.len); 9016 memcpy(&ipsec_xform.salt, td[0].salt.data, salt_len); 9017 9018 struct rte_security_session_conf sess_conf = { 9019 .action_type = ut_params->type, 9020 .protocol = RTE_SECURITY_PROTOCOL_IPSEC, 9021 .ipsec = ipsec_xform, 9022 .crypto_xform = &ut_params->aead_xform, 9023 }; 9024 9025 /* Create security session */ 9026 ut_params->sec_session = rte_security_session_create(ctx, &sess_conf, 9027 ts_params->session_mpool, 9028 ts_params->session_priv_mpool); 9029 9030 if (ut_params->sec_session == NULL) 9031 return TEST_SKIPPED; 9032 9033 for (i = 0; i < nb_td; i++) { 9034 /* Setup source mbuf payload */ 9035 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 9036 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 9037 rte_pktmbuf_tailroom(ut_params->ibuf)); 9038 9039 input_text = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 9040 td[i].input_text.len); 9041 9042 memcpy(input_text, td[i].input_text.data, 9043 td[i].input_text.len); 9044 9045 /* Generate crypto op data structure */ 9046 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 9047 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 9048 if (!ut_params->op) { 9049 printf("TestCase %s line %d: %s\n", 9050 __func__, __LINE__, 9051 "failed to allocate crypto op"); 9052 ret = TEST_FAILED; 9053 goto crypto_op_free; 9054 } 9055 9056 /* Attach session to operation */ 9057 rte_security_attach_session(ut_params->op, 9058 ut_params->sec_session); 9059 9060 /* Set crypto operation mbufs */ 9061 ut_params->op->sym->m_src = ut_params->ibuf; 9062 ut_params->op->sym->m_dst = NULL; 9063 9064 /* Copy IV in crypto operation when IV generation is disabled */ 9065 if (dir == RTE_SECURITY_IPSEC_SA_DIR_EGRESS && 9066 ipsec_xform.options.iv_gen_disable == 1) { 9067 uint8_t *iv = rte_crypto_op_ctod_offset(ut_params->op, 9068 uint8_t *, 9069 IV_OFFSET); 9070 int len; 9071 9072 if (td[i].aead) 9073 len = td[i].xform.aead.aead.iv.length; 9074 else 9075 len = td[i].xform.chain.cipher.cipher.iv.length; 9076 9077 memcpy(iv, td[i].iv.data, len); 9078 } 9079 9080 /* Process crypto operation */ 9081 process_crypto_request(dev_id, ut_params->op); 9082 9083 ret = test_ipsec_status_check(ut_params->op, flags, dir, i + 1); 9084 if (ret != TEST_SUCCESS) 9085 goto crypto_op_free; 9086 9087 if (res_d != NULL) 9088 res_d_tmp = &res_d[i]; 9089 9090 ret = test_ipsec_post_process(ut_params->ibuf, &td[i], 9091 res_d_tmp, silent, flags); 9092 if (ret != TEST_SUCCESS) 9093 goto crypto_op_free; 9094 9095 rte_crypto_op_free(ut_params->op); 9096 ut_params->op = NULL; 9097 9098 rte_pktmbuf_free(ut_params->ibuf); 9099 ut_params->ibuf = NULL; 9100 } 9101 9102 crypto_op_free: 9103 rte_crypto_op_free(ut_params->op); 9104 ut_params->op = NULL; 9105 9106 rte_pktmbuf_free(ut_params->ibuf); 9107 ut_params->ibuf = NULL; 9108 9109 if (ut_params->sec_session) 9110 rte_security_session_destroy(ctx, ut_params->sec_session); 9111 ut_params->sec_session = NULL; 9112 9113 return ret; 9114 } 9115 9116 static int 9117 test_ipsec_proto_known_vec(const void *test_data) 9118 { 9119 struct ipsec_test_data td_outb; 9120 struct ipsec_test_flags flags; 9121 9122 memset(&flags, 0, sizeof(flags)); 9123 9124 memcpy(&td_outb, test_data, sizeof(td_outb)); 9125 9126 /* Disable IV gen to be able to test with known vectors */ 9127 td_outb.ipsec_xform.options.iv_gen_disable = 1; 9128 9129 return test_ipsec_proto_process(&td_outb, NULL, 1, false, &flags); 9130 } 9131 9132 static int 9133 test_ipsec_proto_known_vec_inb(const void *td_outb) 9134 { 9135 struct ipsec_test_flags flags; 9136 struct ipsec_test_data td_inb; 9137 9138 memset(&flags, 0, sizeof(flags)); 9139 9140 test_ipsec_td_in_from_out(td_outb, &td_inb); 9141 9142 return test_ipsec_proto_process(&td_inb, NULL, 1, false, &flags); 9143 } 9144 9145 static int 9146 test_ipsec_proto_all(const struct ipsec_test_flags *flags) 9147 { 9148 struct ipsec_test_data td_outb[IPSEC_TEST_PACKETS_MAX]; 9149 struct ipsec_test_data td_inb[IPSEC_TEST_PACKETS_MAX]; 9150 unsigned int i, nb_pkts = 1, pass_cnt = 0; 9151 int ret; 9152 9153 if (flags->iv_gen || 9154 flags->sa_expiry_pkts_soft || 9155 flags->sa_expiry_pkts_hard) 9156 nb_pkts = IPSEC_TEST_PACKETS_MAX; 9157 9158 for (i = 0; i < RTE_DIM(aead_list); i++) { 9159 test_ipsec_td_prepare(&aead_list[i], 9160 NULL, 9161 flags, 9162 td_outb, 9163 nb_pkts); 9164 9165 ret = test_ipsec_proto_process(td_outb, td_inb, nb_pkts, true, 9166 flags); 9167 if (ret == TEST_SKIPPED) 9168 continue; 9169 9170 if (ret == TEST_FAILED) 9171 return TEST_FAILED; 9172 9173 test_ipsec_td_update(td_inb, td_outb, nb_pkts, flags); 9174 9175 ret = test_ipsec_proto_process(td_inb, NULL, nb_pkts, true, 9176 flags); 9177 if (ret == TEST_SKIPPED) 9178 continue; 9179 9180 if (ret == TEST_FAILED) 9181 return TEST_FAILED; 9182 9183 if (flags->display_alg) 9184 test_ipsec_display_alg(&aead_list[i], NULL); 9185 9186 pass_cnt++; 9187 } 9188 9189 if (pass_cnt > 0) 9190 return TEST_SUCCESS; 9191 else 9192 return TEST_SKIPPED; 9193 } 9194 9195 static int 9196 test_ipsec_proto_display_list(const void *data __rte_unused) 9197 { 9198 struct ipsec_test_flags flags; 9199 9200 memset(&flags, 0, sizeof(flags)); 9201 9202 flags.display_alg = true; 9203 9204 return test_ipsec_proto_all(&flags); 9205 } 9206 9207 static int 9208 test_ipsec_proto_iv_gen(const void *data __rte_unused) 9209 { 9210 struct ipsec_test_flags flags; 9211 9212 memset(&flags, 0, sizeof(flags)); 9213 9214 flags.iv_gen = true; 9215 9216 return test_ipsec_proto_all(&flags); 9217 } 9218 9219 static int 9220 test_ipsec_proto_sa_exp_pkts_soft(const void *data __rte_unused) 9221 { 9222 struct ipsec_test_flags flags; 9223 9224 memset(&flags, 0, sizeof(flags)); 9225 9226 flags.sa_expiry_pkts_soft = true; 9227 9228 return test_ipsec_proto_all(&flags); 9229 } 9230 9231 static int 9232 test_ipsec_proto_sa_exp_pkts_hard(const void *data __rte_unused) 9233 { 9234 struct ipsec_test_flags flags; 9235 9236 memset(&flags, 0, sizeof(flags)); 9237 9238 flags.sa_expiry_pkts_hard = true; 9239 9240 return test_ipsec_proto_all(&flags); 9241 } 9242 9243 static int 9244 test_ipsec_proto_err_icv_corrupt(const void *data __rte_unused) 9245 { 9246 struct ipsec_test_flags flags; 9247 9248 memset(&flags, 0, sizeof(flags)); 9249 9250 flags.icv_corrupt = true; 9251 9252 return test_ipsec_proto_all(&flags); 9253 } 9254 9255 static int 9256 test_ipsec_proto_udp_encap(const void *data __rte_unused) 9257 { 9258 struct ipsec_test_flags flags; 9259 9260 memset(&flags, 0, sizeof(flags)); 9261 9262 flags.udp_encap = true; 9263 9264 return test_ipsec_proto_all(&flags); 9265 } 9266 9267 static int 9268 test_ipsec_proto_tunnel_src_dst_addr_verify(const void *data __rte_unused) 9269 { 9270 struct ipsec_test_flags flags; 9271 9272 memset(&flags, 0, sizeof(flags)); 9273 9274 flags.tunnel_hdr_verify = RTE_SECURITY_IPSEC_TUNNEL_VERIFY_SRC_DST_ADDR; 9275 9276 return test_ipsec_proto_all(&flags); 9277 } 9278 9279 static int 9280 test_ipsec_proto_tunnel_dst_addr_verify(const void *data __rte_unused) 9281 { 9282 struct ipsec_test_flags flags; 9283 9284 memset(&flags, 0, sizeof(flags)); 9285 9286 flags.tunnel_hdr_verify = RTE_SECURITY_IPSEC_TUNNEL_VERIFY_DST_ADDR; 9287 9288 return test_ipsec_proto_all(&flags); 9289 } 9290 9291 static int 9292 test_ipsec_proto_udp_ports_verify(const void *data __rte_unused) 9293 { 9294 struct ipsec_test_flags flags; 9295 9296 memset(&flags, 0, sizeof(flags)); 9297 9298 flags.udp_encap = true; 9299 flags.udp_ports_verify = true; 9300 9301 return test_ipsec_proto_all(&flags); 9302 } 9303 9304 static int 9305 test_ipsec_proto_inner_ip_csum(const void *data __rte_unused) 9306 { 9307 struct ipsec_test_flags flags; 9308 9309 memset(&flags, 0, sizeof(flags)); 9310 9311 flags.ip_csum = true; 9312 9313 return test_ipsec_proto_all(&flags); 9314 } 9315 9316 static int 9317 test_ipsec_proto_inner_l4_csum(const void *data __rte_unused) 9318 { 9319 struct ipsec_test_flags flags; 9320 9321 memset(&flags, 0, sizeof(flags)); 9322 9323 flags.l4_csum = true; 9324 9325 return test_ipsec_proto_all(&flags); 9326 } 9327 9328 static int 9329 test_PDCP_PROTO_all(void) 9330 { 9331 struct crypto_testsuite_params *ts_params = &testsuite_params; 9332 struct crypto_unittest_params *ut_params = &unittest_params; 9333 struct rte_cryptodev_info dev_info; 9334 int status; 9335 9336 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 9337 uint64_t feat_flags = dev_info.feature_flags; 9338 9339 if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY)) 9340 return TEST_SKIPPED; 9341 9342 /* Set action type */ 9343 ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ? 9344 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL : 9345 gbl_action_type; 9346 9347 if (security_proto_supported(ut_params->type, 9348 RTE_SECURITY_PROTOCOL_PDCP) < 0) 9349 return TEST_SKIPPED; 9350 9351 status = test_PDCP_PROTO_cplane_encap_all(); 9352 status += test_PDCP_PROTO_cplane_decap_all(); 9353 status += test_PDCP_PROTO_uplane_encap_all(); 9354 status += test_PDCP_PROTO_uplane_decap_all(); 9355 status += test_PDCP_PROTO_SGL_in_place_32B(); 9356 status += test_PDCP_PROTO_SGL_oop_32B_128B(); 9357 status += test_PDCP_PROTO_SGL_oop_32B_40B(); 9358 status += test_PDCP_PROTO_SGL_oop_128B_32B(); 9359 status += test_PDCP_SDAP_PROTO_encap_all(); 9360 status += test_PDCP_SDAP_PROTO_decap_all(); 9361 status += test_PDCP_PROTO_short_mac(); 9362 9363 if (status) 9364 return TEST_FAILED; 9365 else 9366 return TEST_SUCCESS; 9367 } 9368 9369 static int 9370 test_docsis_proto_uplink(int i, struct docsis_test_data *d_td) 9371 { 9372 struct crypto_testsuite_params *ts_params = &testsuite_params; 9373 struct crypto_unittest_params *ut_params = &unittest_params; 9374 uint8_t *plaintext, *ciphertext; 9375 uint8_t *iv_ptr; 9376 int32_t cipher_len, crc_len; 9377 uint32_t crc_data_len; 9378 int ret = TEST_SUCCESS; 9379 9380 struct rte_security_ctx *ctx = (struct rte_security_ctx *) 9381 rte_cryptodev_get_sec_ctx( 9382 ts_params->valid_devs[0]); 9383 9384 /* Verify the capabilities */ 9385 struct rte_security_capability_idx sec_cap_idx; 9386 const struct rte_security_capability *sec_cap; 9387 const struct rte_cryptodev_capabilities *crypto_cap; 9388 const struct rte_cryptodev_symmetric_capability *sym_cap; 9389 int j = 0; 9390 9391 sec_cap_idx.action = ut_params->type; 9392 sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS; 9393 sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_UPLINK; 9394 9395 sec_cap = rte_security_capability_get(ctx, &sec_cap_idx); 9396 if (sec_cap == NULL) 9397 return TEST_SKIPPED; 9398 9399 while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op != 9400 RTE_CRYPTO_OP_TYPE_UNDEFINED) { 9401 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC && 9402 crypto_cap->sym.xform_type == 9403 RTE_CRYPTO_SYM_XFORM_CIPHER && 9404 crypto_cap->sym.cipher.algo == 9405 RTE_CRYPTO_CIPHER_AES_DOCSISBPI) { 9406 sym_cap = &crypto_cap->sym; 9407 if (rte_cryptodev_sym_capability_check_cipher(sym_cap, 9408 d_td->key.len, 9409 d_td->iv.len) == 0) 9410 break; 9411 } 9412 } 9413 9414 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED) 9415 return TEST_SKIPPED; 9416 9417 /* Setup source mbuf payload */ 9418 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 9419 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 9420 rte_pktmbuf_tailroom(ut_params->ibuf)); 9421 9422 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 9423 d_td->ciphertext.len); 9424 9425 memcpy(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len); 9426 9427 /* Setup cipher session parameters */ 9428 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 9429 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI; 9430 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT; 9431 ut_params->cipher_xform.cipher.key.data = d_td->key.data; 9432 ut_params->cipher_xform.cipher.key.length = d_td->key.len; 9433 ut_params->cipher_xform.cipher.iv.length = d_td->iv.len; 9434 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET; 9435 ut_params->cipher_xform.next = NULL; 9436 9437 /* Setup DOCSIS session parameters */ 9438 ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_UPLINK; 9439 9440 struct rte_security_session_conf sess_conf = { 9441 .action_type = ut_params->type, 9442 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS, 9443 .docsis = ut_params->docsis_xform, 9444 .crypto_xform = &ut_params->cipher_xform, 9445 }; 9446 9447 /* Create security session */ 9448 ut_params->sec_session = rte_security_session_create(ctx, &sess_conf, 9449 ts_params->session_mpool, 9450 ts_params->session_priv_mpool); 9451 9452 if (!ut_params->sec_session) { 9453 printf("TestCase %s(%d) line %d: %s\n", 9454 __func__, i, __LINE__, "failed to allocate session"); 9455 ret = TEST_FAILED; 9456 goto on_err; 9457 } 9458 9459 /* Generate crypto op data structure */ 9460 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 9461 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 9462 if (!ut_params->op) { 9463 printf("TestCase %s(%d) line %d: %s\n", 9464 __func__, i, __LINE__, 9465 "failed to allocate symmetric crypto operation"); 9466 ret = TEST_FAILED; 9467 goto on_err; 9468 } 9469 9470 /* Setup CRC operation parameters */ 9471 crc_len = d_td->ciphertext.no_crc == false ? 9472 (d_td->ciphertext.len - 9473 d_td->ciphertext.crc_offset - 9474 RTE_ETHER_CRC_LEN) : 9475 0; 9476 crc_len = crc_len > 0 ? crc_len : 0; 9477 crc_data_len = crc_len == 0 ? 0 : RTE_ETHER_CRC_LEN; 9478 ut_params->op->sym->auth.data.length = crc_len; 9479 ut_params->op->sym->auth.data.offset = d_td->ciphertext.crc_offset; 9480 9481 /* Setup cipher operation parameters */ 9482 cipher_len = d_td->ciphertext.no_cipher == false ? 9483 (d_td->ciphertext.len - 9484 d_td->ciphertext.cipher_offset) : 9485 0; 9486 cipher_len = cipher_len > 0 ? cipher_len : 0; 9487 ut_params->op->sym->cipher.data.length = cipher_len; 9488 ut_params->op->sym->cipher.data.offset = d_td->ciphertext.cipher_offset; 9489 9490 /* Setup cipher IV */ 9491 iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET; 9492 rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len); 9493 9494 /* Attach session to operation */ 9495 rte_security_attach_session(ut_params->op, ut_params->sec_session); 9496 9497 /* Set crypto operation mbufs */ 9498 ut_params->op->sym->m_src = ut_params->ibuf; 9499 ut_params->op->sym->m_dst = NULL; 9500 9501 /* Process crypto operation */ 9502 if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) == 9503 NULL) { 9504 printf("TestCase %s(%d) line %d: %s\n", 9505 __func__, i, __LINE__, 9506 "failed to process security crypto op"); 9507 ret = TEST_FAILED; 9508 goto on_err; 9509 } 9510 9511 if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) { 9512 printf("TestCase %s(%d) line %d: %s\n", 9513 __func__, i, __LINE__, "crypto op processing failed"); 9514 ret = TEST_FAILED; 9515 goto on_err; 9516 } 9517 9518 /* Validate plaintext */ 9519 plaintext = ciphertext; 9520 9521 if (memcmp(plaintext, d_td->plaintext.data, 9522 d_td->plaintext.len - crc_data_len)) { 9523 printf("TestCase %s(%d) line %d: %s\n", 9524 __func__, i, __LINE__, "plaintext not as expected\n"); 9525 rte_hexdump(stdout, "expected", d_td->plaintext.data, 9526 d_td->plaintext.len); 9527 rte_hexdump(stdout, "actual", plaintext, d_td->plaintext.len); 9528 ret = TEST_FAILED; 9529 goto on_err; 9530 } 9531 9532 on_err: 9533 rte_crypto_op_free(ut_params->op); 9534 ut_params->op = NULL; 9535 9536 if (ut_params->sec_session) 9537 rte_security_session_destroy(ctx, ut_params->sec_session); 9538 ut_params->sec_session = NULL; 9539 9540 rte_pktmbuf_free(ut_params->ibuf); 9541 ut_params->ibuf = NULL; 9542 9543 return ret; 9544 } 9545 9546 static int 9547 test_docsis_proto_downlink(int i, struct docsis_test_data *d_td) 9548 { 9549 struct crypto_testsuite_params *ts_params = &testsuite_params; 9550 struct crypto_unittest_params *ut_params = &unittest_params; 9551 uint8_t *plaintext, *ciphertext; 9552 uint8_t *iv_ptr; 9553 int32_t cipher_len, crc_len; 9554 int ret = TEST_SUCCESS; 9555 9556 struct rte_security_ctx *ctx = (struct rte_security_ctx *) 9557 rte_cryptodev_get_sec_ctx( 9558 ts_params->valid_devs[0]); 9559 9560 /* Verify the capabilities */ 9561 struct rte_security_capability_idx sec_cap_idx; 9562 const struct rte_security_capability *sec_cap; 9563 const struct rte_cryptodev_capabilities *crypto_cap; 9564 const struct rte_cryptodev_symmetric_capability *sym_cap; 9565 int j = 0; 9566 9567 sec_cap_idx.action = ut_params->type; 9568 sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS; 9569 sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_DOWNLINK; 9570 9571 sec_cap = rte_security_capability_get(ctx, &sec_cap_idx); 9572 if (sec_cap == NULL) 9573 return TEST_SKIPPED; 9574 9575 while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op != 9576 RTE_CRYPTO_OP_TYPE_UNDEFINED) { 9577 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC && 9578 crypto_cap->sym.xform_type == 9579 RTE_CRYPTO_SYM_XFORM_CIPHER && 9580 crypto_cap->sym.cipher.algo == 9581 RTE_CRYPTO_CIPHER_AES_DOCSISBPI) { 9582 sym_cap = &crypto_cap->sym; 9583 if (rte_cryptodev_sym_capability_check_cipher(sym_cap, 9584 d_td->key.len, 9585 d_td->iv.len) == 0) 9586 break; 9587 } 9588 } 9589 9590 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED) 9591 return TEST_SKIPPED; 9592 9593 /* Setup source mbuf payload */ 9594 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 9595 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 9596 rte_pktmbuf_tailroom(ut_params->ibuf)); 9597 9598 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 9599 d_td->plaintext.len); 9600 9601 memcpy(plaintext, d_td->plaintext.data, d_td->plaintext.len); 9602 9603 /* Setup cipher session parameters */ 9604 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 9605 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI; 9606 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; 9607 ut_params->cipher_xform.cipher.key.data = d_td->key.data; 9608 ut_params->cipher_xform.cipher.key.length = d_td->key.len; 9609 ut_params->cipher_xform.cipher.iv.length = d_td->iv.len; 9610 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET; 9611 ut_params->cipher_xform.next = NULL; 9612 9613 /* Setup DOCSIS session parameters */ 9614 ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_DOWNLINK; 9615 9616 struct rte_security_session_conf sess_conf = { 9617 .action_type = ut_params->type, 9618 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS, 9619 .docsis = ut_params->docsis_xform, 9620 .crypto_xform = &ut_params->cipher_xform, 9621 }; 9622 9623 /* Create security session */ 9624 ut_params->sec_session = rte_security_session_create(ctx, &sess_conf, 9625 ts_params->session_mpool, 9626 ts_params->session_priv_mpool); 9627 9628 if (!ut_params->sec_session) { 9629 printf("TestCase %s(%d) line %d: %s\n", 9630 __func__, i, __LINE__, "failed to allocate session"); 9631 ret = TEST_FAILED; 9632 goto on_err; 9633 } 9634 9635 /* Generate crypto op data structure */ 9636 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 9637 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 9638 if (!ut_params->op) { 9639 printf("TestCase %s(%d) line %d: %s\n", 9640 __func__, i, __LINE__, 9641 "failed to allocate security crypto operation"); 9642 ret = TEST_FAILED; 9643 goto on_err; 9644 } 9645 9646 /* Setup CRC operation parameters */ 9647 crc_len = d_td->plaintext.no_crc == false ? 9648 (d_td->plaintext.len - 9649 d_td->plaintext.crc_offset - 9650 RTE_ETHER_CRC_LEN) : 9651 0; 9652 crc_len = crc_len > 0 ? crc_len : 0; 9653 ut_params->op->sym->auth.data.length = crc_len; 9654 ut_params->op->sym->auth.data.offset = d_td->plaintext.crc_offset; 9655 9656 /* Setup cipher operation parameters */ 9657 cipher_len = d_td->plaintext.no_cipher == false ? 9658 (d_td->plaintext.len - 9659 d_td->plaintext.cipher_offset) : 9660 0; 9661 cipher_len = cipher_len > 0 ? cipher_len : 0; 9662 ut_params->op->sym->cipher.data.length = cipher_len; 9663 ut_params->op->sym->cipher.data.offset = d_td->plaintext.cipher_offset; 9664 9665 /* Setup cipher IV */ 9666 iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET; 9667 rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len); 9668 9669 /* Attach session to operation */ 9670 rte_security_attach_session(ut_params->op, ut_params->sec_session); 9671 9672 /* Set crypto operation mbufs */ 9673 ut_params->op->sym->m_src = ut_params->ibuf; 9674 ut_params->op->sym->m_dst = NULL; 9675 9676 /* Process crypto operation */ 9677 if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) == 9678 NULL) { 9679 printf("TestCase %s(%d) line %d: %s\n", 9680 __func__, i, __LINE__, 9681 "failed to process security crypto op"); 9682 ret = TEST_FAILED; 9683 goto on_err; 9684 } 9685 9686 if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) { 9687 printf("TestCase %s(%d) line %d: %s\n", 9688 __func__, i, __LINE__, "crypto op processing failed"); 9689 ret = TEST_FAILED; 9690 goto on_err; 9691 } 9692 9693 /* Validate ciphertext */ 9694 ciphertext = plaintext; 9695 9696 if (memcmp(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len)) { 9697 printf("TestCase %s(%d) line %d: %s\n", 9698 __func__, i, __LINE__, "ciphertext not as expected\n"); 9699 rte_hexdump(stdout, "expected", d_td->ciphertext.data, 9700 d_td->ciphertext.len); 9701 rte_hexdump(stdout, "actual", ciphertext, d_td->ciphertext.len); 9702 ret = TEST_FAILED; 9703 goto on_err; 9704 } 9705 9706 on_err: 9707 rte_crypto_op_free(ut_params->op); 9708 ut_params->op = NULL; 9709 9710 if (ut_params->sec_session) 9711 rte_security_session_destroy(ctx, ut_params->sec_session); 9712 ut_params->sec_session = NULL; 9713 9714 rte_pktmbuf_free(ut_params->ibuf); 9715 ut_params->ibuf = NULL; 9716 9717 return ret; 9718 } 9719 9720 #define TEST_DOCSIS_COUNT(func) do { \ 9721 int ret = func; \ 9722 if (ret == TEST_SUCCESS) { \ 9723 printf("\t%2d)", n++); \ 9724 printf("+++++ PASSED:" #func"\n"); \ 9725 p++; \ 9726 } else if (ret == TEST_SKIPPED) { \ 9727 printf("\t%2d)", n++); \ 9728 printf("~~~~~ SKIPPED:" #func"\n"); \ 9729 s++; \ 9730 } else { \ 9731 printf("\t%2d)", n++); \ 9732 printf("----- FAILED:" #func"\n"); \ 9733 f++; \ 9734 } \ 9735 } while (0) 9736 9737 static int 9738 test_DOCSIS_PROTO_uplink_all(void) 9739 { 9740 int p = 0, s = 0, f = 0, n = 0; 9741 9742 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(1, &docsis_test_case_1)); 9743 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(2, &docsis_test_case_2)); 9744 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(3, &docsis_test_case_3)); 9745 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(4, &docsis_test_case_4)); 9746 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(5, &docsis_test_case_5)); 9747 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(6, &docsis_test_case_6)); 9748 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(7, &docsis_test_case_7)); 9749 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(8, &docsis_test_case_8)); 9750 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(9, &docsis_test_case_9)); 9751 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(10, &docsis_test_case_10)); 9752 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(11, &docsis_test_case_11)); 9753 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(12, &docsis_test_case_12)); 9754 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(13, &docsis_test_case_13)); 9755 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(14, &docsis_test_case_14)); 9756 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(15, &docsis_test_case_15)); 9757 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(16, &docsis_test_case_16)); 9758 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(17, &docsis_test_case_17)); 9759 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(18, &docsis_test_case_18)); 9760 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(19, &docsis_test_case_19)); 9761 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(20, &docsis_test_case_20)); 9762 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(21, &docsis_test_case_21)); 9763 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(22, &docsis_test_case_22)); 9764 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(23, &docsis_test_case_23)); 9765 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(24, &docsis_test_case_24)); 9766 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(25, &docsis_test_case_25)); 9767 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(26, &docsis_test_case_26)); 9768 9769 if (f) 9770 printf("## %s: %d passed out of %d (%d skipped)\n", 9771 __func__, p, n, s); 9772 9773 return f; 9774 }; 9775 9776 static int 9777 test_DOCSIS_PROTO_downlink_all(void) 9778 { 9779 int p = 0, s = 0, f = 0, n = 0; 9780 9781 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(1, &docsis_test_case_1)); 9782 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(2, &docsis_test_case_2)); 9783 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(3, &docsis_test_case_3)); 9784 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(4, &docsis_test_case_4)); 9785 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(5, &docsis_test_case_5)); 9786 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(6, &docsis_test_case_6)); 9787 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(7, &docsis_test_case_7)); 9788 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(8, &docsis_test_case_8)); 9789 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(9, &docsis_test_case_9)); 9790 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(10, &docsis_test_case_10)); 9791 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(11, &docsis_test_case_11)); 9792 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(12, &docsis_test_case_12)); 9793 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(13, &docsis_test_case_13)); 9794 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(14, &docsis_test_case_14)); 9795 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(15, &docsis_test_case_15)); 9796 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(16, &docsis_test_case_16)); 9797 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(17, &docsis_test_case_17)); 9798 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(18, &docsis_test_case_18)); 9799 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(19, &docsis_test_case_19)); 9800 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(20, &docsis_test_case_20)); 9801 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(21, &docsis_test_case_21)); 9802 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(22, &docsis_test_case_22)); 9803 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(23, &docsis_test_case_23)); 9804 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(24, &docsis_test_case_24)); 9805 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(25, &docsis_test_case_25)); 9806 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(26, &docsis_test_case_26)); 9807 9808 if (f) 9809 printf("## %s: %d passed out of %d (%d skipped)\n", 9810 __func__, p, n, s); 9811 9812 return f; 9813 }; 9814 9815 static int 9816 test_DOCSIS_PROTO_all(void) 9817 { 9818 struct crypto_testsuite_params *ts_params = &testsuite_params; 9819 struct crypto_unittest_params *ut_params = &unittest_params; 9820 struct rte_cryptodev_info dev_info; 9821 int status; 9822 9823 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 9824 uint64_t feat_flags = dev_info.feature_flags; 9825 9826 if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY)) 9827 return TEST_SKIPPED; 9828 9829 /* Set action type */ 9830 ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ? 9831 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL : 9832 gbl_action_type; 9833 9834 if (security_proto_supported(ut_params->type, 9835 RTE_SECURITY_PROTOCOL_DOCSIS) < 0) 9836 return TEST_SKIPPED; 9837 9838 status = test_DOCSIS_PROTO_uplink_all(); 9839 status += test_DOCSIS_PROTO_downlink_all(); 9840 9841 if (status) 9842 return TEST_FAILED; 9843 else 9844 return TEST_SUCCESS; 9845 } 9846 #endif 9847 9848 static int 9849 test_AES_GCM_authenticated_encryption_test_case_1(void) 9850 { 9851 return test_authenticated_encryption(&gcm_test_case_1); 9852 } 9853 9854 static int 9855 test_AES_GCM_authenticated_encryption_test_case_2(void) 9856 { 9857 return test_authenticated_encryption(&gcm_test_case_2); 9858 } 9859 9860 static int 9861 test_AES_GCM_authenticated_encryption_test_case_3(void) 9862 { 9863 return test_authenticated_encryption(&gcm_test_case_3); 9864 } 9865 9866 static int 9867 test_AES_GCM_authenticated_encryption_test_case_4(void) 9868 { 9869 return test_authenticated_encryption(&gcm_test_case_4); 9870 } 9871 9872 static int 9873 test_AES_GCM_authenticated_encryption_test_case_5(void) 9874 { 9875 return test_authenticated_encryption(&gcm_test_case_5); 9876 } 9877 9878 static int 9879 test_AES_GCM_authenticated_encryption_test_case_6(void) 9880 { 9881 return test_authenticated_encryption(&gcm_test_case_6); 9882 } 9883 9884 static int 9885 test_AES_GCM_authenticated_encryption_test_case_7(void) 9886 { 9887 return test_authenticated_encryption(&gcm_test_case_7); 9888 } 9889 9890 static int 9891 test_AES_GCM_authenticated_encryption_test_case_8(void) 9892 { 9893 return test_authenticated_encryption(&gcm_test_case_8); 9894 } 9895 9896 static int 9897 test_AES_GCM_J0_authenticated_encryption_test_case_1(void) 9898 { 9899 return test_authenticated_encryption(&gcm_J0_test_case_1); 9900 } 9901 9902 static int 9903 test_AES_GCM_auth_encryption_test_case_192_1(void) 9904 { 9905 return test_authenticated_encryption(&gcm_test_case_192_1); 9906 } 9907 9908 static int 9909 test_AES_GCM_auth_encryption_test_case_192_2(void) 9910 { 9911 return test_authenticated_encryption(&gcm_test_case_192_2); 9912 } 9913 9914 static int 9915 test_AES_GCM_auth_encryption_test_case_192_3(void) 9916 { 9917 return test_authenticated_encryption(&gcm_test_case_192_3); 9918 } 9919 9920 static int 9921 test_AES_GCM_auth_encryption_test_case_192_4(void) 9922 { 9923 return test_authenticated_encryption(&gcm_test_case_192_4); 9924 } 9925 9926 static int 9927 test_AES_GCM_auth_encryption_test_case_192_5(void) 9928 { 9929 return test_authenticated_encryption(&gcm_test_case_192_5); 9930 } 9931 9932 static int 9933 test_AES_GCM_auth_encryption_test_case_192_6(void) 9934 { 9935 return test_authenticated_encryption(&gcm_test_case_192_6); 9936 } 9937 9938 static int 9939 test_AES_GCM_auth_encryption_test_case_192_7(void) 9940 { 9941 return test_authenticated_encryption(&gcm_test_case_192_7); 9942 } 9943 9944 static int 9945 test_AES_GCM_auth_encryption_test_case_256_1(void) 9946 { 9947 return test_authenticated_encryption(&gcm_test_case_256_1); 9948 } 9949 9950 static int 9951 test_AES_GCM_auth_encryption_test_case_256_2(void) 9952 { 9953 return test_authenticated_encryption(&gcm_test_case_256_2); 9954 } 9955 9956 static int 9957 test_AES_GCM_auth_encryption_test_case_256_3(void) 9958 { 9959 return test_authenticated_encryption(&gcm_test_case_256_3); 9960 } 9961 9962 static int 9963 test_AES_GCM_auth_encryption_test_case_256_4(void) 9964 { 9965 return test_authenticated_encryption(&gcm_test_case_256_4); 9966 } 9967 9968 static int 9969 test_AES_GCM_auth_encryption_test_case_256_5(void) 9970 { 9971 return test_authenticated_encryption(&gcm_test_case_256_5); 9972 } 9973 9974 static int 9975 test_AES_GCM_auth_encryption_test_case_256_6(void) 9976 { 9977 return test_authenticated_encryption(&gcm_test_case_256_6); 9978 } 9979 9980 static int 9981 test_AES_GCM_auth_encryption_test_case_256_7(void) 9982 { 9983 return test_authenticated_encryption(&gcm_test_case_256_7); 9984 } 9985 9986 static int 9987 test_AES_GCM_auth_encryption_test_case_aad_1(void) 9988 { 9989 return test_authenticated_encryption(&gcm_test_case_aad_1); 9990 } 9991 9992 static int 9993 test_AES_GCM_auth_encryption_test_case_aad_2(void) 9994 { 9995 return test_authenticated_encryption(&gcm_test_case_aad_2); 9996 } 9997 9998 static int 9999 test_AES_GCM_auth_encryption_fail_iv_corrupt(void) 10000 { 10001 struct aead_test_data tdata; 10002 int res; 10003 10004 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n"); 10005 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); 10006 tdata.iv.data[0] += 1; 10007 res = test_authenticated_encryption(&tdata); 10008 if (res == TEST_SKIPPED) 10009 return res; 10010 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed"); 10011 return TEST_SUCCESS; 10012 } 10013 10014 static int 10015 test_AES_GCM_auth_encryption_fail_in_data_corrupt(void) 10016 { 10017 struct aead_test_data tdata; 10018 int res; 10019 10020 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n"); 10021 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); 10022 tdata.plaintext.data[0] += 1; 10023 res = test_authenticated_encryption(&tdata); 10024 if (res == TEST_SKIPPED) 10025 return res; 10026 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed"); 10027 return TEST_SUCCESS; 10028 } 10029 10030 static int 10031 test_AES_GCM_auth_encryption_fail_out_data_corrupt(void) 10032 { 10033 struct aead_test_data tdata; 10034 int res; 10035 10036 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n"); 10037 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); 10038 tdata.ciphertext.data[0] += 1; 10039 res = test_authenticated_encryption(&tdata); 10040 if (res == TEST_SKIPPED) 10041 return res; 10042 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed"); 10043 return TEST_SUCCESS; 10044 } 10045 10046 static int 10047 test_AES_GCM_auth_encryption_fail_aad_len_corrupt(void) 10048 { 10049 struct aead_test_data tdata; 10050 int res; 10051 10052 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n"); 10053 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); 10054 tdata.aad.len += 1; 10055 res = test_authenticated_encryption(&tdata); 10056 if (res == TEST_SKIPPED) 10057 return res; 10058 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed"); 10059 return TEST_SUCCESS; 10060 } 10061 10062 static int 10063 test_AES_GCM_auth_encryption_fail_aad_corrupt(void) 10064 { 10065 struct aead_test_data tdata; 10066 uint8_t aad[gcm_test_case_7.aad.len]; 10067 int res; 10068 10069 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n"); 10070 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); 10071 memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len); 10072 aad[0] += 1; 10073 tdata.aad.data = aad; 10074 res = test_authenticated_encryption(&tdata); 10075 if (res == TEST_SKIPPED) 10076 return res; 10077 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed"); 10078 return TEST_SUCCESS; 10079 } 10080 10081 static int 10082 test_AES_GCM_auth_encryption_fail_tag_corrupt(void) 10083 { 10084 struct aead_test_data tdata; 10085 int res; 10086 10087 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n"); 10088 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); 10089 tdata.auth_tag.data[0] += 1; 10090 res = test_authenticated_encryption(&tdata); 10091 if (res == TEST_SKIPPED) 10092 return res; 10093 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed"); 10094 return TEST_SUCCESS; 10095 } 10096 10097 static int 10098 test_authenticated_decryption(const struct aead_test_data *tdata) 10099 { 10100 struct crypto_testsuite_params *ts_params = &testsuite_params; 10101 struct crypto_unittest_params *ut_params = &unittest_params; 10102 10103 int retval; 10104 uint8_t *plaintext; 10105 uint32_t i; 10106 struct rte_cryptodev_info dev_info; 10107 10108 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 10109 uint64_t feat_flags = dev_info.feature_flags; 10110 10111 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 10112 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 10113 printf("Device doesn't support RAW data-path APIs.\n"); 10114 return TEST_SKIPPED; 10115 } 10116 10117 /* Verify the capabilities */ 10118 struct rte_cryptodev_sym_capability_idx cap_idx; 10119 const struct rte_cryptodev_symmetric_capability *capability; 10120 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD; 10121 cap_idx.algo.aead = tdata->algo; 10122 capability = rte_cryptodev_sym_capability_get( 10123 ts_params->valid_devs[0], &cap_idx); 10124 if (capability == NULL) 10125 return TEST_SKIPPED; 10126 if (rte_cryptodev_sym_capability_check_aead( 10127 capability, tdata->key.len, tdata->auth_tag.len, 10128 tdata->aad.len, tdata->iv.len)) 10129 return TEST_SKIPPED; 10130 10131 /* Create AEAD session */ 10132 retval = create_aead_session(ts_params->valid_devs[0], 10133 tdata->algo, 10134 RTE_CRYPTO_AEAD_OP_DECRYPT, 10135 tdata->key.data, tdata->key.len, 10136 tdata->aad.len, tdata->auth_tag.len, 10137 tdata->iv.len); 10138 if (retval < 0) 10139 return retval; 10140 10141 /* alloc mbuf and set payload */ 10142 if (tdata->aad.len > MBUF_SIZE) { 10143 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool); 10144 /* Populate full size of add data */ 10145 for (i = 32; i < MAX_AAD_LENGTH; i += 32) 10146 memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32); 10147 } else 10148 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 10149 10150 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 10151 rte_pktmbuf_tailroom(ut_params->ibuf)); 10152 10153 /* Create AEAD operation */ 10154 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata); 10155 if (retval < 0) 10156 return retval; 10157 10158 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 10159 10160 ut_params->op->sym->m_src = ut_params->ibuf; 10161 10162 /* Process crypto operation */ 10163 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 10164 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op); 10165 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 10166 process_sym_raw_dp_op(ts_params->valid_devs[0], 0, 10167 ut_params->op, 0, 0, 0, 0); 10168 else 10169 TEST_ASSERT_NOT_NULL( 10170 process_crypto_request(ts_params->valid_devs[0], 10171 ut_params->op), "failed to process sym crypto op"); 10172 10173 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 10174 "crypto op processing failed"); 10175 10176 if (ut_params->op->sym->m_dst) 10177 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst, 10178 uint8_t *); 10179 else 10180 plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src, 10181 uint8_t *, 10182 ut_params->op->sym->cipher.data.offset); 10183 10184 debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len); 10185 10186 /* Validate obuf */ 10187 TEST_ASSERT_BUFFERS_ARE_EQUAL( 10188 plaintext, 10189 tdata->plaintext.data, 10190 tdata->plaintext.len, 10191 "Plaintext data not as expected"); 10192 10193 TEST_ASSERT_EQUAL(ut_params->op->status, 10194 RTE_CRYPTO_OP_STATUS_SUCCESS, 10195 "Authentication failed"); 10196 10197 return 0; 10198 } 10199 10200 static int 10201 test_AES_GCM_authenticated_decryption_test_case_1(void) 10202 { 10203 return test_authenticated_decryption(&gcm_test_case_1); 10204 } 10205 10206 static int 10207 test_AES_GCM_authenticated_decryption_test_case_2(void) 10208 { 10209 return test_authenticated_decryption(&gcm_test_case_2); 10210 } 10211 10212 static int 10213 test_AES_GCM_authenticated_decryption_test_case_3(void) 10214 { 10215 return test_authenticated_decryption(&gcm_test_case_3); 10216 } 10217 10218 static int 10219 test_AES_GCM_authenticated_decryption_test_case_4(void) 10220 { 10221 return test_authenticated_decryption(&gcm_test_case_4); 10222 } 10223 10224 static int 10225 test_AES_GCM_authenticated_decryption_test_case_5(void) 10226 { 10227 return test_authenticated_decryption(&gcm_test_case_5); 10228 } 10229 10230 static int 10231 test_AES_GCM_authenticated_decryption_test_case_6(void) 10232 { 10233 return test_authenticated_decryption(&gcm_test_case_6); 10234 } 10235 10236 static int 10237 test_AES_GCM_authenticated_decryption_test_case_7(void) 10238 { 10239 return test_authenticated_decryption(&gcm_test_case_7); 10240 } 10241 10242 static int 10243 test_AES_GCM_authenticated_decryption_test_case_8(void) 10244 { 10245 return test_authenticated_decryption(&gcm_test_case_8); 10246 } 10247 10248 static int 10249 test_AES_GCM_J0_authenticated_decryption_test_case_1(void) 10250 { 10251 return test_authenticated_decryption(&gcm_J0_test_case_1); 10252 } 10253 10254 static int 10255 test_AES_GCM_auth_decryption_test_case_192_1(void) 10256 { 10257 return test_authenticated_decryption(&gcm_test_case_192_1); 10258 } 10259 10260 static int 10261 test_AES_GCM_auth_decryption_test_case_192_2(void) 10262 { 10263 return test_authenticated_decryption(&gcm_test_case_192_2); 10264 } 10265 10266 static int 10267 test_AES_GCM_auth_decryption_test_case_192_3(void) 10268 { 10269 return test_authenticated_decryption(&gcm_test_case_192_3); 10270 } 10271 10272 static int 10273 test_AES_GCM_auth_decryption_test_case_192_4(void) 10274 { 10275 return test_authenticated_decryption(&gcm_test_case_192_4); 10276 } 10277 10278 static int 10279 test_AES_GCM_auth_decryption_test_case_192_5(void) 10280 { 10281 return test_authenticated_decryption(&gcm_test_case_192_5); 10282 } 10283 10284 static int 10285 test_AES_GCM_auth_decryption_test_case_192_6(void) 10286 { 10287 return test_authenticated_decryption(&gcm_test_case_192_6); 10288 } 10289 10290 static int 10291 test_AES_GCM_auth_decryption_test_case_192_7(void) 10292 { 10293 return test_authenticated_decryption(&gcm_test_case_192_7); 10294 } 10295 10296 static int 10297 test_AES_GCM_auth_decryption_test_case_256_1(void) 10298 { 10299 return test_authenticated_decryption(&gcm_test_case_256_1); 10300 } 10301 10302 static int 10303 test_AES_GCM_auth_decryption_test_case_256_2(void) 10304 { 10305 return test_authenticated_decryption(&gcm_test_case_256_2); 10306 } 10307 10308 static int 10309 test_AES_GCM_auth_decryption_test_case_256_3(void) 10310 { 10311 return test_authenticated_decryption(&gcm_test_case_256_3); 10312 } 10313 10314 static int 10315 test_AES_GCM_auth_decryption_test_case_256_4(void) 10316 { 10317 return test_authenticated_decryption(&gcm_test_case_256_4); 10318 } 10319 10320 static int 10321 test_AES_GCM_auth_decryption_test_case_256_5(void) 10322 { 10323 return test_authenticated_decryption(&gcm_test_case_256_5); 10324 } 10325 10326 static int 10327 test_AES_GCM_auth_decryption_test_case_256_6(void) 10328 { 10329 return test_authenticated_decryption(&gcm_test_case_256_6); 10330 } 10331 10332 static int 10333 test_AES_GCM_auth_decryption_test_case_256_7(void) 10334 { 10335 return test_authenticated_decryption(&gcm_test_case_256_7); 10336 } 10337 10338 static int 10339 test_AES_GCM_auth_decryption_test_case_aad_1(void) 10340 { 10341 return test_authenticated_decryption(&gcm_test_case_aad_1); 10342 } 10343 10344 static int 10345 test_AES_GCM_auth_decryption_test_case_aad_2(void) 10346 { 10347 return test_authenticated_decryption(&gcm_test_case_aad_2); 10348 } 10349 10350 static int 10351 test_AES_GCM_auth_decryption_fail_iv_corrupt(void) 10352 { 10353 struct aead_test_data tdata; 10354 int res; 10355 10356 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); 10357 tdata.iv.data[0] += 1; 10358 res = test_authenticated_decryption(&tdata); 10359 if (res == TEST_SKIPPED) 10360 return res; 10361 TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed"); 10362 return TEST_SUCCESS; 10363 } 10364 10365 static int 10366 test_AES_GCM_auth_decryption_fail_in_data_corrupt(void) 10367 { 10368 struct aead_test_data tdata; 10369 int res; 10370 10371 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n"); 10372 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); 10373 tdata.plaintext.data[0] += 1; 10374 res = test_authenticated_decryption(&tdata); 10375 if (res == TEST_SKIPPED) 10376 return res; 10377 TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed"); 10378 return TEST_SUCCESS; 10379 } 10380 10381 static int 10382 test_AES_GCM_auth_decryption_fail_out_data_corrupt(void) 10383 { 10384 struct aead_test_data tdata; 10385 int res; 10386 10387 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); 10388 tdata.ciphertext.data[0] += 1; 10389 res = test_authenticated_decryption(&tdata); 10390 if (res == TEST_SKIPPED) 10391 return res; 10392 TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed"); 10393 return TEST_SUCCESS; 10394 } 10395 10396 static int 10397 test_AES_GCM_auth_decryption_fail_aad_len_corrupt(void) 10398 { 10399 struct aead_test_data tdata; 10400 int res; 10401 10402 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); 10403 tdata.aad.len += 1; 10404 res = test_authenticated_decryption(&tdata); 10405 if (res == TEST_SKIPPED) 10406 return res; 10407 TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed"); 10408 return TEST_SUCCESS; 10409 } 10410 10411 static int 10412 test_AES_GCM_auth_decryption_fail_aad_corrupt(void) 10413 { 10414 struct aead_test_data tdata; 10415 uint8_t aad[gcm_test_case_7.aad.len]; 10416 int res; 10417 10418 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); 10419 memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len); 10420 aad[0] += 1; 10421 tdata.aad.data = aad; 10422 res = test_authenticated_decryption(&tdata); 10423 if (res == TEST_SKIPPED) 10424 return res; 10425 TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed"); 10426 return TEST_SUCCESS; 10427 } 10428 10429 static int 10430 test_AES_GCM_auth_decryption_fail_tag_corrupt(void) 10431 { 10432 struct aead_test_data tdata; 10433 int res; 10434 10435 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data)); 10436 tdata.auth_tag.data[0] += 1; 10437 res = test_authenticated_decryption(&tdata); 10438 if (res == TEST_SKIPPED) 10439 return res; 10440 TEST_ASSERT_EQUAL(res, TEST_FAILED, "authentication not failed"); 10441 return TEST_SUCCESS; 10442 } 10443 10444 static int 10445 test_authenticated_encryption_oop(const struct aead_test_data *tdata) 10446 { 10447 struct crypto_testsuite_params *ts_params = &testsuite_params; 10448 struct crypto_unittest_params *ut_params = &unittest_params; 10449 10450 int retval; 10451 uint8_t *ciphertext, *auth_tag; 10452 uint16_t plaintext_pad_len; 10453 10454 /* Verify the capabilities */ 10455 struct rte_cryptodev_sym_capability_idx cap_idx; 10456 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD; 10457 cap_idx.algo.aead = tdata->algo; 10458 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 10459 &cap_idx) == NULL) 10460 return TEST_SKIPPED; 10461 10462 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 10463 return TEST_SKIPPED; 10464 10465 /* not supported with CPU crypto */ 10466 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 10467 return TEST_SKIPPED; 10468 10469 /* Create AEAD session */ 10470 retval = create_aead_session(ts_params->valid_devs[0], 10471 tdata->algo, 10472 RTE_CRYPTO_AEAD_OP_ENCRYPT, 10473 tdata->key.data, tdata->key.len, 10474 tdata->aad.len, tdata->auth_tag.len, 10475 tdata->iv.len); 10476 if (retval < 0) 10477 return retval; 10478 10479 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 10480 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 10481 10482 /* clear mbuf payload */ 10483 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 10484 rte_pktmbuf_tailroom(ut_params->ibuf)); 10485 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0, 10486 rte_pktmbuf_tailroom(ut_params->obuf)); 10487 10488 /* Create AEAD operation */ 10489 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata); 10490 if (retval < 0) 10491 return retval; 10492 10493 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 10494 10495 ut_params->op->sym->m_src = ut_params->ibuf; 10496 ut_params->op->sym->m_dst = ut_params->obuf; 10497 10498 /* Process crypto operation */ 10499 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], 10500 ut_params->op), "failed to process sym crypto op"); 10501 10502 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 10503 "crypto op processing failed"); 10504 10505 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16); 10506 10507 ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *, 10508 ut_params->op->sym->cipher.data.offset); 10509 auth_tag = ciphertext + plaintext_pad_len; 10510 10511 debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len); 10512 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len); 10513 10514 /* Validate obuf */ 10515 TEST_ASSERT_BUFFERS_ARE_EQUAL( 10516 ciphertext, 10517 tdata->ciphertext.data, 10518 tdata->ciphertext.len, 10519 "Ciphertext data not as expected"); 10520 10521 TEST_ASSERT_BUFFERS_ARE_EQUAL( 10522 auth_tag, 10523 tdata->auth_tag.data, 10524 tdata->auth_tag.len, 10525 "Generated auth tag not as expected"); 10526 10527 return 0; 10528 10529 } 10530 10531 static int 10532 test_AES_GCM_authenticated_encryption_oop_test_case_1(void) 10533 { 10534 return test_authenticated_encryption_oop(&gcm_test_case_5); 10535 } 10536 10537 static int 10538 test_authenticated_decryption_oop(const struct aead_test_data *tdata) 10539 { 10540 struct crypto_testsuite_params *ts_params = &testsuite_params; 10541 struct crypto_unittest_params *ut_params = &unittest_params; 10542 10543 int retval; 10544 uint8_t *plaintext; 10545 10546 /* Verify the capabilities */ 10547 struct rte_cryptodev_sym_capability_idx cap_idx; 10548 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD; 10549 cap_idx.algo.aead = tdata->algo; 10550 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 10551 &cap_idx) == NULL) 10552 return TEST_SKIPPED; 10553 10554 /* not supported with CPU crypto and raw data-path APIs*/ 10555 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO || 10556 global_api_test_type == CRYPTODEV_RAW_API_TEST) 10557 return TEST_SKIPPED; 10558 10559 /* Create AEAD session */ 10560 retval = create_aead_session(ts_params->valid_devs[0], 10561 tdata->algo, 10562 RTE_CRYPTO_AEAD_OP_DECRYPT, 10563 tdata->key.data, tdata->key.len, 10564 tdata->aad.len, tdata->auth_tag.len, 10565 tdata->iv.len); 10566 if (retval < 0) 10567 return retval; 10568 10569 /* alloc mbuf and set payload */ 10570 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 10571 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 10572 10573 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 10574 rte_pktmbuf_tailroom(ut_params->ibuf)); 10575 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0, 10576 rte_pktmbuf_tailroom(ut_params->obuf)); 10577 10578 /* Create AEAD operation */ 10579 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata); 10580 if (retval < 0) 10581 return retval; 10582 10583 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 10584 10585 ut_params->op->sym->m_src = ut_params->ibuf; 10586 ut_params->op->sym->m_dst = ut_params->obuf; 10587 10588 /* Process crypto operation */ 10589 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], 10590 ut_params->op), "failed to process sym crypto op"); 10591 10592 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 10593 "crypto op processing failed"); 10594 10595 plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *, 10596 ut_params->op->sym->cipher.data.offset); 10597 10598 debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len); 10599 10600 /* Validate obuf */ 10601 TEST_ASSERT_BUFFERS_ARE_EQUAL( 10602 plaintext, 10603 tdata->plaintext.data, 10604 tdata->plaintext.len, 10605 "Plaintext data not as expected"); 10606 10607 TEST_ASSERT_EQUAL(ut_params->op->status, 10608 RTE_CRYPTO_OP_STATUS_SUCCESS, 10609 "Authentication failed"); 10610 return 0; 10611 } 10612 10613 static int 10614 test_AES_GCM_authenticated_decryption_oop_test_case_1(void) 10615 { 10616 return test_authenticated_decryption_oop(&gcm_test_case_5); 10617 } 10618 10619 static int 10620 test_authenticated_encryption_sessionless( 10621 const struct aead_test_data *tdata) 10622 { 10623 struct crypto_testsuite_params *ts_params = &testsuite_params; 10624 struct crypto_unittest_params *ut_params = &unittest_params; 10625 10626 int retval; 10627 uint8_t *ciphertext, *auth_tag; 10628 uint16_t plaintext_pad_len; 10629 uint8_t key[tdata->key.len + 1]; 10630 struct rte_cryptodev_info dev_info; 10631 10632 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 10633 uint64_t feat_flags = dev_info.feature_flags; 10634 10635 if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) { 10636 printf("Device doesn't support Sessionless ops.\n"); 10637 return TEST_SKIPPED; 10638 } 10639 10640 /* not supported with CPU crypto */ 10641 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 10642 return TEST_SKIPPED; 10643 10644 /* Verify the capabilities */ 10645 struct rte_cryptodev_sym_capability_idx cap_idx; 10646 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD; 10647 cap_idx.algo.aead = tdata->algo; 10648 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 10649 &cap_idx) == NULL) 10650 return TEST_SKIPPED; 10651 10652 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 10653 10654 /* clear mbuf payload */ 10655 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 10656 rte_pktmbuf_tailroom(ut_params->ibuf)); 10657 10658 /* Create AEAD operation */ 10659 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata); 10660 if (retval < 0) 10661 return retval; 10662 10663 /* Create GCM xform */ 10664 memcpy(key, tdata->key.data, tdata->key.len); 10665 retval = create_aead_xform(ut_params->op, 10666 tdata->algo, 10667 RTE_CRYPTO_AEAD_OP_ENCRYPT, 10668 key, tdata->key.len, 10669 tdata->aad.len, tdata->auth_tag.len, 10670 tdata->iv.len); 10671 if (retval < 0) 10672 return retval; 10673 10674 ut_params->op->sym->m_src = ut_params->ibuf; 10675 10676 TEST_ASSERT_EQUAL(ut_params->op->sess_type, 10677 RTE_CRYPTO_OP_SESSIONLESS, 10678 "crypto op session type not sessionless"); 10679 10680 /* Process crypto operation */ 10681 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], 10682 ut_params->op), "failed to process sym crypto op"); 10683 10684 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process"); 10685 10686 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 10687 "crypto op status not success"); 10688 10689 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16); 10690 10691 ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *, 10692 ut_params->op->sym->cipher.data.offset); 10693 auth_tag = ciphertext + plaintext_pad_len; 10694 10695 debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len); 10696 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len); 10697 10698 /* Validate obuf */ 10699 TEST_ASSERT_BUFFERS_ARE_EQUAL( 10700 ciphertext, 10701 tdata->ciphertext.data, 10702 tdata->ciphertext.len, 10703 "Ciphertext data not as expected"); 10704 10705 TEST_ASSERT_BUFFERS_ARE_EQUAL( 10706 auth_tag, 10707 tdata->auth_tag.data, 10708 tdata->auth_tag.len, 10709 "Generated auth tag not as expected"); 10710 10711 return 0; 10712 10713 } 10714 10715 static int 10716 test_AES_GCM_authenticated_encryption_sessionless_test_case_1(void) 10717 { 10718 return test_authenticated_encryption_sessionless( 10719 &gcm_test_case_5); 10720 } 10721 10722 static int 10723 test_authenticated_decryption_sessionless( 10724 const struct aead_test_data *tdata) 10725 { 10726 struct crypto_testsuite_params *ts_params = &testsuite_params; 10727 struct crypto_unittest_params *ut_params = &unittest_params; 10728 10729 int retval; 10730 uint8_t *plaintext; 10731 uint8_t key[tdata->key.len + 1]; 10732 struct rte_cryptodev_info dev_info; 10733 10734 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 10735 uint64_t feat_flags = dev_info.feature_flags; 10736 10737 if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) { 10738 printf("Device doesn't support Sessionless ops.\n"); 10739 return TEST_SKIPPED; 10740 } 10741 10742 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 10743 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 10744 printf("Device doesn't support RAW data-path APIs.\n"); 10745 return TEST_SKIPPED; 10746 } 10747 10748 /* not supported with CPU crypto */ 10749 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 10750 return TEST_SKIPPED; 10751 10752 /* Verify the capabilities */ 10753 struct rte_cryptodev_sym_capability_idx cap_idx; 10754 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD; 10755 cap_idx.algo.aead = tdata->algo; 10756 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 10757 &cap_idx) == NULL) 10758 return TEST_SKIPPED; 10759 10760 /* alloc mbuf and set payload */ 10761 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 10762 10763 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 10764 rte_pktmbuf_tailroom(ut_params->ibuf)); 10765 10766 /* Create AEAD operation */ 10767 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata); 10768 if (retval < 0) 10769 return retval; 10770 10771 /* Create AEAD xform */ 10772 memcpy(key, tdata->key.data, tdata->key.len); 10773 retval = create_aead_xform(ut_params->op, 10774 tdata->algo, 10775 RTE_CRYPTO_AEAD_OP_DECRYPT, 10776 key, tdata->key.len, 10777 tdata->aad.len, tdata->auth_tag.len, 10778 tdata->iv.len); 10779 if (retval < 0) 10780 return retval; 10781 10782 ut_params->op->sym->m_src = ut_params->ibuf; 10783 10784 TEST_ASSERT_EQUAL(ut_params->op->sess_type, 10785 RTE_CRYPTO_OP_SESSIONLESS, 10786 "crypto op session type not sessionless"); 10787 10788 /* Process crypto operation */ 10789 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 10790 process_sym_raw_dp_op(ts_params->valid_devs[0], 0, 10791 ut_params->op, 0, 0, 0, 0); 10792 else 10793 TEST_ASSERT_NOT_NULL(process_crypto_request( 10794 ts_params->valid_devs[0], ut_params->op), 10795 "failed to process sym crypto op"); 10796 10797 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process"); 10798 10799 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 10800 "crypto op status not success"); 10801 10802 plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *, 10803 ut_params->op->sym->cipher.data.offset); 10804 10805 debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len); 10806 10807 /* Validate obuf */ 10808 TEST_ASSERT_BUFFERS_ARE_EQUAL( 10809 plaintext, 10810 tdata->plaintext.data, 10811 tdata->plaintext.len, 10812 "Plaintext data not as expected"); 10813 10814 TEST_ASSERT_EQUAL(ut_params->op->status, 10815 RTE_CRYPTO_OP_STATUS_SUCCESS, 10816 "Authentication failed"); 10817 return 0; 10818 } 10819 10820 static int 10821 test_AES_GCM_authenticated_decryption_sessionless_test_case_1(void) 10822 { 10823 return test_authenticated_decryption_sessionless( 10824 &gcm_test_case_5); 10825 } 10826 10827 static int 10828 test_AES_CCM_authenticated_encryption_test_case_128_1(void) 10829 { 10830 return test_authenticated_encryption(&ccm_test_case_128_1); 10831 } 10832 10833 static int 10834 test_AES_CCM_authenticated_encryption_test_case_128_2(void) 10835 { 10836 return test_authenticated_encryption(&ccm_test_case_128_2); 10837 } 10838 10839 static int 10840 test_AES_CCM_authenticated_encryption_test_case_128_3(void) 10841 { 10842 return test_authenticated_encryption(&ccm_test_case_128_3); 10843 } 10844 10845 static int 10846 test_AES_CCM_authenticated_decryption_test_case_128_1(void) 10847 { 10848 return test_authenticated_decryption(&ccm_test_case_128_1); 10849 } 10850 10851 static int 10852 test_AES_CCM_authenticated_decryption_test_case_128_2(void) 10853 { 10854 return test_authenticated_decryption(&ccm_test_case_128_2); 10855 } 10856 10857 static int 10858 test_AES_CCM_authenticated_decryption_test_case_128_3(void) 10859 { 10860 return test_authenticated_decryption(&ccm_test_case_128_3); 10861 } 10862 10863 static int 10864 test_AES_CCM_authenticated_encryption_test_case_192_1(void) 10865 { 10866 return test_authenticated_encryption(&ccm_test_case_192_1); 10867 } 10868 10869 static int 10870 test_AES_CCM_authenticated_encryption_test_case_192_2(void) 10871 { 10872 return test_authenticated_encryption(&ccm_test_case_192_2); 10873 } 10874 10875 static int 10876 test_AES_CCM_authenticated_encryption_test_case_192_3(void) 10877 { 10878 return test_authenticated_encryption(&ccm_test_case_192_3); 10879 } 10880 10881 static int 10882 test_AES_CCM_authenticated_decryption_test_case_192_1(void) 10883 { 10884 return test_authenticated_decryption(&ccm_test_case_192_1); 10885 } 10886 10887 static int 10888 test_AES_CCM_authenticated_decryption_test_case_192_2(void) 10889 { 10890 return test_authenticated_decryption(&ccm_test_case_192_2); 10891 } 10892 10893 static int 10894 test_AES_CCM_authenticated_decryption_test_case_192_3(void) 10895 { 10896 return test_authenticated_decryption(&ccm_test_case_192_3); 10897 } 10898 10899 static int 10900 test_AES_CCM_authenticated_encryption_test_case_256_1(void) 10901 { 10902 return test_authenticated_encryption(&ccm_test_case_256_1); 10903 } 10904 10905 static int 10906 test_AES_CCM_authenticated_encryption_test_case_256_2(void) 10907 { 10908 return test_authenticated_encryption(&ccm_test_case_256_2); 10909 } 10910 10911 static int 10912 test_AES_CCM_authenticated_encryption_test_case_256_3(void) 10913 { 10914 return test_authenticated_encryption(&ccm_test_case_256_3); 10915 } 10916 10917 static int 10918 test_AES_CCM_authenticated_decryption_test_case_256_1(void) 10919 { 10920 return test_authenticated_decryption(&ccm_test_case_256_1); 10921 } 10922 10923 static int 10924 test_AES_CCM_authenticated_decryption_test_case_256_2(void) 10925 { 10926 return test_authenticated_decryption(&ccm_test_case_256_2); 10927 } 10928 10929 static int 10930 test_AES_CCM_authenticated_decryption_test_case_256_3(void) 10931 { 10932 return test_authenticated_decryption(&ccm_test_case_256_3); 10933 } 10934 10935 static int 10936 test_stats(void) 10937 { 10938 struct crypto_testsuite_params *ts_params = &testsuite_params; 10939 struct rte_cryptodev_stats stats; 10940 10941 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 10942 return TEST_SKIPPED; 10943 10944 /* Verify the capabilities */ 10945 struct rte_cryptodev_sym_capability_idx cap_idx; 10946 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; 10947 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC; 10948 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 10949 &cap_idx) == NULL) 10950 return TEST_SKIPPED; 10951 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 10952 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC; 10953 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 10954 &cap_idx) == NULL) 10955 return TEST_SKIPPED; 10956 10957 if (rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats) 10958 == -ENOTSUP) 10959 return TEST_SKIPPED; 10960 10961 rte_cryptodev_stats_reset(ts_params->valid_devs[0]); 10962 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600, 10963 &stats) == -ENODEV), 10964 "rte_cryptodev_stats_get invalid dev failed"); 10965 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0), 10966 "rte_cryptodev_stats_get invalid Param failed"); 10967 10968 /* Test expected values */ 10969 test_AES_CBC_HMAC_SHA1_encrypt_digest(); 10970 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0], 10971 &stats), 10972 "rte_cryptodev_stats_get failed"); 10973 TEST_ASSERT((stats.enqueued_count == 1), 10974 "rte_cryptodev_stats_get returned unexpected enqueued stat"); 10975 TEST_ASSERT((stats.dequeued_count == 1), 10976 "rte_cryptodev_stats_get returned unexpected enqueued stat"); 10977 TEST_ASSERT((stats.enqueue_err_count == 0), 10978 "rte_cryptodev_stats_get returned unexpected enqueued stat"); 10979 TEST_ASSERT((stats.dequeue_err_count == 0), 10980 "rte_cryptodev_stats_get returned unexpected enqueued stat"); 10981 10982 /* invalid device but should ignore and not reset device stats*/ 10983 rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300); 10984 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0], 10985 &stats), 10986 "rte_cryptodev_stats_get failed"); 10987 TEST_ASSERT((stats.enqueued_count == 1), 10988 "rte_cryptodev_stats_get returned unexpected enqueued stat"); 10989 10990 /* check that a valid reset clears stats */ 10991 rte_cryptodev_stats_reset(ts_params->valid_devs[0]); 10992 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0], 10993 &stats), 10994 "rte_cryptodev_stats_get failed"); 10995 TEST_ASSERT((stats.enqueued_count == 0), 10996 "rte_cryptodev_stats_get returned unexpected enqueued stat"); 10997 TEST_ASSERT((stats.dequeued_count == 0), 10998 "rte_cryptodev_stats_get returned unexpected enqueued stat"); 10999 11000 return TEST_SUCCESS; 11001 } 11002 11003 static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params, 11004 struct crypto_unittest_params *ut_params, 11005 enum rte_crypto_auth_operation op, 11006 const struct HMAC_MD5_vector *test_case) 11007 { 11008 uint8_t key[64]; 11009 11010 memcpy(key, test_case->key.data, test_case->key.len); 11011 11012 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 11013 ut_params->auth_xform.next = NULL; 11014 ut_params->auth_xform.auth.op = op; 11015 11016 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC; 11017 11018 ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN; 11019 ut_params->auth_xform.auth.key.length = test_case->key.len; 11020 ut_params->auth_xform.auth.key.data = key; 11021 11022 ut_params->sess = rte_cryptodev_sym_session_create( 11023 ts_params->session_mpool); 11024 11025 rte_cryptodev_sym_session_init(ts_params->valid_devs[0], 11026 ut_params->sess, &ut_params->auth_xform, 11027 ts_params->session_priv_mpool); 11028 11029 if (ut_params->sess == NULL) 11030 return TEST_FAILED; 11031 11032 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 11033 11034 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 11035 rte_pktmbuf_tailroom(ut_params->ibuf)); 11036 11037 return 0; 11038 } 11039 11040 static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params, 11041 const struct HMAC_MD5_vector *test_case, 11042 uint8_t **plaintext) 11043 { 11044 uint16_t plaintext_pad_len; 11045 11046 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 11047 11048 plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len, 11049 16); 11050 11051 *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 11052 plaintext_pad_len); 11053 memcpy(*plaintext, test_case->plaintext.data, 11054 test_case->plaintext.len); 11055 11056 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( 11057 ut_params->ibuf, MD5_DIGEST_LEN); 11058 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, 11059 "no room to append digest"); 11060 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( 11061 ut_params->ibuf, plaintext_pad_len); 11062 11063 if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) { 11064 rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data, 11065 test_case->auth_tag.len); 11066 } 11067 11068 sym_op->auth.data.offset = 0; 11069 sym_op->auth.data.length = test_case->plaintext.len; 11070 11071 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 11072 ut_params->op->sym->m_src = ut_params->ibuf; 11073 11074 return 0; 11075 } 11076 11077 static int 11078 test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case) 11079 { 11080 uint16_t plaintext_pad_len; 11081 uint8_t *plaintext, *auth_tag; 11082 11083 struct crypto_testsuite_params *ts_params = &testsuite_params; 11084 struct crypto_unittest_params *ut_params = &unittest_params; 11085 struct rte_cryptodev_info dev_info; 11086 11087 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 11088 uint64_t feat_flags = dev_info.feature_flags; 11089 11090 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 11091 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 11092 printf("Device doesn't support RAW data-path APIs.\n"); 11093 return TEST_SKIPPED; 11094 } 11095 11096 /* Verify the capabilities */ 11097 struct rte_cryptodev_sym_capability_idx cap_idx; 11098 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; 11099 cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC; 11100 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 11101 &cap_idx) == NULL) 11102 return TEST_SKIPPED; 11103 11104 if (MD5_HMAC_create_session(ts_params, ut_params, 11105 RTE_CRYPTO_AUTH_OP_GENERATE, test_case)) 11106 return TEST_FAILED; 11107 11108 /* Generate Crypto op data structure */ 11109 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 11110 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 11111 TEST_ASSERT_NOT_NULL(ut_params->op, 11112 "Failed to allocate symmetric crypto operation struct"); 11113 11114 plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len, 11115 16); 11116 11117 if (MD5_HMAC_create_op(ut_params, test_case, &plaintext)) 11118 return TEST_FAILED; 11119 11120 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 11121 process_cpu_crypt_auth_op(ts_params->valid_devs[0], 11122 ut_params->op); 11123 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 11124 process_sym_raw_dp_op(ts_params->valid_devs[0], 0, 11125 ut_params->op, 0, 1, 0, 0); 11126 else 11127 TEST_ASSERT_NOT_NULL( 11128 process_crypto_request(ts_params->valid_devs[0], 11129 ut_params->op), 11130 "failed to process sym crypto op"); 11131 11132 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 11133 "crypto op processing failed"); 11134 11135 if (ut_params->op->sym->m_dst) { 11136 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst, 11137 uint8_t *, plaintext_pad_len); 11138 } else { 11139 auth_tag = plaintext + plaintext_pad_len; 11140 } 11141 11142 TEST_ASSERT_BUFFERS_ARE_EQUAL( 11143 auth_tag, 11144 test_case->auth_tag.data, 11145 test_case->auth_tag.len, 11146 "HMAC_MD5 generated tag not as expected"); 11147 11148 return TEST_SUCCESS; 11149 } 11150 11151 static int 11152 test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case) 11153 { 11154 uint8_t *plaintext; 11155 11156 struct crypto_testsuite_params *ts_params = &testsuite_params; 11157 struct crypto_unittest_params *ut_params = &unittest_params; 11158 struct rte_cryptodev_info dev_info; 11159 11160 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 11161 uint64_t feat_flags = dev_info.feature_flags; 11162 11163 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 11164 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 11165 printf("Device doesn't support RAW data-path APIs.\n"); 11166 return TEST_SKIPPED; 11167 } 11168 11169 /* Verify the capabilities */ 11170 struct rte_cryptodev_sym_capability_idx cap_idx; 11171 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; 11172 cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC; 11173 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 11174 &cap_idx) == NULL) 11175 return TEST_SKIPPED; 11176 11177 if (MD5_HMAC_create_session(ts_params, ut_params, 11178 RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) { 11179 return TEST_FAILED; 11180 } 11181 11182 /* Generate Crypto op data structure */ 11183 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 11184 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 11185 TEST_ASSERT_NOT_NULL(ut_params->op, 11186 "Failed to allocate symmetric crypto operation struct"); 11187 11188 if (MD5_HMAC_create_op(ut_params, test_case, &plaintext)) 11189 return TEST_FAILED; 11190 11191 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 11192 process_cpu_crypt_auth_op(ts_params->valid_devs[0], 11193 ut_params->op); 11194 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 11195 process_sym_raw_dp_op(ts_params->valid_devs[0], 0, 11196 ut_params->op, 0, 1, 0, 0); 11197 else 11198 TEST_ASSERT_NOT_NULL( 11199 process_crypto_request(ts_params->valid_devs[0], 11200 ut_params->op), 11201 "failed to process sym crypto op"); 11202 11203 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 11204 "HMAC_MD5 crypto op processing failed"); 11205 11206 return TEST_SUCCESS; 11207 } 11208 11209 static int 11210 test_MD5_HMAC_generate_case_1(void) 11211 { 11212 return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1); 11213 } 11214 11215 static int 11216 test_MD5_HMAC_verify_case_1(void) 11217 { 11218 return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1); 11219 } 11220 11221 static int 11222 test_MD5_HMAC_generate_case_2(void) 11223 { 11224 return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2); 11225 } 11226 11227 static int 11228 test_MD5_HMAC_verify_case_2(void) 11229 { 11230 return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2); 11231 } 11232 11233 static int 11234 test_multi_session(void) 11235 { 11236 struct crypto_testsuite_params *ts_params = &testsuite_params; 11237 struct crypto_unittest_params *ut_params = &unittest_params; 11238 11239 struct rte_cryptodev_info dev_info; 11240 struct rte_cryptodev_sym_session **sessions; 11241 11242 uint16_t i; 11243 11244 /* Verify the capabilities */ 11245 struct rte_cryptodev_sym_capability_idx cap_idx; 11246 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; 11247 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC; 11248 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 11249 &cap_idx) == NULL) 11250 return TEST_SKIPPED; 11251 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 11252 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC; 11253 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 11254 &cap_idx) == NULL) 11255 return TEST_SKIPPED; 11256 11257 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params, 11258 aes_cbc_key, hmac_sha512_key); 11259 11260 11261 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 11262 11263 sessions = rte_malloc(NULL, 11264 sizeof(struct rte_cryptodev_sym_session *) * 11265 (MAX_NB_SESSIONS + 1), 0); 11266 11267 /* Create multiple crypto sessions*/ 11268 for (i = 0; i < MAX_NB_SESSIONS; i++) { 11269 11270 sessions[i] = rte_cryptodev_sym_session_create( 11271 ts_params->session_mpool); 11272 11273 rte_cryptodev_sym_session_init(ts_params->valid_devs[0], 11274 sessions[i], &ut_params->auth_xform, 11275 ts_params->session_priv_mpool); 11276 TEST_ASSERT_NOT_NULL(sessions[i], 11277 "Session creation failed at session number %u", 11278 i); 11279 11280 /* Attempt to send a request on each session */ 11281 TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform( 11282 sessions[i], 11283 ut_params, 11284 ts_params, 11285 catch_22_quote_2_512_bytes_AES_CBC_ciphertext, 11286 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest, 11287 aes_cbc_iv), 11288 "Failed to perform decrypt on request number %u.", i); 11289 /* free crypto operation structure */ 11290 if (ut_params->op) 11291 rte_crypto_op_free(ut_params->op); 11292 11293 /* 11294 * free mbuf - both obuf and ibuf are usually the same, 11295 * so check if they point at the same address is necessary, 11296 * to avoid freeing the mbuf twice. 11297 */ 11298 if (ut_params->obuf) { 11299 rte_pktmbuf_free(ut_params->obuf); 11300 if (ut_params->ibuf == ut_params->obuf) 11301 ut_params->ibuf = 0; 11302 ut_params->obuf = 0; 11303 } 11304 if (ut_params->ibuf) { 11305 rte_pktmbuf_free(ut_params->ibuf); 11306 ut_params->ibuf = 0; 11307 } 11308 } 11309 11310 sessions[i] = NULL; 11311 /* Next session create should fail */ 11312 rte_cryptodev_sym_session_init(ts_params->valid_devs[0], 11313 sessions[i], &ut_params->auth_xform, 11314 ts_params->session_priv_mpool); 11315 TEST_ASSERT_NULL(sessions[i], 11316 "Session creation succeeded unexpectedly!"); 11317 11318 for (i = 0; i < MAX_NB_SESSIONS; i++) { 11319 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0], 11320 sessions[i]); 11321 rte_cryptodev_sym_session_free(sessions[i]); 11322 } 11323 11324 rte_free(sessions); 11325 11326 return TEST_SUCCESS; 11327 } 11328 11329 struct multi_session_params { 11330 struct crypto_unittest_params ut_params; 11331 uint8_t *cipher_key; 11332 uint8_t *hmac_key; 11333 const uint8_t *cipher; 11334 const uint8_t *digest; 11335 uint8_t *iv; 11336 }; 11337 11338 #define MB_SESSION_NUMBER 3 11339 11340 static int 11341 test_multi_session_random_usage(void) 11342 { 11343 struct crypto_testsuite_params *ts_params = &testsuite_params; 11344 struct rte_cryptodev_info dev_info; 11345 struct rte_cryptodev_sym_session **sessions; 11346 uint32_t i, j; 11347 struct multi_session_params ut_paramz[] = { 11348 11349 { 11350 .cipher_key = ms_aes_cbc_key0, 11351 .hmac_key = ms_hmac_key0, 11352 .cipher = ms_aes_cbc_cipher0, 11353 .digest = ms_hmac_digest0, 11354 .iv = ms_aes_cbc_iv0 11355 }, 11356 { 11357 .cipher_key = ms_aes_cbc_key1, 11358 .hmac_key = ms_hmac_key1, 11359 .cipher = ms_aes_cbc_cipher1, 11360 .digest = ms_hmac_digest1, 11361 .iv = ms_aes_cbc_iv1 11362 }, 11363 { 11364 .cipher_key = ms_aes_cbc_key2, 11365 .hmac_key = ms_hmac_key2, 11366 .cipher = ms_aes_cbc_cipher2, 11367 .digest = ms_hmac_digest2, 11368 .iv = ms_aes_cbc_iv2 11369 }, 11370 11371 }; 11372 11373 /* Verify the capabilities */ 11374 struct rte_cryptodev_sym_capability_idx cap_idx; 11375 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; 11376 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC; 11377 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 11378 &cap_idx) == NULL) 11379 return TEST_SKIPPED; 11380 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 11381 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC; 11382 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 11383 &cap_idx) == NULL) 11384 return TEST_SKIPPED; 11385 11386 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 11387 11388 sessions = rte_malloc(NULL, 11389 (sizeof(struct rte_cryptodev_sym_session *) 11390 * MAX_NB_SESSIONS) + 1, 0); 11391 11392 for (i = 0; i < MB_SESSION_NUMBER; i++) { 11393 sessions[i] = rte_cryptodev_sym_session_create( 11394 ts_params->session_mpool); 11395 11396 rte_memcpy(&ut_paramz[i].ut_params, &unittest_params, 11397 sizeof(struct crypto_unittest_params)); 11398 11399 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params( 11400 &ut_paramz[i].ut_params, 11401 ut_paramz[i].cipher_key, ut_paramz[i].hmac_key); 11402 11403 /* Create multiple crypto sessions*/ 11404 rte_cryptodev_sym_session_init( 11405 ts_params->valid_devs[0], 11406 sessions[i], 11407 &ut_paramz[i].ut_params.auth_xform, 11408 ts_params->session_priv_mpool); 11409 11410 TEST_ASSERT_NOT_NULL(sessions[i], 11411 "Session creation failed at session number %u", 11412 i); 11413 11414 } 11415 11416 srand(time(NULL)); 11417 for (i = 0; i < 40000; i++) { 11418 11419 j = rand() % MB_SESSION_NUMBER; 11420 11421 TEST_ASSERT_SUCCESS( 11422 test_AES_CBC_HMAC_SHA512_decrypt_perform( 11423 sessions[j], 11424 &ut_paramz[j].ut_params, 11425 ts_params, ut_paramz[j].cipher, 11426 ut_paramz[j].digest, 11427 ut_paramz[j].iv), 11428 "Failed to perform decrypt on request number %u.", i); 11429 11430 if (ut_paramz[j].ut_params.op) 11431 rte_crypto_op_free(ut_paramz[j].ut_params.op); 11432 11433 /* 11434 * free mbuf - both obuf and ibuf are usually the same, 11435 * so check if they point at the same address is necessary, 11436 * to avoid freeing the mbuf twice. 11437 */ 11438 if (ut_paramz[j].ut_params.obuf) { 11439 rte_pktmbuf_free(ut_paramz[j].ut_params.obuf); 11440 if (ut_paramz[j].ut_params.ibuf 11441 == ut_paramz[j].ut_params.obuf) 11442 ut_paramz[j].ut_params.ibuf = 0; 11443 ut_paramz[j].ut_params.obuf = 0; 11444 } 11445 if (ut_paramz[j].ut_params.ibuf) { 11446 rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf); 11447 ut_paramz[j].ut_params.ibuf = 0; 11448 } 11449 } 11450 11451 for (i = 0; i < MB_SESSION_NUMBER; i++) { 11452 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0], 11453 sessions[i]); 11454 rte_cryptodev_sym_session_free(sessions[i]); 11455 } 11456 11457 rte_free(sessions); 11458 11459 return TEST_SUCCESS; 11460 } 11461 11462 uint8_t orig_data[] = {0xab, 0xab, 0xab, 0xab, 11463 0xab, 0xab, 0xab, 0xab, 11464 0xab, 0xab, 0xab, 0xab, 11465 0xab, 0xab, 0xab, 0xab}; 11466 11467 static int 11468 test_null_invalid_operation(void) 11469 { 11470 struct crypto_testsuite_params *ts_params = &testsuite_params; 11471 struct crypto_unittest_params *ut_params = &unittest_params; 11472 int ret; 11473 11474 /* This test is for NULL PMD only */ 11475 if (gbl_driver_id != rte_cryptodev_driver_id_get( 11476 RTE_STR(CRYPTODEV_NAME_NULL_PMD))) 11477 return TEST_SKIPPED; 11478 11479 /* Setup Cipher Parameters */ 11480 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 11481 ut_params->cipher_xform.next = NULL; 11482 11483 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC; 11484 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; 11485 11486 ut_params->sess = rte_cryptodev_sym_session_create( 11487 ts_params->session_mpool); 11488 11489 /* Create Crypto session*/ 11490 ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0], 11491 ut_params->sess, &ut_params->cipher_xform, 11492 ts_params->session_priv_mpool); 11493 TEST_ASSERT(ret < 0, 11494 "Session creation succeeded unexpectedly"); 11495 11496 11497 /* Setup HMAC Parameters */ 11498 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 11499 ut_params->auth_xform.next = NULL; 11500 11501 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC; 11502 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; 11503 11504 ut_params->sess = rte_cryptodev_sym_session_create( 11505 ts_params->session_mpool); 11506 11507 /* Create Crypto session*/ 11508 ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0], 11509 ut_params->sess, &ut_params->auth_xform, 11510 ts_params->session_priv_mpool); 11511 TEST_ASSERT(ret < 0, 11512 "Session creation succeeded unexpectedly"); 11513 11514 return TEST_SUCCESS; 11515 } 11516 11517 11518 #define NULL_BURST_LENGTH (32) 11519 11520 static int 11521 test_null_burst_operation(void) 11522 { 11523 struct crypto_testsuite_params *ts_params = &testsuite_params; 11524 struct crypto_unittest_params *ut_params = &unittest_params; 11525 11526 unsigned i, burst_len = NULL_BURST_LENGTH; 11527 11528 struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL }; 11529 struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL }; 11530 11531 /* This test is for NULL PMD only */ 11532 if (gbl_driver_id != rte_cryptodev_driver_id_get( 11533 RTE_STR(CRYPTODEV_NAME_NULL_PMD))) 11534 return TEST_SKIPPED; 11535 11536 /* Setup Cipher Parameters */ 11537 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 11538 ut_params->cipher_xform.next = &ut_params->auth_xform; 11539 11540 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL; 11541 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; 11542 11543 /* Setup HMAC Parameters */ 11544 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 11545 ut_params->auth_xform.next = NULL; 11546 11547 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL; 11548 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; 11549 11550 ut_params->sess = rte_cryptodev_sym_session_create( 11551 ts_params->session_mpool); 11552 11553 /* Create Crypto session*/ 11554 rte_cryptodev_sym_session_init(ts_params->valid_devs[0], 11555 ut_params->sess, &ut_params->cipher_xform, 11556 ts_params->session_priv_mpool); 11557 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 11558 11559 TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool, 11560 RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len), 11561 burst_len, "failed to generate burst of crypto ops"); 11562 11563 /* Generate an operation for each mbuf in burst */ 11564 for (i = 0; i < burst_len; i++) { 11565 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool); 11566 11567 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf"); 11568 11569 unsigned *data = (unsigned *)rte_pktmbuf_append(m, 11570 sizeof(unsigned)); 11571 *data = i; 11572 11573 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess); 11574 11575 burst[i]->sym->m_src = m; 11576 } 11577 11578 /* Process crypto operation */ 11579 TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0], 11580 0, burst, burst_len), 11581 burst_len, 11582 "Error enqueuing burst"); 11583 11584 TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0], 11585 0, burst_dequeued, burst_len), 11586 burst_len, 11587 "Error dequeuing burst"); 11588 11589 11590 for (i = 0; i < burst_len; i++) { 11591 TEST_ASSERT_EQUAL( 11592 *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *), 11593 *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src, 11594 uint32_t *), 11595 "data not as expected"); 11596 11597 rte_pktmbuf_free(burst[i]->sym->m_src); 11598 rte_crypto_op_free(burst[i]); 11599 } 11600 11601 return TEST_SUCCESS; 11602 } 11603 11604 static uint16_t 11605 test_enq_callback(uint16_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops, 11606 uint16_t nb_ops, void *user_param) 11607 { 11608 RTE_SET_USED(dev_id); 11609 RTE_SET_USED(qp_id); 11610 RTE_SET_USED(ops); 11611 RTE_SET_USED(user_param); 11612 11613 printf("crypto enqueue callback called\n"); 11614 return nb_ops; 11615 } 11616 11617 static uint16_t 11618 test_deq_callback(uint16_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops, 11619 uint16_t nb_ops, void *user_param) 11620 { 11621 RTE_SET_USED(dev_id); 11622 RTE_SET_USED(qp_id); 11623 RTE_SET_USED(ops); 11624 RTE_SET_USED(user_param); 11625 11626 printf("crypto dequeue callback called\n"); 11627 return nb_ops; 11628 } 11629 11630 /* 11631 * Thread using enqueue/dequeue callback with RCU. 11632 */ 11633 static int 11634 test_enqdeq_callback_thread(void *arg) 11635 { 11636 RTE_SET_USED(arg); 11637 /* DP thread calls rte_cryptodev_enqueue_burst()/ 11638 * rte_cryptodev_dequeue_burst() and invokes callback. 11639 */ 11640 test_null_burst_operation(); 11641 return 0; 11642 } 11643 11644 static int 11645 test_enq_callback_setup(void) 11646 { 11647 struct crypto_testsuite_params *ts_params = &testsuite_params; 11648 struct rte_cryptodev_info dev_info; 11649 struct rte_cryptodev_qp_conf qp_conf = { 11650 .nb_descriptors = MAX_NUM_OPS_INFLIGHT 11651 }; 11652 11653 struct rte_cryptodev_cb *cb; 11654 uint16_t qp_id = 0; 11655 11656 /* Stop the device in case it's started so it can be configured */ 11657 rte_cryptodev_stop(ts_params->valid_devs[0]); 11658 11659 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 11660 11661 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0], 11662 &ts_params->conf), 11663 "Failed to configure cryptodev %u", 11664 ts_params->valid_devs[0]); 11665 11666 qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; 11667 qp_conf.mp_session = ts_params->session_mpool; 11668 qp_conf.mp_session_private = ts_params->session_priv_mpool; 11669 11670 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( 11671 ts_params->valid_devs[0], qp_id, &qp_conf, 11672 rte_cryptodev_socket_id(ts_params->valid_devs[0])), 11673 "Failed test for " 11674 "rte_cryptodev_queue_pair_setup: num_inflights " 11675 "%u on qp %u on cryptodev %u", 11676 qp_conf.nb_descriptors, qp_id, 11677 ts_params->valid_devs[0]); 11678 11679 /* Test with invalid crypto device */ 11680 cb = rte_cryptodev_add_enq_callback(RTE_CRYPTO_MAX_DEVS, 11681 qp_id, test_enq_callback, NULL); 11682 TEST_ASSERT_NULL(cb, "Add callback on qp %u on " 11683 "cryptodev %u did not fail", 11684 qp_id, RTE_CRYPTO_MAX_DEVS); 11685 11686 /* Test with invalid queue pair */ 11687 cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0], 11688 dev_info.max_nb_queue_pairs + 1, 11689 test_enq_callback, NULL); 11690 TEST_ASSERT_NULL(cb, "Add callback on qp %u on " 11691 "cryptodev %u did not fail", 11692 dev_info.max_nb_queue_pairs + 1, 11693 ts_params->valid_devs[0]); 11694 11695 /* Test with NULL callback */ 11696 cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0], 11697 qp_id, NULL, NULL); 11698 TEST_ASSERT_NULL(cb, "Add callback on qp %u on " 11699 "cryptodev %u did not fail", 11700 qp_id, ts_params->valid_devs[0]); 11701 11702 /* Test with valid configuration */ 11703 cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0], 11704 qp_id, test_enq_callback, NULL); 11705 TEST_ASSERT_NOT_NULL(cb, "Failed test to add callback on " 11706 "qp %u on cryptodev %u", 11707 qp_id, ts_params->valid_devs[0]); 11708 11709 rte_cryptodev_start(ts_params->valid_devs[0]); 11710 11711 /* Launch a thread */ 11712 rte_eal_remote_launch(test_enqdeq_callback_thread, NULL, 11713 rte_get_next_lcore(-1, 1, 0)); 11714 11715 /* Wait until reader exited. */ 11716 rte_eal_mp_wait_lcore(); 11717 11718 /* Test with invalid crypto device */ 11719 TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback( 11720 RTE_CRYPTO_MAX_DEVS, qp_id, cb), 11721 "Expected call to fail as crypto device is invalid"); 11722 11723 /* Test with invalid queue pair */ 11724 TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback( 11725 ts_params->valid_devs[0], 11726 dev_info.max_nb_queue_pairs + 1, cb), 11727 "Expected call to fail as queue pair is invalid"); 11728 11729 /* Test with NULL callback */ 11730 TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback( 11731 ts_params->valid_devs[0], qp_id, NULL), 11732 "Expected call to fail as callback is NULL"); 11733 11734 /* Test with valid configuration */ 11735 TEST_ASSERT_SUCCESS(rte_cryptodev_remove_enq_callback( 11736 ts_params->valid_devs[0], qp_id, cb), 11737 "Failed test to remove callback on " 11738 "qp %u on cryptodev %u", 11739 qp_id, ts_params->valid_devs[0]); 11740 11741 return TEST_SUCCESS; 11742 } 11743 11744 static int 11745 test_deq_callback_setup(void) 11746 { 11747 struct crypto_testsuite_params *ts_params = &testsuite_params; 11748 struct rte_cryptodev_info dev_info; 11749 struct rte_cryptodev_qp_conf qp_conf = { 11750 .nb_descriptors = MAX_NUM_OPS_INFLIGHT 11751 }; 11752 11753 struct rte_cryptodev_cb *cb; 11754 uint16_t qp_id = 0; 11755 11756 /* Stop the device in case it's started so it can be configured */ 11757 rte_cryptodev_stop(ts_params->valid_devs[0]); 11758 11759 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 11760 11761 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0], 11762 &ts_params->conf), 11763 "Failed to configure cryptodev %u", 11764 ts_params->valid_devs[0]); 11765 11766 qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; 11767 qp_conf.mp_session = ts_params->session_mpool; 11768 qp_conf.mp_session_private = ts_params->session_priv_mpool; 11769 11770 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup( 11771 ts_params->valid_devs[0], qp_id, &qp_conf, 11772 rte_cryptodev_socket_id(ts_params->valid_devs[0])), 11773 "Failed test for " 11774 "rte_cryptodev_queue_pair_setup: num_inflights " 11775 "%u on qp %u on cryptodev %u", 11776 qp_conf.nb_descriptors, qp_id, 11777 ts_params->valid_devs[0]); 11778 11779 /* Test with invalid crypto device */ 11780 cb = rte_cryptodev_add_deq_callback(RTE_CRYPTO_MAX_DEVS, 11781 qp_id, test_deq_callback, NULL); 11782 TEST_ASSERT_NULL(cb, "Add callback on qp %u on " 11783 "cryptodev %u did not fail", 11784 qp_id, RTE_CRYPTO_MAX_DEVS); 11785 11786 /* Test with invalid queue pair */ 11787 cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0], 11788 dev_info.max_nb_queue_pairs + 1, 11789 test_deq_callback, NULL); 11790 TEST_ASSERT_NULL(cb, "Add callback on qp %u on " 11791 "cryptodev %u did not fail", 11792 dev_info.max_nb_queue_pairs + 1, 11793 ts_params->valid_devs[0]); 11794 11795 /* Test with NULL callback */ 11796 cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0], 11797 qp_id, NULL, NULL); 11798 TEST_ASSERT_NULL(cb, "Add callback on qp %u on " 11799 "cryptodev %u did not fail", 11800 qp_id, ts_params->valid_devs[0]); 11801 11802 /* Test with valid configuration */ 11803 cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0], 11804 qp_id, test_deq_callback, NULL); 11805 TEST_ASSERT_NOT_NULL(cb, "Failed test to add callback on " 11806 "qp %u on cryptodev %u", 11807 qp_id, ts_params->valid_devs[0]); 11808 11809 rte_cryptodev_start(ts_params->valid_devs[0]); 11810 11811 /* Launch a thread */ 11812 rte_eal_remote_launch(test_enqdeq_callback_thread, NULL, 11813 rte_get_next_lcore(-1, 1, 0)); 11814 11815 /* Wait until reader exited. */ 11816 rte_eal_mp_wait_lcore(); 11817 11818 /* Test with invalid crypto device */ 11819 TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback( 11820 RTE_CRYPTO_MAX_DEVS, qp_id, cb), 11821 "Expected call to fail as crypto device is invalid"); 11822 11823 /* Test with invalid queue pair */ 11824 TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback( 11825 ts_params->valid_devs[0], 11826 dev_info.max_nb_queue_pairs + 1, cb), 11827 "Expected call to fail as queue pair is invalid"); 11828 11829 /* Test with NULL callback */ 11830 TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback( 11831 ts_params->valid_devs[0], qp_id, NULL), 11832 "Expected call to fail as callback is NULL"); 11833 11834 /* Test with valid configuration */ 11835 TEST_ASSERT_SUCCESS(rte_cryptodev_remove_deq_callback( 11836 ts_params->valid_devs[0], qp_id, cb), 11837 "Failed test to remove callback on " 11838 "qp %u on cryptodev %u", 11839 qp_id, ts_params->valid_devs[0]); 11840 11841 return TEST_SUCCESS; 11842 } 11843 11844 static void 11845 generate_gmac_large_plaintext(uint8_t *data) 11846 { 11847 uint16_t i; 11848 11849 for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32) 11850 memcpy(&data[i], &data[0], 32); 11851 } 11852 11853 static int 11854 create_gmac_operation(enum rte_crypto_auth_operation op, 11855 const struct gmac_test_data *tdata) 11856 { 11857 struct crypto_testsuite_params *ts_params = &testsuite_params; 11858 struct crypto_unittest_params *ut_params = &unittest_params; 11859 struct rte_crypto_sym_op *sym_op; 11860 11861 uint32_t plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16); 11862 11863 /* Generate Crypto op data structure */ 11864 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 11865 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 11866 TEST_ASSERT_NOT_NULL(ut_params->op, 11867 "Failed to allocate symmetric crypto operation struct"); 11868 11869 sym_op = ut_params->op->sym; 11870 11871 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( 11872 ut_params->ibuf, tdata->gmac_tag.len); 11873 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, 11874 "no room to append digest"); 11875 11876 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( 11877 ut_params->ibuf, plaintext_pad_len); 11878 11879 if (op == RTE_CRYPTO_AUTH_OP_VERIFY) { 11880 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data, 11881 tdata->gmac_tag.len); 11882 debug_hexdump(stdout, "digest:", 11883 sym_op->auth.digest.data, 11884 tdata->gmac_tag.len); 11885 } 11886 11887 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, 11888 uint8_t *, IV_OFFSET); 11889 11890 rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len); 11891 11892 debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len); 11893 11894 sym_op->cipher.data.length = 0; 11895 sym_op->cipher.data.offset = 0; 11896 11897 sym_op->auth.data.offset = 0; 11898 sym_op->auth.data.length = tdata->plaintext.len; 11899 11900 return 0; 11901 } 11902 11903 static int 11904 create_gmac_operation_sgl(enum rte_crypto_auth_operation op, 11905 const struct gmac_test_data *tdata, 11906 void *digest_mem, uint64_t digest_phys) 11907 { 11908 struct crypto_testsuite_params *ts_params = &testsuite_params; 11909 struct crypto_unittest_params *ut_params = &unittest_params; 11910 struct rte_crypto_sym_op *sym_op; 11911 11912 /* Generate Crypto op data structure */ 11913 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 11914 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 11915 TEST_ASSERT_NOT_NULL(ut_params->op, 11916 "Failed to allocate symmetric crypto operation struct"); 11917 11918 sym_op = ut_params->op->sym; 11919 11920 sym_op->auth.digest.data = digest_mem; 11921 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, 11922 "no room to append digest"); 11923 11924 sym_op->auth.digest.phys_addr = digest_phys; 11925 11926 if (op == RTE_CRYPTO_AUTH_OP_VERIFY) { 11927 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data, 11928 tdata->gmac_tag.len); 11929 debug_hexdump(stdout, "digest:", 11930 sym_op->auth.digest.data, 11931 tdata->gmac_tag.len); 11932 } 11933 11934 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, 11935 uint8_t *, IV_OFFSET); 11936 11937 rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len); 11938 11939 debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len); 11940 11941 sym_op->cipher.data.length = 0; 11942 sym_op->cipher.data.offset = 0; 11943 11944 sym_op->auth.data.offset = 0; 11945 sym_op->auth.data.length = tdata->plaintext.len; 11946 11947 return 0; 11948 } 11949 11950 static int create_gmac_session(uint8_t dev_id, 11951 const struct gmac_test_data *tdata, 11952 enum rte_crypto_auth_operation auth_op) 11953 { 11954 uint8_t auth_key[tdata->key.len]; 11955 11956 struct crypto_testsuite_params *ts_params = &testsuite_params; 11957 struct crypto_unittest_params *ut_params = &unittest_params; 11958 11959 memcpy(auth_key, tdata->key.data, tdata->key.len); 11960 11961 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 11962 ut_params->auth_xform.next = NULL; 11963 11964 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC; 11965 ut_params->auth_xform.auth.op = auth_op; 11966 ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len; 11967 ut_params->auth_xform.auth.key.length = tdata->key.len; 11968 ut_params->auth_xform.auth.key.data = auth_key; 11969 ut_params->auth_xform.auth.iv.offset = IV_OFFSET; 11970 ut_params->auth_xform.auth.iv.length = tdata->iv.len; 11971 11972 11973 ut_params->sess = rte_cryptodev_sym_session_create( 11974 ts_params->session_mpool); 11975 11976 rte_cryptodev_sym_session_init(dev_id, ut_params->sess, 11977 &ut_params->auth_xform, 11978 ts_params->session_priv_mpool); 11979 11980 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 11981 11982 return 0; 11983 } 11984 11985 static int 11986 test_AES_GMAC_authentication(const struct gmac_test_data *tdata) 11987 { 11988 struct crypto_testsuite_params *ts_params = &testsuite_params; 11989 struct crypto_unittest_params *ut_params = &unittest_params; 11990 struct rte_cryptodev_info dev_info; 11991 11992 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 11993 uint64_t feat_flags = dev_info.feature_flags; 11994 11995 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 11996 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 11997 printf("Device doesn't support RAW data-path APIs.\n"); 11998 return TEST_SKIPPED; 11999 } 12000 12001 int retval; 12002 12003 uint8_t *auth_tag, *plaintext; 12004 uint16_t plaintext_pad_len; 12005 12006 TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0, 12007 "No GMAC length in the source data"); 12008 12009 /* Verify the capabilities */ 12010 struct rte_cryptodev_sym_capability_idx cap_idx; 12011 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; 12012 cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC; 12013 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 12014 &cap_idx) == NULL) 12015 return TEST_SKIPPED; 12016 12017 retval = create_gmac_session(ts_params->valid_devs[0], 12018 tdata, RTE_CRYPTO_AUTH_OP_GENERATE); 12019 12020 if (retval < 0) 12021 return retval; 12022 12023 if (tdata->plaintext.len > MBUF_SIZE) 12024 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool); 12025 else 12026 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 12027 TEST_ASSERT_NOT_NULL(ut_params->ibuf, 12028 "Failed to allocate input buffer in mempool"); 12029 12030 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 12031 rte_pktmbuf_tailroom(ut_params->ibuf)); 12032 12033 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16); 12034 /* 12035 * Runtime generate the large plain text instead of use hard code 12036 * plain text vector. It is done to avoid create huge source file 12037 * with the test vector. 12038 */ 12039 if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH) 12040 generate_gmac_large_plaintext(tdata->plaintext.data); 12041 12042 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 12043 plaintext_pad_len); 12044 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext"); 12045 12046 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len); 12047 debug_hexdump(stdout, "plaintext:", plaintext, 12048 tdata->plaintext.len); 12049 12050 retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE, 12051 tdata); 12052 12053 if (retval < 0) 12054 return retval; 12055 12056 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 12057 12058 ut_params->op->sym->m_src = ut_params->ibuf; 12059 12060 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 12061 process_cpu_crypt_auth_op(ts_params->valid_devs[0], 12062 ut_params->op); 12063 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 12064 process_sym_raw_dp_op(ts_params->valid_devs[0], 0, 12065 ut_params->op, 0, 1, 0, 0); 12066 else 12067 TEST_ASSERT_NOT_NULL( 12068 process_crypto_request(ts_params->valid_devs[0], 12069 ut_params->op), "failed to process sym crypto op"); 12070 12071 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 12072 "crypto op processing failed"); 12073 12074 if (ut_params->op->sym->m_dst) { 12075 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst, 12076 uint8_t *, plaintext_pad_len); 12077 } else { 12078 auth_tag = plaintext + plaintext_pad_len; 12079 } 12080 12081 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len); 12082 12083 TEST_ASSERT_BUFFERS_ARE_EQUAL( 12084 auth_tag, 12085 tdata->gmac_tag.data, 12086 tdata->gmac_tag.len, 12087 "GMAC Generated auth tag not as expected"); 12088 12089 return 0; 12090 } 12091 12092 static int 12093 test_AES_GMAC_authentication_test_case_1(void) 12094 { 12095 return test_AES_GMAC_authentication(&gmac_test_case_1); 12096 } 12097 12098 static int 12099 test_AES_GMAC_authentication_test_case_2(void) 12100 { 12101 return test_AES_GMAC_authentication(&gmac_test_case_2); 12102 } 12103 12104 static int 12105 test_AES_GMAC_authentication_test_case_3(void) 12106 { 12107 return test_AES_GMAC_authentication(&gmac_test_case_3); 12108 } 12109 12110 static int 12111 test_AES_GMAC_authentication_test_case_4(void) 12112 { 12113 return test_AES_GMAC_authentication(&gmac_test_case_4); 12114 } 12115 12116 static int 12117 test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata) 12118 { 12119 struct crypto_testsuite_params *ts_params = &testsuite_params; 12120 struct crypto_unittest_params *ut_params = &unittest_params; 12121 int retval; 12122 uint32_t plaintext_pad_len; 12123 uint8_t *plaintext; 12124 struct rte_cryptodev_info dev_info; 12125 12126 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 12127 uint64_t feat_flags = dev_info.feature_flags; 12128 12129 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 12130 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 12131 printf("Device doesn't support RAW data-path APIs.\n"); 12132 return TEST_SKIPPED; 12133 } 12134 12135 TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0, 12136 "No GMAC length in the source data"); 12137 12138 /* Verify the capabilities */ 12139 struct rte_cryptodev_sym_capability_idx cap_idx; 12140 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; 12141 cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC; 12142 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 12143 &cap_idx) == NULL) 12144 return TEST_SKIPPED; 12145 12146 retval = create_gmac_session(ts_params->valid_devs[0], 12147 tdata, RTE_CRYPTO_AUTH_OP_VERIFY); 12148 12149 if (retval < 0) 12150 return retval; 12151 12152 if (tdata->plaintext.len > MBUF_SIZE) 12153 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool); 12154 else 12155 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 12156 TEST_ASSERT_NOT_NULL(ut_params->ibuf, 12157 "Failed to allocate input buffer in mempool"); 12158 12159 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 12160 rte_pktmbuf_tailroom(ut_params->ibuf)); 12161 12162 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16); 12163 12164 /* 12165 * Runtime generate the large plain text instead of use hard code 12166 * plain text vector. It is done to avoid create huge source file 12167 * with the test vector. 12168 */ 12169 if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH) 12170 generate_gmac_large_plaintext(tdata->plaintext.data); 12171 12172 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 12173 plaintext_pad_len); 12174 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext"); 12175 12176 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len); 12177 debug_hexdump(stdout, "plaintext:", plaintext, 12178 tdata->plaintext.len); 12179 12180 retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY, 12181 tdata); 12182 12183 if (retval < 0) 12184 return retval; 12185 12186 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 12187 12188 ut_params->op->sym->m_src = ut_params->ibuf; 12189 12190 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 12191 process_cpu_crypt_auth_op(ts_params->valid_devs[0], 12192 ut_params->op); 12193 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 12194 process_sym_raw_dp_op(ts_params->valid_devs[0], 0, 12195 ut_params->op, 0, 1, 0, 0); 12196 else 12197 TEST_ASSERT_NOT_NULL( 12198 process_crypto_request(ts_params->valid_devs[0], 12199 ut_params->op), "failed to process sym crypto op"); 12200 12201 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 12202 "crypto op processing failed"); 12203 12204 return 0; 12205 12206 } 12207 12208 static int 12209 test_AES_GMAC_authentication_verify_test_case_1(void) 12210 { 12211 return test_AES_GMAC_authentication_verify(&gmac_test_case_1); 12212 } 12213 12214 static int 12215 test_AES_GMAC_authentication_verify_test_case_2(void) 12216 { 12217 return test_AES_GMAC_authentication_verify(&gmac_test_case_2); 12218 } 12219 12220 static int 12221 test_AES_GMAC_authentication_verify_test_case_3(void) 12222 { 12223 return test_AES_GMAC_authentication_verify(&gmac_test_case_3); 12224 } 12225 12226 static int 12227 test_AES_GMAC_authentication_verify_test_case_4(void) 12228 { 12229 return test_AES_GMAC_authentication_verify(&gmac_test_case_4); 12230 } 12231 12232 static int 12233 test_AES_GMAC_authentication_SGL(const struct gmac_test_data *tdata, 12234 uint32_t fragsz) 12235 { 12236 struct crypto_testsuite_params *ts_params = &testsuite_params; 12237 struct crypto_unittest_params *ut_params = &unittest_params; 12238 struct rte_cryptodev_info dev_info; 12239 uint64_t feature_flags; 12240 unsigned int trn_data = 0; 12241 void *digest_mem = NULL; 12242 uint32_t segs = 1; 12243 unsigned int to_trn = 0; 12244 struct rte_mbuf *buf = NULL; 12245 uint8_t *auth_tag, *plaintext; 12246 int retval; 12247 12248 TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0, 12249 "No GMAC length in the source data"); 12250 12251 /* Verify the capabilities */ 12252 struct rte_cryptodev_sym_capability_idx cap_idx; 12253 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; 12254 cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC; 12255 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 12256 &cap_idx) == NULL) 12257 return TEST_SKIPPED; 12258 12259 /* Check for any input SGL support */ 12260 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 12261 feature_flags = dev_info.feature_flags; 12262 12263 if ((!(feature_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) || 12264 (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT)) || 12265 (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT))) 12266 return TEST_SKIPPED; 12267 12268 if (fragsz > tdata->plaintext.len) 12269 fragsz = tdata->plaintext.len; 12270 12271 uint16_t plaintext_len = fragsz; 12272 12273 retval = create_gmac_session(ts_params->valid_devs[0], 12274 tdata, RTE_CRYPTO_AUTH_OP_GENERATE); 12275 12276 if (retval < 0) 12277 return retval; 12278 12279 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 12280 TEST_ASSERT_NOT_NULL(ut_params->ibuf, 12281 "Failed to allocate input buffer in mempool"); 12282 12283 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 12284 rte_pktmbuf_tailroom(ut_params->ibuf)); 12285 12286 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 12287 plaintext_len); 12288 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext"); 12289 12290 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 12291 12292 trn_data += plaintext_len; 12293 12294 buf = ut_params->ibuf; 12295 12296 /* 12297 * Loop until no more fragments 12298 */ 12299 12300 while (trn_data < tdata->plaintext.len) { 12301 ++segs; 12302 to_trn = (tdata->plaintext.len - trn_data < fragsz) ? 12303 (tdata->plaintext.len - trn_data) : fragsz; 12304 12305 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool); 12306 buf = buf->next; 12307 12308 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0, 12309 rte_pktmbuf_tailroom(buf)); 12310 12311 plaintext = (uint8_t *)rte_pktmbuf_append(buf, 12312 to_trn); 12313 12314 memcpy(plaintext, tdata->plaintext.data + trn_data, 12315 to_trn); 12316 trn_data += to_trn; 12317 if (trn_data == tdata->plaintext.len) 12318 digest_mem = (uint8_t *)rte_pktmbuf_append(buf, 12319 tdata->gmac_tag.len); 12320 } 12321 ut_params->ibuf->nb_segs = segs; 12322 12323 /* 12324 * Place digest at the end of the last buffer 12325 */ 12326 uint64_t digest_phys = rte_pktmbuf_iova(buf) + to_trn; 12327 12328 if (!digest_mem) { 12329 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 12330 + tdata->gmac_tag.len); 12331 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf, 12332 tdata->plaintext.len); 12333 } 12334 12335 retval = create_gmac_operation_sgl(RTE_CRYPTO_AUTH_OP_GENERATE, 12336 tdata, digest_mem, digest_phys); 12337 12338 if (retval < 0) 12339 return retval; 12340 12341 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 12342 12343 ut_params->op->sym->m_src = ut_params->ibuf; 12344 12345 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 12346 return TEST_SKIPPED; 12347 12348 TEST_ASSERT_NOT_NULL( 12349 process_crypto_request(ts_params->valid_devs[0], 12350 ut_params->op), "failed to process sym crypto op"); 12351 12352 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 12353 "crypto op processing failed"); 12354 12355 auth_tag = digest_mem; 12356 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len); 12357 TEST_ASSERT_BUFFERS_ARE_EQUAL( 12358 auth_tag, 12359 tdata->gmac_tag.data, 12360 tdata->gmac_tag.len, 12361 "GMAC Generated auth tag not as expected"); 12362 12363 return 0; 12364 } 12365 12366 /* Segment size not multiple of block size (16B) */ 12367 static int 12368 test_AES_GMAC_authentication_SGL_40B(void) 12369 { 12370 return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 40); 12371 } 12372 12373 static int 12374 test_AES_GMAC_authentication_SGL_80B(void) 12375 { 12376 return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 80); 12377 } 12378 12379 static int 12380 test_AES_GMAC_authentication_SGL_2048B(void) 12381 { 12382 return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2048); 12383 } 12384 12385 /* Segment size not multiple of block size (16B) */ 12386 static int 12387 test_AES_GMAC_authentication_SGL_2047B(void) 12388 { 12389 return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2047); 12390 } 12391 12392 struct test_crypto_vector { 12393 enum rte_crypto_cipher_algorithm crypto_algo; 12394 unsigned int cipher_offset; 12395 unsigned int cipher_len; 12396 12397 struct { 12398 uint8_t data[64]; 12399 unsigned int len; 12400 } cipher_key; 12401 12402 struct { 12403 uint8_t data[64]; 12404 unsigned int len; 12405 } iv; 12406 12407 struct { 12408 const uint8_t *data; 12409 unsigned int len; 12410 } plaintext; 12411 12412 struct { 12413 const uint8_t *data; 12414 unsigned int len; 12415 } ciphertext; 12416 12417 enum rte_crypto_auth_algorithm auth_algo; 12418 unsigned int auth_offset; 12419 12420 struct { 12421 uint8_t data[128]; 12422 unsigned int len; 12423 } auth_key; 12424 12425 struct { 12426 const uint8_t *data; 12427 unsigned int len; 12428 } aad; 12429 12430 struct { 12431 uint8_t data[128]; 12432 unsigned int len; 12433 } digest; 12434 }; 12435 12436 static const struct test_crypto_vector 12437 hmac_sha1_test_crypto_vector = { 12438 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC, 12439 .plaintext = { 12440 .data = plaintext_hash, 12441 .len = 512 12442 }, 12443 .auth_key = { 12444 .data = { 12445 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA, 12446 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD, 12447 0xDE, 0xF4, 0xDE, 0xAD 12448 }, 12449 .len = 20 12450 }, 12451 .digest = { 12452 .data = { 12453 0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77, 12454 0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17, 12455 0x3F, 0x91, 0x64, 0x59 12456 }, 12457 .len = 20 12458 } 12459 }; 12460 12461 static const struct test_crypto_vector 12462 aes128_gmac_test_vector = { 12463 .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC, 12464 .plaintext = { 12465 .data = plaintext_hash, 12466 .len = 512 12467 }, 12468 .iv = { 12469 .data = { 12470 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 12471 0x08, 0x09, 0x0A, 0x0B 12472 }, 12473 .len = 12 12474 }, 12475 .auth_key = { 12476 .data = { 12477 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1, 12478 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA 12479 }, 12480 .len = 16 12481 }, 12482 .digest = { 12483 .data = { 12484 0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56, 12485 0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A 12486 }, 12487 .len = 16 12488 } 12489 }; 12490 12491 static const struct test_crypto_vector 12492 aes128cbc_hmac_sha1_test_vector = { 12493 .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC, 12494 .cipher_offset = 0, 12495 .cipher_len = 512, 12496 .cipher_key = { 12497 .data = { 12498 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2, 12499 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A 12500 }, 12501 .len = 16 12502 }, 12503 .iv = { 12504 .data = { 12505 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 12506 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F 12507 }, 12508 .len = 16 12509 }, 12510 .plaintext = { 12511 .data = plaintext_hash, 12512 .len = 512 12513 }, 12514 .ciphertext = { 12515 .data = ciphertext512_aes128cbc, 12516 .len = 512 12517 }, 12518 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC, 12519 .auth_offset = 0, 12520 .auth_key = { 12521 .data = { 12522 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA, 12523 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD, 12524 0xDE, 0xF4, 0xDE, 0xAD 12525 }, 12526 .len = 20 12527 }, 12528 .digest = { 12529 .data = { 12530 0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60, 12531 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1, 12532 0x18, 0x8C, 0x1D, 0x32 12533 }, 12534 .len = 20 12535 } 12536 }; 12537 12538 static const struct test_crypto_vector 12539 aes128cbc_hmac_sha1_aad_test_vector = { 12540 .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC, 12541 .cipher_offset = 8, 12542 .cipher_len = 496, 12543 .cipher_key = { 12544 .data = { 12545 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2, 12546 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A 12547 }, 12548 .len = 16 12549 }, 12550 .iv = { 12551 .data = { 12552 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 12553 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F 12554 }, 12555 .len = 16 12556 }, 12557 .plaintext = { 12558 .data = plaintext_hash, 12559 .len = 512 12560 }, 12561 .ciphertext = { 12562 .data = ciphertext512_aes128cbc_aad, 12563 .len = 512 12564 }, 12565 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC, 12566 .auth_offset = 0, 12567 .auth_key = { 12568 .data = { 12569 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA, 12570 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD, 12571 0xDE, 0xF4, 0xDE, 0xAD 12572 }, 12573 .len = 20 12574 }, 12575 .digest = { 12576 .data = { 12577 0x6D, 0xF3, 0x50, 0x79, 0x7A, 0x2A, 0xAC, 0x7F, 12578 0xA6, 0xF0, 0xC6, 0x38, 0x1F, 0xA4, 0xDD, 0x9B, 12579 0x62, 0x0F, 0xFB, 0x10 12580 }, 12581 .len = 20 12582 } 12583 }; 12584 12585 static void 12586 data_corruption(uint8_t *data) 12587 { 12588 data[0] += 1; 12589 } 12590 12591 static void 12592 tag_corruption(uint8_t *data, unsigned int tag_offset) 12593 { 12594 data[tag_offset] += 1; 12595 } 12596 12597 static int 12598 create_auth_session(struct crypto_unittest_params *ut_params, 12599 uint8_t dev_id, 12600 const struct test_crypto_vector *reference, 12601 enum rte_crypto_auth_operation auth_op) 12602 { 12603 struct crypto_testsuite_params *ts_params = &testsuite_params; 12604 uint8_t auth_key[reference->auth_key.len + 1]; 12605 12606 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len); 12607 12608 /* Setup Authentication Parameters */ 12609 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 12610 ut_params->auth_xform.auth.op = auth_op; 12611 ut_params->auth_xform.next = NULL; 12612 ut_params->auth_xform.auth.algo = reference->auth_algo; 12613 ut_params->auth_xform.auth.key.length = reference->auth_key.len; 12614 ut_params->auth_xform.auth.key.data = auth_key; 12615 ut_params->auth_xform.auth.digest_length = reference->digest.len; 12616 12617 /* Create Crypto session*/ 12618 ut_params->sess = rte_cryptodev_sym_session_create( 12619 ts_params->session_mpool); 12620 12621 rte_cryptodev_sym_session_init(dev_id, ut_params->sess, 12622 &ut_params->auth_xform, 12623 ts_params->session_priv_mpool); 12624 12625 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 12626 12627 return 0; 12628 } 12629 12630 static int 12631 create_auth_cipher_session(struct crypto_unittest_params *ut_params, 12632 uint8_t dev_id, 12633 const struct test_crypto_vector *reference, 12634 enum rte_crypto_auth_operation auth_op, 12635 enum rte_crypto_cipher_operation cipher_op) 12636 { 12637 struct crypto_testsuite_params *ts_params = &testsuite_params; 12638 uint8_t cipher_key[reference->cipher_key.len + 1]; 12639 uint8_t auth_key[reference->auth_key.len + 1]; 12640 12641 memcpy(cipher_key, reference->cipher_key.data, 12642 reference->cipher_key.len); 12643 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len); 12644 12645 /* Setup Authentication Parameters */ 12646 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 12647 ut_params->auth_xform.auth.op = auth_op; 12648 ut_params->auth_xform.auth.algo = reference->auth_algo; 12649 ut_params->auth_xform.auth.key.length = reference->auth_key.len; 12650 ut_params->auth_xform.auth.key.data = auth_key; 12651 ut_params->auth_xform.auth.digest_length = reference->digest.len; 12652 12653 if (reference->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) { 12654 ut_params->auth_xform.auth.iv.offset = IV_OFFSET; 12655 ut_params->auth_xform.auth.iv.length = reference->iv.len; 12656 } else { 12657 ut_params->auth_xform.next = &ut_params->cipher_xform; 12658 12659 /* Setup Cipher Parameters */ 12660 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 12661 ut_params->cipher_xform.next = NULL; 12662 ut_params->cipher_xform.cipher.algo = reference->crypto_algo; 12663 ut_params->cipher_xform.cipher.op = cipher_op; 12664 ut_params->cipher_xform.cipher.key.data = cipher_key; 12665 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len; 12666 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET; 12667 ut_params->cipher_xform.cipher.iv.length = reference->iv.len; 12668 } 12669 12670 /* Create Crypto session*/ 12671 ut_params->sess = rte_cryptodev_sym_session_create( 12672 ts_params->session_mpool); 12673 12674 rte_cryptodev_sym_session_init(dev_id, ut_params->sess, 12675 &ut_params->auth_xform, 12676 ts_params->session_priv_mpool); 12677 12678 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 12679 12680 return 0; 12681 } 12682 12683 static int 12684 create_auth_operation(struct crypto_testsuite_params *ts_params, 12685 struct crypto_unittest_params *ut_params, 12686 const struct test_crypto_vector *reference, 12687 unsigned int auth_generate) 12688 { 12689 /* Generate Crypto op data structure */ 12690 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 12691 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 12692 TEST_ASSERT_NOT_NULL(ut_params->op, 12693 "Failed to allocate pktmbuf offload"); 12694 12695 /* Set crypto operation data parameters */ 12696 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 12697 12698 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 12699 12700 /* set crypto operation source mbuf */ 12701 sym_op->m_src = ut_params->ibuf; 12702 12703 /* digest */ 12704 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( 12705 ut_params->ibuf, reference->digest.len); 12706 12707 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, 12708 "no room to append auth tag"); 12709 12710 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( 12711 ut_params->ibuf, reference->plaintext.len); 12712 12713 if (auth_generate) 12714 memset(sym_op->auth.digest.data, 0, reference->digest.len); 12715 else 12716 memcpy(sym_op->auth.digest.data, 12717 reference->digest.data, 12718 reference->digest.len); 12719 12720 debug_hexdump(stdout, "digest:", 12721 sym_op->auth.digest.data, 12722 reference->digest.len); 12723 12724 sym_op->auth.data.length = reference->plaintext.len; 12725 sym_op->auth.data.offset = 0; 12726 12727 return 0; 12728 } 12729 12730 static int 12731 create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params, 12732 struct crypto_unittest_params *ut_params, 12733 const struct test_crypto_vector *reference, 12734 unsigned int auth_generate) 12735 { 12736 /* Generate Crypto op data structure */ 12737 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 12738 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 12739 TEST_ASSERT_NOT_NULL(ut_params->op, 12740 "Failed to allocate pktmbuf offload"); 12741 12742 /* Set crypto operation data parameters */ 12743 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 12744 12745 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 12746 12747 /* set crypto operation source mbuf */ 12748 sym_op->m_src = ut_params->ibuf; 12749 12750 /* digest */ 12751 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( 12752 ut_params->ibuf, reference->digest.len); 12753 12754 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, 12755 "no room to append auth tag"); 12756 12757 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( 12758 ut_params->ibuf, reference->ciphertext.len); 12759 12760 if (auth_generate) 12761 memset(sym_op->auth.digest.data, 0, reference->digest.len); 12762 else 12763 memcpy(sym_op->auth.digest.data, 12764 reference->digest.data, 12765 reference->digest.len); 12766 12767 debug_hexdump(stdout, "digest:", 12768 sym_op->auth.digest.data, 12769 reference->digest.len); 12770 12771 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET), 12772 reference->iv.data, reference->iv.len); 12773 12774 sym_op->cipher.data.length = 0; 12775 sym_op->cipher.data.offset = 0; 12776 12777 sym_op->auth.data.length = reference->plaintext.len; 12778 sym_op->auth.data.offset = 0; 12779 12780 return 0; 12781 } 12782 12783 static int 12784 create_cipher_auth_operation(struct crypto_testsuite_params *ts_params, 12785 struct crypto_unittest_params *ut_params, 12786 const struct test_crypto_vector *reference, 12787 unsigned int auth_generate) 12788 { 12789 /* Generate Crypto op data structure */ 12790 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 12791 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 12792 TEST_ASSERT_NOT_NULL(ut_params->op, 12793 "Failed to allocate pktmbuf offload"); 12794 12795 /* Set crypto operation data parameters */ 12796 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 12797 12798 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 12799 12800 /* set crypto operation source mbuf */ 12801 sym_op->m_src = ut_params->ibuf; 12802 12803 /* digest */ 12804 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append( 12805 ut_params->ibuf, reference->digest.len); 12806 12807 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, 12808 "no room to append auth tag"); 12809 12810 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset( 12811 ut_params->ibuf, reference->ciphertext.len); 12812 12813 if (auth_generate) 12814 memset(sym_op->auth.digest.data, 0, reference->digest.len); 12815 else 12816 memcpy(sym_op->auth.digest.data, 12817 reference->digest.data, 12818 reference->digest.len); 12819 12820 debug_hexdump(stdout, "digest:", 12821 sym_op->auth.digest.data, 12822 reference->digest.len); 12823 12824 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET), 12825 reference->iv.data, reference->iv.len); 12826 12827 sym_op->cipher.data.length = reference->cipher_len; 12828 sym_op->cipher.data.offset = reference->cipher_offset; 12829 12830 sym_op->auth.data.length = reference->plaintext.len; 12831 sym_op->auth.data.offset = reference->auth_offset; 12832 12833 return 0; 12834 } 12835 12836 static int 12837 create_auth_verify_operation(struct crypto_testsuite_params *ts_params, 12838 struct crypto_unittest_params *ut_params, 12839 const struct test_crypto_vector *reference) 12840 { 12841 return create_auth_operation(ts_params, ut_params, reference, 0); 12842 } 12843 12844 static int 12845 create_auth_verify_GMAC_operation( 12846 struct crypto_testsuite_params *ts_params, 12847 struct crypto_unittest_params *ut_params, 12848 const struct test_crypto_vector *reference) 12849 { 12850 return create_auth_GMAC_operation(ts_params, ut_params, reference, 0); 12851 } 12852 12853 static int 12854 create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params, 12855 struct crypto_unittest_params *ut_params, 12856 const struct test_crypto_vector *reference) 12857 { 12858 return create_cipher_auth_operation(ts_params, ut_params, reference, 0); 12859 } 12860 12861 static int 12862 test_authentication_verify_fail_when_data_corruption( 12863 struct crypto_testsuite_params *ts_params, 12864 struct crypto_unittest_params *ut_params, 12865 const struct test_crypto_vector *reference, 12866 unsigned int data_corrupted) 12867 { 12868 int retval; 12869 12870 uint8_t *plaintext; 12871 struct rte_cryptodev_info dev_info; 12872 12873 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 12874 uint64_t feat_flags = dev_info.feature_flags; 12875 12876 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 12877 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 12878 printf("Device doesn't support RAW data-path APIs.\n"); 12879 return TEST_SKIPPED; 12880 } 12881 12882 /* Verify the capabilities */ 12883 struct rte_cryptodev_sym_capability_idx cap_idx; 12884 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; 12885 cap_idx.algo.auth = reference->auth_algo; 12886 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 12887 &cap_idx) == NULL) 12888 return TEST_SKIPPED; 12889 12890 12891 /* Create session */ 12892 retval = create_auth_session(ut_params, 12893 ts_params->valid_devs[0], 12894 reference, 12895 RTE_CRYPTO_AUTH_OP_VERIFY); 12896 if (retval < 0) 12897 return retval; 12898 12899 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 12900 TEST_ASSERT_NOT_NULL(ut_params->ibuf, 12901 "Failed to allocate input buffer in mempool"); 12902 12903 /* clear mbuf payload */ 12904 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 12905 rte_pktmbuf_tailroom(ut_params->ibuf)); 12906 12907 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 12908 reference->plaintext.len); 12909 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext"); 12910 memcpy(plaintext, reference->plaintext.data, reference->plaintext.len); 12911 12912 debug_hexdump(stdout, "plaintext:", plaintext, 12913 reference->plaintext.len); 12914 12915 /* Create operation */ 12916 retval = create_auth_verify_operation(ts_params, ut_params, reference); 12917 12918 if (retval < 0) 12919 return retval; 12920 12921 if (data_corrupted) 12922 data_corruption(plaintext); 12923 else 12924 tag_corruption(plaintext, reference->plaintext.len); 12925 12926 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) { 12927 process_cpu_crypt_auth_op(ts_params->valid_devs[0], 12928 ut_params->op); 12929 TEST_ASSERT_NOT_EQUAL(ut_params->op->status, 12930 RTE_CRYPTO_OP_STATUS_SUCCESS, 12931 "authentication not failed"); 12932 } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 12933 process_sym_raw_dp_op(ts_params->valid_devs[0], 0, 12934 ut_params->op, 0, 1, 0, 0); 12935 else { 12936 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 12937 ut_params->op); 12938 TEST_ASSERT_NULL(ut_params->op, "authentication not failed"); 12939 } 12940 12941 return 0; 12942 } 12943 12944 static int 12945 test_authentication_verify_GMAC_fail_when_corruption( 12946 struct crypto_testsuite_params *ts_params, 12947 struct crypto_unittest_params *ut_params, 12948 const struct test_crypto_vector *reference, 12949 unsigned int data_corrupted) 12950 { 12951 int retval; 12952 uint8_t *plaintext; 12953 struct rte_cryptodev_info dev_info; 12954 12955 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 12956 uint64_t feat_flags = dev_info.feature_flags; 12957 12958 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 12959 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 12960 printf("Device doesn't support RAW data-path APIs.\n"); 12961 return TEST_SKIPPED; 12962 } 12963 12964 /* Verify the capabilities */ 12965 struct rte_cryptodev_sym_capability_idx cap_idx; 12966 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; 12967 cap_idx.algo.auth = reference->auth_algo; 12968 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 12969 &cap_idx) == NULL) 12970 return TEST_SKIPPED; 12971 12972 /* Create session */ 12973 retval = create_auth_cipher_session(ut_params, 12974 ts_params->valid_devs[0], 12975 reference, 12976 RTE_CRYPTO_AUTH_OP_VERIFY, 12977 RTE_CRYPTO_CIPHER_OP_DECRYPT); 12978 if (retval < 0) 12979 return retval; 12980 12981 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 12982 TEST_ASSERT_NOT_NULL(ut_params->ibuf, 12983 "Failed to allocate input buffer in mempool"); 12984 12985 /* clear mbuf payload */ 12986 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 12987 rte_pktmbuf_tailroom(ut_params->ibuf)); 12988 12989 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 12990 reference->plaintext.len); 12991 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext"); 12992 memcpy(plaintext, reference->plaintext.data, reference->plaintext.len); 12993 12994 debug_hexdump(stdout, "plaintext:", plaintext, 12995 reference->plaintext.len); 12996 12997 /* Create operation */ 12998 retval = create_auth_verify_GMAC_operation(ts_params, 12999 ut_params, 13000 reference); 13001 13002 if (retval < 0) 13003 return retval; 13004 13005 if (data_corrupted) 13006 data_corruption(plaintext); 13007 else 13008 tag_corruption(plaintext, reference->aad.len); 13009 13010 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) { 13011 process_cpu_crypt_auth_op(ts_params->valid_devs[0], 13012 ut_params->op); 13013 TEST_ASSERT_NOT_EQUAL(ut_params->op->status, 13014 RTE_CRYPTO_OP_STATUS_SUCCESS, 13015 "authentication not failed"); 13016 } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 13017 process_sym_raw_dp_op(ts_params->valid_devs[0], 0, 13018 ut_params->op, 0, 1, 0, 0); 13019 else { 13020 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 13021 ut_params->op); 13022 TEST_ASSERT_NULL(ut_params->op, "authentication not failed"); 13023 } 13024 13025 return 0; 13026 } 13027 13028 static int 13029 test_authenticated_decryption_fail_when_corruption( 13030 struct crypto_testsuite_params *ts_params, 13031 struct crypto_unittest_params *ut_params, 13032 const struct test_crypto_vector *reference, 13033 unsigned int data_corrupted) 13034 { 13035 int retval; 13036 13037 uint8_t *ciphertext; 13038 struct rte_cryptodev_info dev_info; 13039 13040 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 13041 uint64_t feat_flags = dev_info.feature_flags; 13042 13043 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 13044 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 13045 printf("Device doesn't support RAW data-path APIs.\n"); 13046 return TEST_SKIPPED; 13047 } 13048 13049 /* Verify the capabilities */ 13050 struct rte_cryptodev_sym_capability_idx cap_idx; 13051 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; 13052 cap_idx.algo.auth = reference->auth_algo; 13053 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 13054 &cap_idx) == NULL) 13055 return TEST_SKIPPED; 13056 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 13057 cap_idx.algo.cipher = reference->crypto_algo; 13058 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 13059 &cap_idx) == NULL) 13060 return TEST_SKIPPED; 13061 13062 /* Create session */ 13063 retval = create_auth_cipher_session(ut_params, 13064 ts_params->valid_devs[0], 13065 reference, 13066 RTE_CRYPTO_AUTH_OP_VERIFY, 13067 RTE_CRYPTO_CIPHER_OP_DECRYPT); 13068 if (retval < 0) 13069 return retval; 13070 13071 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 13072 TEST_ASSERT_NOT_NULL(ut_params->ibuf, 13073 "Failed to allocate input buffer in mempool"); 13074 13075 /* clear mbuf payload */ 13076 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 13077 rte_pktmbuf_tailroom(ut_params->ibuf)); 13078 13079 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 13080 reference->ciphertext.len); 13081 TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext"); 13082 memcpy(ciphertext, reference->ciphertext.data, 13083 reference->ciphertext.len); 13084 13085 /* Create operation */ 13086 retval = create_cipher_auth_verify_operation(ts_params, 13087 ut_params, 13088 reference); 13089 13090 if (retval < 0) 13091 return retval; 13092 13093 if (data_corrupted) 13094 data_corruption(ciphertext); 13095 else 13096 tag_corruption(ciphertext, reference->ciphertext.len); 13097 13098 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) { 13099 process_cpu_crypt_auth_op(ts_params->valid_devs[0], 13100 ut_params->op); 13101 TEST_ASSERT_NOT_EQUAL(ut_params->op->status, 13102 RTE_CRYPTO_OP_STATUS_SUCCESS, 13103 "authentication not failed"); 13104 } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 13105 process_sym_raw_dp_op(ts_params->valid_devs[0], 0, 13106 ut_params->op, 1, 1, 0, 0); 13107 else { 13108 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 13109 ut_params->op); 13110 TEST_ASSERT_NULL(ut_params->op, "authentication not failed"); 13111 } 13112 13113 return 0; 13114 } 13115 13116 static int 13117 test_authenticated_encrypt_with_esn( 13118 struct crypto_testsuite_params *ts_params, 13119 struct crypto_unittest_params *ut_params, 13120 const struct test_crypto_vector *reference) 13121 { 13122 int retval; 13123 13124 uint8_t *authciphertext, *plaintext, *auth_tag; 13125 uint16_t plaintext_pad_len; 13126 uint8_t cipher_key[reference->cipher_key.len + 1]; 13127 uint8_t auth_key[reference->auth_key.len + 1]; 13128 struct rte_cryptodev_info dev_info; 13129 13130 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 13131 uint64_t feat_flags = dev_info.feature_flags; 13132 13133 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 13134 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 13135 printf("Device doesn't support RAW data-path APIs.\n"); 13136 return TEST_SKIPPED; 13137 } 13138 13139 /* Verify the capabilities */ 13140 struct rte_cryptodev_sym_capability_idx cap_idx; 13141 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; 13142 cap_idx.algo.auth = reference->auth_algo; 13143 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 13144 &cap_idx) == NULL) 13145 return TEST_SKIPPED; 13146 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 13147 cap_idx.algo.cipher = reference->crypto_algo; 13148 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 13149 &cap_idx) == NULL) 13150 return TEST_SKIPPED; 13151 13152 /* Create session */ 13153 memcpy(cipher_key, reference->cipher_key.data, 13154 reference->cipher_key.len); 13155 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len); 13156 13157 /* Setup Cipher Parameters */ 13158 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 13159 ut_params->cipher_xform.cipher.algo = reference->crypto_algo; 13160 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; 13161 ut_params->cipher_xform.cipher.key.data = cipher_key; 13162 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len; 13163 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET; 13164 ut_params->cipher_xform.cipher.iv.length = reference->iv.len; 13165 13166 ut_params->cipher_xform.next = &ut_params->auth_xform; 13167 13168 /* Setup Authentication Parameters */ 13169 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 13170 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; 13171 ut_params->auth_xform.auth.algo = reference->auth_algo; 13172 ut_params->auth_xform.auth.key.length = reference->auth_key.len; 13173 ut_params->auth_xform.auth.key.data = auth_key; 13174 ut_params->auth_xform.auth.digest_length = reference->digest.len; 13175 ut_params->auth_xform.next = NULL; 13176 13177 /* Create Crypto session*/ 13178 ut_params->sess = rte_cryptodev_sym_session_create( 13179 ts_params->session_mpool); 13180 13181 rte_cryptodev_sym_session_init(ts_params->valid_devs[0], 13182 ut_params->sess, 13183 &ut_params->cipher_xform, 13184 ts_params->session_priv_mpool); 13185 13186 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 13187 13188 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 13189 TEST_ASSERT_NOT_NULL(ut_params->ibuf, 13190 "Failed to allocate input buffer in mempool"); 13191 13192 /* clear mbuf payload */ 13193 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 13194 rte_pktmbuf_tailroom(ut_params->ibuf)); 13195 13196 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 13197 reference->plaintext.len); 13198 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext"); 13199 memcpy(plaintext, reference->plaintext.data, reference->plaintext.len); 13200 13201 /* Create operation */ 13202 retval = create_cipher_auth_operation(ts_params, 13203 ut_params, 13204 reference, 0); 13205 13206 if (retval < 0) 13207 return retval; 13208 13209 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 13210 process_cpu_crypt_auth_op(ts_params->valid_devs[0], 13211 ut_params->op); 13212 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 13213 process_sym_raw_dp_op(ts_params->valid_devs[0], 0, 13214 ut_params->op, 1, 1, 0, 0); 13215 else 13216 ut_params->op = process_crypto_request( 13217 ts_params->valid_devs[0], ut_params->op); 13218 13219 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned"); 13220 13221 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 13222 "crypto op processing failed"); 13223 13224 plaintext_pad_len = RTE_ALIGN_CEIL(reference->plaintext.len, 16); 13225 13226 authciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *, 13227 ut_params->op->sym->auth.data.offset); 13228 auth_tag = authciphertext + plaintext_pad_len; 13229 debug_hexdump(stdout, "ciphertext:", authciphertext, 13230 reference->ciphertext.len); 13231 debug_hexdump(stdout, "auth tag:", auth_tag, reference->digest.len); 13232 13233 /* Validate obuf */ 13234 TEST_ASSERT_BUFFERS_ARE_EQUAL( 13235 authciphertext, 13236 reference->ciphertext.data, 13237 reference->ciphertext.len, 13238 "Ciphertext data not as expected"); 13239 13240 TEST_ASSERT_BUFFERS_ARE_EQUAL( 13241 auth_tag, 13242 reference->digest.data, 13243 reference->digest.len, 13244 "Generated digest not as expected"); 13245 13246 return TEST_SUCCESS; 13247 13248 } 13249 13250 static int 13251 test_authenticated_decrypt_with_esn( 13252 struct crypto_testsuite_params *ts_params, 13253 struct crypto_unittest_params *ut_params, 13254 const struct test_crypto_vector *reference) 13255 { 13256 int retval; 13257 13258 uint8_t *ciphertext; 13259 uint8_t cipher_key[reference->cipher_key.len + 1]; 13260 uint8_t auth_key[reference->auth_key.len + 1]; 13261 struct rte_cryptodev_info dev_info; 13262 13263 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 13264 uint64_t feat_flags = dev_info.feature_flags; 13265 13266 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 13267 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 13268 printf("Device doesn't support RAW data-path APIs.\n"); 13269 return TEST_SKIPPED; 13270 } 13271 13272 /* Verify the capabilities */ 13273 struct rte_cryptodev_sym_capability_idx cap_idx; 13274 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; 13275 cap_idx.algo.auth = reference->auth_algo; 13276 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 13277 &cap_idx) == NULL) 13278 return TEST_SKIPPED; 13279 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 13280 cap_idx.algo.cipher = reference->crypto_algo; 13281 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 13282 &cap_idx) == NULL) 13283 return TEST_SKIPPED; 13284 13285 /* Create session */ 13286 memcpy(cipher_key, reference->cipher_key.data, 13287 reference->cipher_key.len); 13288 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len); 13289 13290 /* Setup Authentication Parameters */ 13291 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 13292 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY; 13293 ut_params->auth_xform.auth.algo = reference->auth_algo; 13294 ut_params->auth_xform.auth.key.length = reference->auth_key.len; 13295 ut_params->auth_xform.auth.key.data = auth_key; 13296 ut_params->auth_xform.auth.digest_length = reference->digest.len; 13297 ut_params->auth_xform.next = &ut_params->cipher_xform; 13298 13299 /* Setup Cipher Parameters */ 13300 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 13301 ut_params->cipher_xform.next = NULL; 13302 ut_params->cipher_xform.cipher.algo = reference->crypto_algo; 13303 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT; 13304 ut_params->cipher_xform.cipher.key.data = cipher_key; 13305 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len; 13306 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET; 13307 ut_params->cipher_xform.cipher.iv.length = reference->iv.len; 13308 13309 /* Create Crypto session*/ 13310 ut_params->sess = rte_cryptodev_sym_session_create( 13311 ts_params->session_mpool); 13312 13313 rte_cryptodev_sym_session_init(ts_params->valid_devs[0], 13314 ut_params->sess, 13315 &ut_params->auth_xform, 13316 ts_params->session_priv_mpool); 13317 13318 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); 13319 13320 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 13321 TEST_ASSERT_NOT_NULL(ut_params->ibuf, 13322 "Failed to allocate input buffer in mempool"); 13323 13324 /* clear mbuf payload */ 13325 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 13326 rte_pktmbuf_tailroom(ut_params->ibuf)); 13327 13328 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 13329 reference->ciphertext.len); 13330 TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext"); 13331 memcpy(ciphertext, reference->ciphertext.data, 13332 reference->ciphertext.len); 13333 13334 /* Create operation */ 13335 retval = create_cipher_auth_verify_operation(ts_params, 13336 ut_params, 13337 reference); 13338 13339 if (retval < 0) 13340 return retval; 13341 13342 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 13343 process_cpu_crypt_auth_op(ts_params->valid_devs[0], 13344 ut_params->op); 13345 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 13346 process_sym_raw_dp_op(ts_params->valid_devs[0], 0, 13347 ut_params->op, 1, 1, 0, 0); 13348 else 13349 ut_params->op = process_crypto_request(ts_params->valid_devs[0], 13350 ut_params->op); 13351 13352 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process"); 13353 TEST_ASSERT_EQUAL(ut_params->op->status, 13354 RTE_CRYPTO_OP_STATUS_SUCCESS, 13355 "crypto op processing passed"); 13356 13357 ut_params->obuf = ut_params->op->sym->m_src; 13358 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf"); 13359 13360 return 0; 13361 } 13362 13363 static int 13364 create_aead_operation_SGL(enum rte_crypto_aead_operation op, 13365 const struct aead_test_data *tdata, 13366 void *digest_mem, uint64_t digest_phys) 13367 { 13368 struct crypto_testsuite_params *ts_params = &testsuite_params; 13369 struct crypto_unittest_params *ut_params = &unittest_params; 13370 13371 const unsigned int auth_tag_len = tdata->auth_tag.len; 13372 const unsigned int iv_len = tdata->iv.len; 13373 unsigned int aad_len = tdata->aad.len; 13374 unsigned int aad_len_pad = 0; 13375 13376 /* Generate Crypto op data structure */ 13377 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, 13378 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 13379 TEST_ASSERT_NOT_NULL(ut_params->op, 13380 "Failed to allocate symmetric crypto operation struct"); 13381 13382 struct rte_crypto_sym_op *sym_op = ut_params->op->sym; 13383 13384 sym_op->aead.digest.data = digest_mem; 13385 13386 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data, 13387 "no room to append digest"); 13388 13389 sym_op->aead.digest.phys_addr = digest_phys; 13390 13391 if (op == RTE_CRYPTO_AEAD_OP_DECRYPT) { 13392 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data, 13393 auth_tag_len); 13394 debug_hexdump(stdout, "digest:", 13395 sym_op->aead.digest.data, 13396 auth_tag_len); 13397 } 13398 13399 /* Append aad data */ 13400 if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) { 13401 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, 13402 uint8_t *, IV_OFFSET); 13403 13404 /* Copy IV 1 byte after the IV pointer, according to the API */ 13405 rte_memcpy(iv_ptr + 1, tdata->iv.data, iv_len); 13406 13407 aad_len = RTE_ALIGN_CEIL(aad_len + 18, 16); 13408 13409 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend( 13410 ut_params->ibuf, aad_len); 13411 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data, 13412 "no room to prepend aad"); 13413 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova( 13414 ut_params->ibuf); 13415 13416 memset(sym_op->aead.aad.data, 0, aad_len); 13417 /* Copy AAD 18 bytes after the AAD pointer, according to the API */ 13418 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len); 13419 13420 debug_hexdump(stdout, "iv:", iv_ptr, iv_len); 13421 debug_hexdump(stdout, "aad:", 13422 sym_op->aead.aad.data, aad_len); 13423 } else { 13424 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, 13425 uint8_t *, IV_OFFSET); 13426 13427 rte_memcpy(iv_ptr, tdata->iv.data, iv_len); 13428 13429 aad_len_pad = RTE_ALIGN_CEIL(aad_len, 16); 13430 13431 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend( 13432 ut_params->ibuf, aad_len_pad); 13433 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data, 13434 "no room to prepend aad"); 13435 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova( 13436 ut_params->ibuf); 13437 13438 memset(sym_op->aead.aad.data, 0, aad_len); 13439 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len); 13440 13441 debug_hexdump(stdout, "iv:", iv_ptr, iv_len); 13442 debug_hexdump(stdout, "aad:", 13443 sym_op->aead.aad.data, aad_len); 13444 } 13445 13446 sym_op->aead.data.length = tdata->plaintext.len; 13447 sym_op->aead.data.offset = aad_len_pad; 13448 13449 return 0; 13450 } 13451 13452 #define SGL_MAX_NO 16 13453 13454 static int 13455 test_authenticated_encryption_SGL(const struct aead_test_data *tdata, 13456 const int oop, uint32_t fragsz, uint32_t fragsz_oop) 13457 { 13458 struct crypto_testsuite_params *ts_params = &testsuite_params; 13459 struct crypto_unittest_params *ut_params = &unittest_params; 13460 struct rte_mbuf *buf, *buf_oop = NULL, *buf_last_oop = NULL; 13461 int retval; 13462 int to_trn = 0; 13463 int to_trn_tbl[SGL_MAX_NO]; 13464 int segs = 1; 13465 unsigned int trn_data = 0; 13466 uint8_t *plaintext, *ciphertext, *auth_tag; 13467 struct rte_cryptodev_info dev_info; 13468 13469 /* Verify the capabilities */ 13470 struct rte_cryptodev_sym_capability_idx cap_idx; 13471 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD; 13472 cap_idx.algo.aead = tdata->algo; 13473 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], 13474 &cap_idx) == NULL) 13475 return TEST_SKIPPED; 13476 13477 /* OOP not supported with CPU crypto */ 13478 if (oop && gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 13479 return TEST_SKIPPED; 13480 13481 /* Detailed check for the particular SGL support flag */ 13482 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); 13483 if (!oop) { 13484 unsigned int sgl_in = fragsz < tdata->plaintext.len; 13485 if (sgl_in && (!(dev_info.feature_flags & 13486 RTE_CRYPTODEV_FF_IN_PLACE_SGL))) 13487 return TEST_SKIPPED; 13488 13489 uint64_t feat_flags = dev_info.feature_flags; 13490 13491 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 13492 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 13493 printf("Device doesn't support RAW data-path APIs.\n"); 13494 return TEST_SKIPPED; 13495 } 13496 } else { 13497 unsigned int sgl_in = fragsz < tdata->plaintext.len; 13498 unsigned int sgl_out = (fragsz_oop ? fragsz_oop : fragsz) < 13499 tdata->plaintext.len; 13500 /* Raw data path API does not support OOP */ 13501 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 13502 return TEST_SKIPPED; 13503 if (sgl_in && !sgl_out) { 13504 if (!(dev_info.feature_flags & 13505 RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT)) 13506 return TEST_SKIPPED; 13507 } else if (!sgl_in && sgl_out) { 13508 if (!(dev_info.feature_flags & 13509 RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT)) 13510 return TEST_SKIPPED; 13511 } else if (sgl_in && sgl_out) { 13512 if (!(dev_info.feature_flags & 13513 RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) 13514 return TEST_SKIPPED; 13515 } 13516 } 13517 13518 if (fragsz > tdata->plaintext.len) 13519 fragsz = tdata->plaintext.len; 13520 13521 uint16_t plaintext_len = fragsz; 13522 uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz; 13523 13524 if (fragsz_oop > tdata->plaintext.len) 13525 frag_size_oop = tdata->plaintext.len; 13526 13527 int ecx = 0; 13528 void *digest_mem = NULL; 13529 13530 uint32_t prepend_len = RTE_ALIGN_CEIL(tdata->aad.len, 16); 13531 13532 if (tdata->plaintext.len % fragsz != 0) { 13533 if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO) 13534 return 1; 13535 } else { 13536 if (tdata->plaintext.len / fragsz > SGL_MAX_NO) 13537 return 1; 13538 } 13539 13540 /* 13541 * For out-op-place we need to alloc another mbuf 13542 */ 13543 if (oop) { 13544 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 13545 rte_pktmbuf_append(ut_params->obuf, 13546 frag_size_oop + prepend_len); 13547 buf_oop = ut_params->obuf; 13548 } 13549 13550 /* Create AEAD session */ 13551 retval = create_aead_session(ts_params->valid_devs[0], 13552 tdata->algo, 13553 RTE_CRYPTO_AEAD_OP_ENCRYPT, 13554 tdata->key.data, tdata->key.len, 13555 tdata->aad.len, tdata->auth_tag.len, 13556 tdata->iv.len); 13557 if (retval < 0) 13558 return retval; 13559 13560 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); 13561 13562 /* clear mbuf payload */ 13563 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, 13564 rte_pktmbuf_tailroom(ut_params->ibuf)); 13565 13566 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 13567 plaintext_len); 13568 13569 memcpy(plaintext, tdata->plaintext.data, plaintext_len); 13570 13571 trn_data += plaintext_len; 13572 13573 buf = ut_params->ibuf; 13574 13575 /* 13576 * Loop until no more fragments 13577 */ 13578 13579 while (trn_data < tdata->plaintext.len) { 13580 ++segs; 13581 to_trn = (tdata->plaintext.len - trn_data < fragsz) ? 13582 (tdata->plaintext.len - trn_data) : fragsz; 13583 13584 to_trn_tbl[ecx++] = to_trn; 13585 13586 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool); 13587 buf = buf->next; 13588 13589 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0, 13590 rte_pktmbuf_tailroom(buf)); 13591 13592 /* OOP */ 13593 if (oop && !fragsz_oop) { 13594 buf_last_oop = buf_oop->next = 13595 rte_pktmbuf_alloc(ts_params->mbuf_pool); 13596 buf_oop = buf_oop->next; 13597 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *), 13598 0, rte_pktmbuf_tailroom(buf_oop)); 13599 rte_pktmbuf_append(buf_oop, to_trn); 13600 } 13601 13602 plaintext = (uint8_t *)rte_pktmbuf_append(buf, 13603 to_trn); 13604 13605 memcpy(plaintext, tdata->plaintext.data + trn_data, 13606 to_trn); 13607 trn_data += to_trn; 13608 if (trn_data == tdata->plaintext.len) { 13609 if (oop) { 13610 if (!fragsz_oop) 13611 digest_mem = rte_pktmbuf_append(buf_oop, 13612 tdata->auth_tag.len); 13613 } else 13614 digest_mem = (uint8_t *)rte_pktmbuf_append(buf, 13615 tdata->auth_tag.len); 13616 } 13617 } 13618 13619 uint64_t digest_phys = 0; 13620 13621 ut_params->ibuf->nb_segs = segs; 13622 13623 segs = 1; 13624 if (fragsz_oop && oop) { 13625 to_trn = 0; 13626 ecx = 0; 13627 13628 if (frag_size_oop == tdata->plaintext.len) { 13629 digest_mem = rte_pktmbuf_append(ut_params->obuf, 13630 tdata->auth_tag.len); 13631 13632 digest_phys = rte_pktmbuf_iova_offset( 13633 ut_params->obuf, 13634 tdata->plaintext.len + prepend_len); 13635 } 13636 13637 trn_data = frag_size_oop; 13638 while (trn_data < tdata->plaintext.len) { 13639 ++segs; 13640 to_trn = 13641 (tdata->plaintext.len - trn_data < 13642 frag_size_oop) ? 13643 (tdata->plaintext.len - trn_data) : 13644 frag_size_oop; 13645 13646 to_trn_tbl[ecx++] = to_trn; 13647 13648 buf_last_oop = buf_oop->next = 13649 rte_pktmbuf_alloc(ts_params->mbuf_pool); 13650 buf_oop = buf_oop->next; 13651 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *), 13652 0, rte_pktmbuf_tailroom(buf_oop)); 13653 rte_pktmbuf_append(buf_oop, to_trn); 13654 13655 trn_data += to_trn; 13656 13657 if (trn_data == tdata->plaintext.len) { 13658 digest_mem = rte_pktmbuf_append(buf_oop, 13659 tdata->auth_tag.len); 13660 } 13661 } 13662 13663 ut_params->obuf->nb_segs = segs; 13664 } 13665 13666 /* 13667 * Place digest at the end of the last buffer 13668 */ 13669 if (!digest_phys) 13670 digest_phys = rte_pktmbuf_iova(buf) + to_trn; 13671 if (oop && buf_last_oop) 13672 digest_phys = rte_pktmbuf_iova(buf_last_oop) + to_trn; 13673 13674 if (!digest_mem && !oop) { 13675 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, 13676 + tdata->auth_tag.len); 13677 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf, 13678 tdata->plaintext.len); 13679 } 13680 13681 /* Create AEAD operation */ 13682 retval = create_aead_operation_SGL(RTE_CRYPTO_AEAD_OP_ENCRYPT, 13683 tdata, digest_mem, digest_phys); 13684 13685 if (retval < 0) 13686 return retval; 13687 13688 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); 13689 13690 ut_params->op->sym->m_src = ut_params->ibuf; 13691 if (oop) 13692 ut_params->op->sym->m_dst = ut_params->obuf; 13693 13694 /* Process crypto operation */ 13695 if (oop == IN_PLACE && 13696 gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) 13697 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op); 13698 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST) 13699 process_sym_raw_dp_op(ts_params->valid_devs[0], 0, 13700 ut_params->op, 0, 0, 0, 0); 13701 else 13702 TEST_ASSERT_NOT_NULL( 13703 process_crypto_request(ts_params->valid_devs[0], 13704 ut_params->op), "failed to process sym crypto op"); 13705 13706 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, 13707 "crypto op processing failed"); 13708 13709 13710 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src, 13711 uint8_t *, prepend_len); 13712 if (oop) { 13713 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst, 13714 uint8_t *, prepend_len); 13715 } 13716 13717 if (fragsz_oop) 13718 fragsz = fragsz_oop; 13719 13720 TEST_ASSERT_BUFFERS_ARE_EQUAL( 13721 ciphertext, 13722 tdata->ciphertext.data, 13723 fragsz, 13724 "Ciphertext data not as expected"); 13725 13726 buf = ut_params->op->sym->m_src->next; 13727 if (oop) 13728 buf = ut_params->op->sym->m_dst->next; 13729 13730 unsigned int off = fragsz; 13731 13732 ecx = 0; 13733 while (buf) { 13734 ciphertext = rte_pktmbuf_mtod(buf, 13735 uint8_t *); 13736 13737 TEST_ASSERT_BUFFERS_ARE_EQUAL( 13738 ciphertext, 13739 tdata->ciphertext.data + off, 13740 to_trn_tbl[ecx], 13741 "Ciphertext data not as expected"); 13742 13743 off += to_trn_tbl[ecx++]; 13744 buf = buf->next; 13745 } 13746 13747 auth_tag = digest_mem; 13748 TEST_ASSERT_BUFFERS_ARE_EQUAL( 13749 auth_tag, 13750 tdata->auth_tag.data, 13751 tdata->auth_tag.len, 13752 "Generated auth tag not as expected"); 13753 13754 return 0; 13755 } 13756 13757 static int 13758 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void) 13759 { 13760 return test_authenticated_encryption_SGL( 13761 &gcm_test_case_SGL_1, OUT_OF_PLACE, 400, 400); 13762 } 13763 13764 static int 13765 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B(void) 13766 { 13767 return test_authenticated_encryption_SGL( 13768 &gcm_test_case_SGL_1, OUT_OF_PLACE, 1500, 2000); 13769 } 13770 13771 static int 13772 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void) 13773 { 13774 return test_authenticated_encryption_SGL( 13775 &gcm_test_case_8, OUT_OF_PLACE, 400, 13776 gcm_test_case_8.plaintext.len); 13777 } 13778 13779 static int 13780 test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void) 13781 { 13782 /* This test is not for OPENSSL PMD */ 13783 if (gbl_driver_id == rte_cryptodev_driver_id_get( 13784 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD))) 13785 return TEST_SKIPPED; 13786 13787 return test_authenticated_encryption_SGL( 13788 &gcm_test_case_SGL_1, IN_PLACE, 1500, 0); 13789 } 13790 13791 static int 13792 test_authentication_verify_fail_when_data_corrupted( 13793 struct crypto_testsuite_params *ts_params, 13794 struct crypto_unittest_params *ut_params, 13795 const struct test_crypto_vector *reference) 13796 { 13797 return test_authentication_verify_fail_when_data_corruption( 13798 ts_params, ut_params, reference, 1); 13799 } 13800 13801 static int 13802 test_authentication_verify_fail_when_tag_corrupted( 13803 struct crypto_testsuite_params *ts_params, 13804 struct crypto_unittest_params *ut_params, 13805 const struct test_crypto_vector *reference) 13806 { 13807 return test_authentication_verify_fail_when_data_corruption( 13808 ts_params, ut_params, reference, 0); 13809 } 13810 13811 static int 13812 test_authentication_verify_GMAC_fail_when_data_corrupted( 13813 struct crypto_testsuite_params *ts_params, 13814 struct crypto_unittest_params *ut_params, 13815 const struct test_crypto_vector *reference) 13816 { 13817 return test_authentication_verify_GMAC_fail_when_corruption( 13818 ts_params, ut_params, reference, 1); 13819 } 13820 13821 static int 13822 test_authentication_verify_GMAC_fail_when_tag_corrupted( 13823 struct crypto_testsuite_params *ts_params, 13824 struct crypto_unittest_params *ut_params, 13825 const struct test_crypto_vector *reference) 13826 { 13827 return test_authentication_verify_GMAC_fail_when_corruption( 13828 ts_params, ut_params, reference, 0); 13829 } 13830 13831 static int 13832 test_authenticated_decryption_fail_when_data_corrupted( 13833 struct crypto_testsuite_params *ts_params, 13834 struct crypto_unittest_params *ut_params, 13835 const struct test_crypto_vector *reference) 13836 { 13837 return test_authenticated_decryption_fail_when_corruption( 13838 ts_params, ut_params, reference, 1); 13839 } 13840 13841 static int 13842 test_authenticated_decryption_fail_when_tag_corrupted( 13843 struct crypto_testsuite_params *ts_params, 13844 struct crypto_unittest_params *ut_params, 13845 const struct test_crypto_vector *reference) 13846 { 13847 return test_authenticated_decryption_fail_when_corruption( 13848 ts_params, ut_params, reference, 0); 13849 } 13850 13851 static int 13852 authentication_verify_HMAC_SHA1_fail_data_corrupt(void) 13853 { 13854 return test_authentication_verify_fail_when_data_corrupted( 13855 &testsuite_params, &unittest_params, 13856 &hmac_sha1_test_crypto_vector); 13857 } 13858 13859 static int 13860 authentication_verify_HMAC_SHA1_fail_tag_corrupt(void) 13861 { 13862 return test_authentication_verify_fail_when_tag_corrupted( 13863 &testsuite_params, &unittest_params, 13864 &hmac_sha1_test_crypto_vector); 13865 } 13866 13867 static int 13868 authentication_verify_AES128_GMAC_fail_data_corrupt(void) 13869 { 13870 return test_authentication_verify_GMAC_fail_when_data_corrupted( 13871 &testsuite_params, &unittest_params, 13872 &aes128_gmac_test_vector); 13873 } 13874 13875 static int 13876 authentication_verify_AES128_GMAC_fail_tag_corrupt(void) 13877 { 13878 return test_authentication_verify_GMAC_fail_when_tag_corrupted( 13879 &testsuite_params, &unittest_params, 13880 &aes128_gmac_test_vector); 13881 } 13882 13883 static int 13884 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void) 13885 { 13886 return test_authenticated_decryption_fail_when_data_corrupted( 13887 &testsuite_params, 13888 &unittest_params, 13889 &aes128cbc_hmac_sha1_test_vector); 13890 } 13891 13892 static int 13893 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void) 13894 { 13895 return test_authenticated_decryption_fail_when_tag_corrupted( 13896 &testsuite_params, 13897 &unittest_params, 13898 &aes128cbc_hmac_sha1_test_vector); 13899 } 13900 13901 static int 13902 auth_encrypt_AES128CBC_HMAC_SHA1_esn_check(void) 13903 { 13904 return test_authenticated_encrypt_with_esn( 13905 &testsuite_params, 13906 &unittest_params, 13907 &aes128cbc_hmac_sha1_aad_test_vector); 13908 } 13909 13910 static int 13911 auth_decrypt_AES128CBC_HMAC_SHA1_esn_check(void) 13912 { 13913 return test_authenticated_decrypt_with_esn( 13914 &testsuite_params, 13915 &unittest_params, 13916 &aes128cbc_hmac_sha1_aad_test_vector); 13917 } 13918 13919 static int 13920 test_chacha20_poly1305_encrypt_test_case_rfc8439(void) 13921 { 13922 return test_authenticated_encryption(&chacha20_poly1305_case_rfc8439); 13923 } 13924 13925 static int 13926 test_chacha20_poly1305_decrypt_test_case_rfc8439(void) 13927 { 13928 return test_authenticated_decryption(&chacha20_poly1305_case_rfc8439); 13929 } 13930 13931 #ifdef RTE_CRYPTO_SCHEDULER 13932 13933 /* global AESNI worker IDs for the scheduler test */ 13934 uint8_t aesni_ids[2]; 13935 13936 static int 13937 scheduler_testsuite_setup(void) 13938 { 13939 uint32_t i = 0; 13940 int32_t nb_devs, ret; 13941 char vdev_args[VDEV_ARGS_SIZE] = {""}; 13942 char temp_str[VDEV_ARGS_SIZE] = {"mode=multi-core," 13943 "ordering=enable,name=cryptodev_test_scheduler,corelist="}; 13944 uint16_t worker_core_count = 0; 13945 uint16_t socket_id = 0; 13946 13947 if (gbl_driver_id == rte_cryptodev_driver_id_get( 13948 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD))) { 13949 13950 /* Identify the Worker Cores 13951 * Use 2 worker cores for the device args 13952 */ 13953 RTE_LCORE_FOREACH_WORKER(i) { 13954 if (worker_core_count > 1) 13955 break; 13956 snprintf(vdev_args, sizeof(vdev_args), 13957 "%s%d", temp_str, i); 13958 strcpy(temp_str, vdev_args); 13959 strlcat(temp_str, ";", sizeof(temp_str)); 13960 worker_core_count++; 13961 socket_id = rte_lcore_to_socket_id(i); 13962 } 13963 if (worker_core_count != 2) { 13964 RTE_LOG(ERR, USER1, 13965 "Cryptodev scheduler test require at least " 13966 "two worker cores to run. " 13967 "Please use the correct coremask.\n"); 13968 return TEST_FAILED; 13969 } 13970 strcpy(temp_str, vdev_args); 13971 snprintf(vdev_args, sizeof(vdev_args), "%s,socket_id=%d", 13972 temp_str, socket_id); 13973 RTE_LOG(DEBUG, USER1, "vdev_args: %s\n", vdev_args); 13974 nb_devs = rte_cryptodev_device_count_by_driver( 13975 rte_cryptodev_driver_id_get( 13976 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD))); 13977 if (nb_devs < 1) { 13978 ret = rte_vdev_init( 13979 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD), 13980 vdev_args); 13981 TEST_ASSERT(ret == 0, 13982 "Failed to create instance %u of pmd : %s", 13983 i, RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)); 13984 } 13985 } 13986 return testsuite_setup(); 13987 } 13988 13989 static int 13990 test_scheduler_attach_worker_op(void) 13991 { 13992 struct crypto_testsuite_params *ts_params = &testsuite_params; 13993 uint8_t sched_id = ts_params->valid_devs[0]; 13994 uint32_t i, nb_devs_attached = 0; 13995 int ret; 13996 char vdev_name[32]; 13997 unsigned int count = rte_cryptodev_count(); 13998 13999 /* create 2 AESNI_MB vdevs on top of existing devices */ 14000 for (i = count; i < count + 2; i++) { 14001 snprintf(vdev_name, sizeof(vdev_name), "%s_%u", 14002 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), 14003 i); 14004 ret = rte_vdev_init(vdev_name, NULL); 14005 14006 TEST_ASSERT(ret == 0, 14007 "Failed to create instance %u of" 14008 " pmd : %s", 14009 i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)); 14010 14011 if (ret < 0) { 14012 RTE_LOG(ERR, USER1, 14013 "Failed to create 2 AESNI MB PMDs.\n"); 14014 return TEST_SKIPPED; 14015 } 14016 } 14017 14018 /* attach 2 AESNI_MB cdevs */ 14019 for (i = count; i < count + 2; i++) { 14020 struct rte_cryptodev_info info; 14021 unsigned int session_size; 14022 14023 rte_cryptodev_info_get(i, &info); 14024 if (info.driver_id != rte_cryptodev_driver_id_get( 14025 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD))) 14026 continue; 14027 14028 session_size = rte_cryptodev_sym_get_private_session_size(i); 14029 /* 14030 * Create the session mempool again, since now there are new devices 14031 * to use the mempool. 14032 */ 14033 if (ts_params->session_mpool) { 14034 rte_mempool_free(ts_params->session_mpool); 14035 ts_params->session_mpool = NULL; 14036 } 14037 if (ts_params->session_priv_mpool) { 14038 rte_mempool_free(ts_params->session_priv_mpool); 14039 ts_params->session_priv_mpool = NULL; 14040 } 14041 14042 if (info.sym.max_nb_sessions != 0 && 14043 info.sym.max_nb_sessions < MAX_NB_SESSIONS) { 14044 RTE_LOG(ERR, USER1, 14045 "Device does not support " 14046 "at least %u sessions\n", 14047 MAX_NB_SESSIONS); 14048 return TEST_FAILED; 14049 } 14050 /* 14051 * Create mempool with maximum number of sessions, 14052 * to include the session headers 14053 */ 14054 if (ts_params->session_mpool == NULL) { 14055 ts_params->session_mpool = 14056 rte_cryptodev_sym_session_pool_create( 14057 "test_sess_mp", 14058 MAX_NB_SESSIONS, 0, 0, 0, 14059 SOCKET_ID_ANY); 14060 TEST_ASSERT_NOT_NULL(ts_params->session_mpool, 14061 "session mempool allocation failed"); 14062 } 14063 14064 /* 14065 * Create mempool with maximum number of sessions, 14066 * to include device specific session private data 14067 */ 14068 if (ts_params->session_priv_mpool == NULL) { 14069 ts_params->session_priv_mpool = rte_mempool_create( 14070 "test_sess_mp_priv", 14071 MAX_NB_SESSIONS, 14072 session_size, 14073 0, 0, NULL, NULL, NULL, 14074 NULL, SOCKET_ID_ANY, 14075 0); 14076 14077 TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool, 14078 "session mempool allocation failed"); 14079 } 14080 14081 ts_params->qp_conf.mp_session = ts_params->session_mpool; 14082 ts_params->qp_conf.mp_session_private = 14083 ts_params->session_priv_mpool; 14084 14085 ret = rte_cryptodev_scheduler_worker_attach(sched_id, 14086 (uint8_t)i); 14087 14088 TEST_ASSERT(ret == 0, 14089 "Failed to attach device %u of pmd : %s", i, 14090 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)); 14091 14092 aesni_ids[nb_devs_attached] = (uint8_t)i; 14093 14094 nb_devs_attached++; 14095 } 14096 14097 return 0; 14098 } 14099 14100 static int 14101 test_scheduler_detach_worker_op(void) 14102 { 14103 struct crypto_testsuite_params *ts_params = &testsuite_params; 14104 uint8_t sched_id = ts_params->valid_devs[0]; 14105 uint32_t i; 14106 int ret; 14107 14108 for (i = 0; i < 2; i++) { 14109 ret = rte_cryptodev_scheduler_worker_detach(sched_id, 14110 aesni_ids[i]); 14111 TEST_ASSERT(ret == 0, 14112 "Failed to detach device %u", aesni_ids[i]); 14113 } 14114 14115 return 0; 14116 } 14117 14118 static int 14119 test_scheduler_mode_op(enum rte_cryptodev_scheduler_mode scheduler_mode) 14120 { 14121 struct crypto_testsuite_params *ts_params = &testsuite_params; 14122 uint8_t sched_id = ts_params->valid_devs[0]; 14123 /* set mode */ 14124 return rte_cryptodev_scheduler_mode_set(sched_id, 14125 scheduler_mode); 14126 } 14127 14128 static int 14129 test_scheduler_mode_roundrobin_op(void) 14130 { 14131 TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) == 14132 0, "Failed to set roundrobin mode"); 14133 return 0; 14134 14135 } 14136 14137 static int 14138 test_scheduler_mode_multicore_op(void) 14139 { 14140 TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) == 14141 0, "Failed to set multicore mode"); 14142 14143 return 0; 14144 } 14145 14146 static int 14147 test_scheduler_mode_failover_op(void) 14148 { 14149 TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) == 14150 0, "Failed to set failover mode"); 14151 14152 return 0; 14153 } 14154 14155 static int 14156 test_scheduler_mode_pkt_size_distr_op(void) 14157 { 14158 TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) == 14159 0, "Failed to set pktsize mode"); 14160 14161 return 0; 14162 } 14163 14164 static int 14165 scheduler_multicore_testsuite_setup(void) 14166 { 14167 if (test_scheduler_attach_worker_op() < 0) 14168 return TEST_SKIPPED; 14169 if (test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) < 0) 14170 return TEST_SKIPPED; 14171 return 0; 14172 } 14173 14174 static int 14175 scheduler_roundrobin_testsuite_setup(void) 14176 { 14177 if (test_scheduler_attach_worker_op() < 0) 14178 return TEST_SKIPPED; 14179 if (test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) < 0) 14180 return TEST_SKIPPED; 14181 return 0; 14182 } 14183 14184 static int 14185 scheduler_failover_testsuite_setup(void) 14186 { 14187 if (test_scheduler_attach_worker_op() < 0) 14188 return TEST_SKIPPED; 14189 if (test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) < 0) 14190 return TEST_SKIPPED; 14191 return 0; 14192 } 14193 14194 static int 14195 scheduler_pkt_size_distr_testsuite_setup(void) 14196 { 14197 if (test_scheduler_attach_worker_op() < 0) 14198 return TEST_SKIPPED; 14199 if (test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) < 0) 14200 return TEST_SKIPPED; 14201 return 0; 14202 } 14203 14204 static void 14205 scheduler_mode_testsuite_teardown(void) 14206 { 14207 test_scheduler_detach_worker_op(); 14208 } 14209 14210 #endif /* RTE_CRYPTO_SCHEDULER */ 14211 14212 static struct unit_test_suite end_testsuite = { 14213 .suite_name = NULL, 14214 .setup = NULL, 14215 .teardown = NULL, 14216 .unit_test_suites = NULL 14217 }; 14218 14219 #ifdef RTE_LIB_SECURITY 14220 static struct unit_test_suite ipsec_proto_testsuite = { 14221 .suite_name = "IPsec Proto Unit Test Suite", 14222 .setup = ipsec_proto_testsuite_setup, 14223 .unit_test_cases = { 14224 TEST_CASE_NAMED_WITH_DATA( 14225 "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 128)", 14226 ut_setup_security, ut_teardown, 14227 test_ipsec_proto_known_vec, &pkt_aes_128_gcm), 14228 TEST_CASE_NAMED_WITH_DATA( 14229 "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 192)", 14230 ut_setup_security, ut_teardown, 14231 test_ipsec_proto_known_vec, &pkt_aes_192_gcm), 14232 TEST_CASE_NAMED_WITH_DATA( 14233 "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 256)", 14234 ut_setup_security, ut_teardown, 14235 test_ipsec_proto_known_vec, &pkt_aes_256_gcm), 14236 TEST_CASE_NAMED_WITH_DATA( 14237 "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 128)", 14238 ut_setup_security, ut_teardown, 14239 test_ipsec_proto_known_vec_inb, &pkt_aes_128_gcm), 14240 TEST_CASE_NAMED_WITH_DATA( 14241 "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 192)", 14242 ut_setup_security, ut_teardown, 14243 test_ipsec_proto_known_vec_inb, &pkt_aes_192_gcm), 14244 TEST_CASE_NAMED_WITH_DATA( 14245 "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 256)", 14246 ut_setup_security, ut_teardown, 14247 test_ipsec_proto_known_vec_inb, &pkt_aes_256_gcm), 14248 TEST_CASE_NAMED_ST( 14249 "Combined test alg list", 14250 ut_setup_security, ut_teardown, 14251 test_ipsec_proto_display_list), 14252 TEST_CASE_NAMED_ST( 14253 "IV generation", 14254 ut_setup_security, ut_teardown, 14255 test_ipsec_proto_iv_gen), 14256 TEST_CASE_NAMED_ST( 14257 "UDP encapsulation", 14258 ut_setup_security, ut_teardown, 14259 test_ipsec_proto_udp_encap), 14260 TEST_CASE_NAMED_ST( 14261 "UDP encapsulation ports verification test", 14262 ut_setup_security, ut_teardown, 14263 test_ipsec_proto_udp_ports_verify), 14264 TEST_CASE_NAMED_ST( 14265 "SA expiry packets soft", 14266 ut_setup_security, ut_teardown, 14267 test_ipsec_proto_sa_exp_pkts_soft), 14268 TEST_CASE_NAMED_ST( 14269 "SA expiry packets hard", 14270 ut_setup_security, ut_teardown, 14271 test_ipsec_proto_sa_exp_pkts_hard), 14272 TEST_CASE_NAMED_ST( 14273 "Negative test: ICV corruption", 14274 ut_setup_security, ut_teardown, 14275 test_ipsec_proto_err_icv_corrupt), 14276 TEST_CASE_NAMED_ST( 14277 "Tunnel dst addr verification", 14278 ut_setup_security, ut_teardown, 14279 test_ipsec_proto_tunnel_dst_addr_verify), 14280 TEST_CASE_NAMED_ST( 14281 "Tunnel src and dst addr verification", 14282 ut_setup_security, ut_teardown, 14283 test_ipsec_proto_tunnel_src_dst_addr_verify), 14284 TEST_CASE_NAMED_ST( 14285 "Inner IP checksum", 14286 ut_setup_security, ut_teardown, 14287 test_ipsec_proto_inner_ip_csum), 14288 TEST_CASE_NAMED_ST( 14289 "Inner L4 checksum", 14290 ut_setup_security, ut_teardown, 14291 test_ipsec_proto_inner_l4_csum), 14292 TEST_CASES_END() /**< NULL terminate unit test array */ 14293 } 14294 }; 14295 14296 static struct unit_test_suite pdcp_proto_testsuite = { 14297 .suite_name = "PDCP Proto Unit Test Suite", 14298 .setup = pdcp_proto_testsuite_setup, 14299 .unit_test_cases = { 14300 TEST_CASE_ST(ut_setup_security, ut_teardown, 14301 test_PDCP_PROTO_all), 14302 TEST_CASES_END() /**< NULL terminate unit test array */ 14303 } 14304 }; 14305 14306 static struct unit_test_suite docsis_proto_testsuite = { 14307 .suite_name = "Docsis Proto Unit Test Suite", 14308 .setup = docsis_proto_testsuite_setup, 14309 .unit_test_cases = { 14310 TEST_CASE_ST(ut_setup_security, ut_teardown, 14311 test_DOCSIS_PROTO_all), 14312 TEST_CASES_END() /**< NULL terminate unit test array */ 14313 } 14314 }; 14315 #endif 14316 14317 static struct unit_test_suite cryptodev_gen_testsuite = { 14318 .suite_name = "Crypto General Unit Test Suite", 14319 .setup = crypto_gen_testsuite_setup, 14320 .unit_test_cases = { 14321 TEST_CASE_ST(ut_setup, ut_teardown, 14322 test_device_configure_invalid_dev_id), 14323 TEST_CASE_ST(ut_setup, ut_teardown, 14324 test_queue_pair_descriptor_setup), 14325 TEST_CASE_ST(ut_setup, ut_teardown, 14326 test_device_configure_invalid_queue_pair_ids), 14327 TEST_CASE_ST(ut_setup, ut_teardown, test_stats), 14328 TEST_CASE_ST(ut_setup, ut_teardown, test_enq_callback_setup), 14329 TEST_CASE_ST(ut_setup, ut_teardown, test_deq_callback_setup), 14330 TEST_CASES_END() /**< NULL terminate unit test array */ 14331 } 14332 }; 14333 14334 static struct unit_test_suite cryptodev_negative_hmac_sha1_testsuite = { 14335 .suite_name = "Negative HMAC SHA1 Unit Test Suite", 14336 .setup = negative_hmac_sha1_testsuite_setup, 14337 .unit_test_cases = { 14338 /** Negative tests */ 14339 TEST_CASE_ST(ut_setup, ut_teardown, 14340 authentication_verify_HMAC_SHA1_fail_data_corrupt), 14341 TEST_CASE_ST(ut_setup, ut_teardown, 14342 authentication_verify_HMAC_SHA1_fail_tag_corrupt), 14343 TEST_CASE_ST(ut_setup, ut_teardown, 14344 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt), 14345 TEST_CASE_ST(ut_setup, ut_teardown, 14346 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt), 14347 14348 TEST_CASES_END() /**< NULL terminate unit test array */ 14349 } 14350 }; 14351 14352 static struct unit_test_suite cryptodev_multi_session_testsuite = { 14353 .suite_name = "Multi Session Unit Test Suite", 14354 .setup = multi_session_testsuite_setup, 14355 .unit_test_cases = { 14356 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session), 14357 TEST_CASE_ST(ut_setup, ut_teardown, 14358 test_multi_session_random_usage), 14359 14360 TEST_CASES_END() /**< NULL terminate unit test array */ 14361 } 14362 }; 14363 14364 static struct unit_test_suite cryptodev_null_testsuite = { 14365 .suite_name = "NULL Test Suite", 14366 .setup = null_testsuite_setup, 14367 .unit_test_cases = { 14368 TEST_CASE_ST(ut_setup, ut_teardown, 14369 test_null_invalid_operation), 14370 TEST_CASE_ST(ut_setup, ut_teardown, test_null_burst_operation), 14371 TEST_CASES_END() 14372 } 14373 }; 14374 14375 static struct unit_test_suite cryptodev_aes_ccm_auth_testsuite = { 14376 .suite_name = "AES CCM Authenticated Test Suite", 14377 .setup = aes_ccm_auth_testsuite_setup, 14378 .unit_test_cases = { 14379 /** AES CCM Authenticated Encryption 128 bits key*/ 14380 TEST_CASE_ST(ut_setup, ut_teardown, 14381 test_AES_CCM_authenticated_encryption_test_case_128_1), 14382 TEST_CASE_ST(ut_setup, ut_teardown, 14383 test_AES_CCM_authenticated_encryption_test_case_128_2), 14384 TEST_CASE_ST(ut_setup, ut_teardown, 14385 test_AES_CCM_authenticated_encryption_test_case_128_3), 14386 14387 /** AES CCM Authenticated Decryption 128 bits key*/ 14388 TEST_CASE_ST(ut_setup, ut_teardown, 14389 test_AES_CCM_authenticated_decryption_test_case_128_1), 14390 TEST_CASE_ST(ut_setup, ut_teardown, 14391 test_AES_CCM_authenticated_decryption_test_case_128_2), 14392 TEST_CASE_ST(ut_setup, ut_teardown, 14393 test_AES_CCM_authenticated_decryption_test_case_128_3), 14394 14395 /** AES CCM Authenticated Encryption 192 bits key */ 14396 TEST_CASE_ST(ut_setup, ut_teardown, 14397 test_AES_CCM_authenticated_encryption_test_case_192_1), 14398 TEST_CASE_ST(ut_setup, ut_teardown, 14399 test_AES_CCM_authenticated_encryption_test_case_192_2), 14400 TEST_CASE_ST(ut_setup, ut_teardown, 14401 test_AES_CCM_authenticated_encryption_test_case_192_3), 14402 14403 /** AES CCM Authenticated Decryption 192 bits key*/ 14404 TEST_CASE_ST(ut_setup, ut_teardown, 14405 test_AES_CCM_authenticated_decryption_test_case_192_1), 14406 TEST_CASE_ST(ut_setup, ut_teardown, 14407 test_AES_CCM_authenticated_decryption_test_case_192_2), 14408 TEST_CASE_ST(ut_setup, ut_teardown, 14409 test_AES_CCM_authenticated_decryption_test_case_192_3), 14410 14411 /** AES CCM Authenticated Encryption 256 bits key */ 14412 TEST_CASE_ST(ut_setup, ut_teardown, 14413 test_AES_CCM_authenticated_encryption_test_case_256_1), 14414 TEST_CASE_ST(ut_setup, ut_teardown, 14415 test_AES_CCM_authenticated_encryption_test_case_256_2), 14416 TEST_CASE_ST(ut_setup, ut_teardown, 14417 test_AES_CCM_authenticated_encryption_test_case_256_3), 14418 14419 /** AES CCM Authenticated Decryption 256 bits key*/ 14420 TEST_CASE_ST(ut_setup, ut_teardown, 14421 test_AES_CCM_authenticated_decryption_test_case_256_1), 14422 TEST_CASE_ST(ut_setup, ut_teardown, 14423 test_AES_CCM_authenticated_decryption_test_case_256_2), 14424 TEST_CASE_ST(ut_setup, ut_teardown, 14425 test_AES_CCM_authenticated_decryption_test_case_256_3), 14426 TEST_CASES_END() 14427 } 14428 }; 14429 14430 static struct unit_test_suite cryptodev_aes_gcm_auth_testsuite = { 14431 .suite_name = "AES GCM Authenticated Test Suite", 14432 .setup = aes_gcm_auth_testsuite_setup, 14433 .unit_test_cases = { 14434 /** AES GCM Authenticated Encryption */ 14435 TEST_CASE_ST(ut_setup, ut_teardown, 14436 test_AES_GCM_auth_encrypt_SGL_in_place_1500B), 14437 TEST_CASE_ST(ut_setup, ut_teardown, 14438 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B), 14439 TEST_CASE_ST(ut_setup, ut_teardown, 14440 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B), 14441 TEST_CASE_ST(ut_setup, ut_teardown, 14442 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg), 14443 TEST_CASE_ST(ut_setup, ut_teardown, 14444 test_AES_GCM_authenticated_encryption_test_case_1), 14445 TEST_CASE_ST(ut_setup, ut_teardown, 14446 test_AES_GCM_authenticated_encryption_test_case_2), 14447 TEST_CASE_ST(ut_setup, ut_teardown, 14448 test_AES_GCM_authenticated_encryption_test_case_3), 14449 TEST_CASE_ST(ut_setup, ut_teardown, 14450 test_AES_GCM_authenticated_encryption_test_case_4), 14451 TEST_CASE_ST(ut_setup, ut_teardown, 14452 test_AES_GCM_authenticated_encryption_test_case_5), 14453 TEST_CASE_ST(ut_setup, ut_teardown, 14454 test_AES_GCM_authenticated_encryption_test_case_6), 14455 TEST_CASE_ST(ut_setup, ut_teardown, 14456 test_AES_GCM_authenticated_encryption_test_case_7), 14457 TEST_CASE_ST(ut_setup, ut_teardown, 14458 test_AES_GCM_authenticated_encryption_test_case_8), 14459 TEST_CASE_ST(ut_setup, ut_teardown, 14460 test_AES_GCM_J0_authenticated_encryption_test_case_1), 14461 14462 /** AES GCM Authenticated Decryption */ 14463 TEST_CASE_ST(ut_setup, ut_teardown, 14464 test_AES_GCM_authenticated_decryption_test_case_1), 14465 TEST_CASE_ST(ut_setup, ut_teardown, 14466 test_AES_GCM_authenticated_decryption_test_case_2), 14467 TEST_CASE_ST(ut_setup, ut_teardown, 14468 test_AES_GCM_authenticated_decryption_test_case_3), 14469 TEST_CASE_ST(ut_setup, ut_teardown, 14470 test_AES_GCM_authenticated_decryption_test_case_4), 14471 TEST_CASE_ST(ut_setup, ut_teardown, 14472 test_AES_GCM_authenticated_decryption_test_case_5), 14473 TEST_CASE_ST(ut_setup, ut_teardown, 14474 test_AES_GCM_authenticated_decryption_test_case_6), 14475 TEST_CASE_ST(ut_setup, ut_teardown, 14476 test_AES_GCM_authenticated_decryption_test_case_7), 14477 TEST_CASE_ST(ut_setup, ut_teardown, 14478 test_AES_GCM_authenticated_decryption_test_case_8), 14479 TEST_CASE_ST(ut_setup, ut_teardown, 14480 test_AES_GCM_J0_authenticated_decryption_test_case_1), 14481 14482 /** AES GCM Authenticated Encryption 192 bits key */ 14483 TEST_CASE_ST(ut_setup, ut_teardown, 14484 test_AES_GCM_auth_encryption_test_case_192_1), 14485 TEST_CASE_ST(ut_setup, ut_teardown, 14486 test_AES_GCM_auth_encryption_test_case_192_2), 14487 TEST_CASE_ST(ut_setup, ut_teardown, 14488 test_AES_GCM_auth_encryption_test_case_192_3), 14489 TEST_CASE_ST(ut_setup, ut_teardown, 14490 test_AES_GCM_auth_encryption_test_case_192_4), 14491 TEST_CASE_ST(ut_setup, ut_teardown, 14492 test_AES_GCM_auth_encryption_test_case_192_5), 14493 TEST_CASE_ST(ut_setup, ut_teardown, 14494 test_AES_GCM_auth_encryption_test_case_192_6), 14495 TEST_CASE_ST(ut_setup, ut_teardown, 14496 test_AES_GCM_auth_encryption_test_case_192_7), 14497 14498 /** AES GCM Authenticated Decryption 192 bits key */ 14499 TEST_CASE_ST(ut_setup, ut_teardown, 14500 test_AES_GCM_auth_decryption_test_case_192_1), 14501 TEST_CASE_ST(ut_setup, ut_teardown, 14502 test_AES_GCM_auth_decryption_test_case_192_2), 14503 TEST_CASE_ST(ut_setup, ut_teardown, 14504 test_AES_GCM_auth_decryption_test_case_192_3), 14505 TEST_CASE_ST(ut_setup, ut_teardown, 14506 test_AES_GCM_auth_decryption_test_case_192_4), 14507 TEST_CASE_ST(ut_setup, ut_teardown, 14508 test_AES_GCM_auth_decryption_test_case_192_5), 14509 TEST_CASE_ST(ut_setup, ut_teardown, 14510 test_AES_GCM_auth_decryption_test_case_192_6), 14511 TEST_CASE_ST(ut_setup, ut_teardown, 14512 test_AES_GCM_auth_decryption_test_case_192_7), 14513 14514 /** AES GCM Authenticated Encryption 256 bits key */ 14515 TEST_CASE_ST(ut_setup, ut_teardown, 14516 test_AES_GCM_auth_encryption_test_case_256_1), 14517 TEST_CASE_ST(ut_setup, ut_teardown, 14518 test_AES_GCM_auth_encryption_test_case_256_2), 14519 TEST_CASE_ST(ut_setup, ut_teardown, 14520 test_AES_GCM_auth_encryption_test_case_256_3), 14521 TEST_CASE_ST(ut_setup, ut_teardown, 14522 test_AES_GCM_auth_encryption_test_case_256_4), 14523 TEST_CASE_ST(ut_setup, ut_teardown, 14524 test_AES_GCM_auth_encryption_test_case_256_5), 14525 TEST_CASE_ST(ut_setup, ut_teardown, 14526 test_AES_GCM_auth_encryption_test_case_256_6), 14527 TEST_CASE_ST(ut_setup, ut_teardown, 14528 test_AES_GCM_auth_encryption_test_case_256_7), 14529 14530 /** AES GCM Authenticated Decryption 256 bits key */ 14531 TEST_CASE_ST(ut_setup, ut_teardown, 14532 test_AES_GCM_auth_decryption_test_case_256_1), 14533 TEST_CASE_ST(ut_setup, ut_teardown, 14534 test_AES_GCM_auth_decryption_test_case_256_2), 14535 TEST_CASE_ST(ut_setup, ut_teardown, 14536 test_AES_GCM_auth_decryption_test_case_256_3), 14537 TEST_CASE_ST(ut_setup, ut_teardown, 14538 test_AES_GCM_auth_decryption_test_case_256_4), 14539 TEST_CASE_ST(ut_setup, ut_teardown, 14540 test_AES_GCM_auth_decryption_test_case_256_5), 14541 TEST_CASE_ST(ut_setup, ut_teardown, 14542 test_AES_GCM_auth_decryption_test_case_256_6), 14543 TEST_CASE_ST(ut_setup, ut_teardown, 14544 test_AES_GCM_auth_decryption_test_case_256_7), 14545 14546 /** AES GCM Authenticated Encryption big aad size */ 14547 TEST_CASE_ST(ut_setup, ut_teardown, 14548 test_AES_GCM_auth_encryption_test_case_aad_1), 14549 TEST_CASE_ST(ut_setup, ut_teardown, 14550 test_AES_GCM_auth_encryption_test_case_aad_2), 14551 14552 /** AES GCM Authenticated Decryption big aad size */ 14553 TEST_CASE_ST(ut_setup, ut_teardown, 14554 test_AES_GCM_auth_decryption_test_case_aad_1), 14555 TEST_CASE_ST(ut_setup, ut_teardown, 14556 test_AES_GCM_auth_decryption_test_case_aad_2), 14557 14558 /** Out of place tests */ 14559 TEST_CASE_ST(ut_setup, ut_teardown, 14560 test_AES_GCM_authenticated_encryption_oop_test_case_1), 14561 TEST_CASE_ST(ut_setup, ut_teardown, 14562 test_AES_GCM_authenticated_decryption_oop_test_case_1), 14563 14564 /** Session-less tests */ 14565 TEST_CASE_ST(ut_setup, ut_teardown, 14566 test_AES_GCM_authenticated_encryption_sessionless_test_case_1), 14567 TEST_CASE_ST(ut_setup, ut_teardown, 14568 test_AES_GCM_authenticated_decryption_sessionless_test_case_1), 14569 14570 TEST_CASES_END() 14571 } 14572 }; 14573 14574 static struct unit_test_suite cryptodev_aes_gmac_auth_testsuite = { 14575 .suite_name = "AES GMAC Authentication Test Suite", 14576 .setup = aes_gmac_auth_testsuite_setup, 14577 .unit_test_cases = { 14578 TEST_CASE_ST(ut_setup, ut_teardown, 14579 test_AES_GMAC_authentication_test_case_1), 14580 TEST_CASE_ST(ut_setup, ut_teardown, 14581 test_AES_GMAC_authentication_verify_test_case_1), 14582 TEST_CASE_ST(ut_setup, ut_teardown, 14583 test_AES_GMAC_authentication_test_case_2), 14584 TEST_CASE_ST(ut_setup, ut_teardown, 14585 test_AES_GMAC_authentication_verify_test_case_2), 14586 TEST_CASE_ST(ut_setup, ut_teardown, 14587 test_AES_GMAC_authentication_test_case_3), 14588 TEST_CASE_ST(ut_setup, ut_teardown, 14589 test_AES_GMAC_authentication_verify_test_case_3), 14590 TEST_CASE_ST(ut_setup, ut_teardown, 14591 test_AES_GMAC_authentication_test_case_4), 14592 TEST_CASE_ST(ut_setup, ut_teardown, 14593 test_AES_GMAC_authentication_verify_test_case_4), 14594 TEST_CASE_ST(ut_setup, ut_teardown, 14595 test_AES_GMAC_authentication_SGL_40B), 14596 TEST_CASE_ST(ut_setup, ut_teardown, 14597 test_AES_GMAC_authentication_SGL_80B), 14598 TEST_CASE_ST(ut_setup, ut_teardown, 14599 test_AES_GMAC_authentication_SGL_2048B), 14600 TEST_CASE_ST(ut_setup, ut_teardown, 14601 test_AES_GMAC_authentication_SGL_2047B), 14602 14603 TEST_CASES_END() 14604 } 14605 }; 14606 14607 static struct unit_test_suite cryptodev_chacha20_poly1305_testsuite = { 14608 .suite_name = "Chacha20-Poly1305 Test Suite", 14609 .setup = chacha20_poly1305_testsuite_setup, 14610 .unit_test_cases = { 14611 TEST_CASE_ST(ut_setup, ut_teardown, 14612 test_chacha20_poly1305_encrypt_test_case_rfc8439), 14613 TEST_CASE_ST(ut_setup, ut_teardown, 14614 test_chacha20_poly1305_decrypt_test_case_rfc8439), 14615 TEST_CASES_END() 14616 } 14617 }; 14618 14619 static struct unit_test_suite cryptodev_snow3g_testsuite = { 14620 .suite_name = "SNOW 3G Test Suite", 14621 .setup = snow3g_testsuite_setup, 14622 .unit_test_cases = { 14623 /** SNOW 3G encrypt only (UEA2) */ 14624 TEST_CASE_ST(ut_setup, ut_teardown, 14625 test_snow3g_encryption_test_case_1), 14626 TEST_CASE_ST(ut_setup, ut_teardown, 14627 test_snow3g_encryption_test_case_2), 14628 TEST_CASE_ST(ut_setup, ut_teardown, 14629 test_snow3g_encryption_test_case_3), 14630 TEST_CASE_ST(ut_setup, ut_teardown, 14631 test_snow3g_encryption_test_case_4), 14632 TEST_CASE_ST(ut_setup, ut_teardown, 14633 test_snow3g_encryption_test_case_5), 14634 14635 TEST_CASE_ST(ut_setup, ut_teardown, 14636 test_snow3g_encryption_test_case_1_oop), 14637 TEST_CASE_ST(ut_setup, ut_teardown, 14638 test_snow3g_encryption_test_case_1_oop_sgl), 14639 TEST_CASE_ST(ut_setup, ut_teardown, 14640 test_snow3g_encryption_test_case_1_offset_oop), 14641 TEST_CASE_ST(ut_setup, ut_teardown, 14642 test_snow3g_decryption_test_case_1_oop), 14643 14644 /** SNOW 3G generate auth, then encrypt (UEA2) */ 14645 TEST_CASE_ST(ut_setup, ut_teardown, 14646 test_snow3g_auth_cipher_test_case_1), 14647 TEST_CASE_ST(ut_setup, ut_teardown, 14648 test_snow3g_auth_cipher_test_case_2), 14649 TEST_CASE_ST(ut_setup, ut_teardown, 14650 test_snow3g_auth_cipher_test_case_2_oop), 14651 TEST_CASE_ST(ut_setup, ut_teardown, 14652 test_snow3g_auth_cipher_part_digest_enc), 14653 TEST_CASE_ST(ut_setup, ut_teardown, 14654 test_snow3g_auth_cipher_part_digest_enc_oop), 14655 TEST_CASE_ST(ut_setup, ut_teardown, 14656 test_snow3g_auth_cipher_test_case_3_sgl), 14657 TEST_CASE_ST(ut_setup, ut_teardown, 14658 test_snow3g_auth_cipher_test_case_3_oop_sgl), 14659 TEST_CASE_ST(ut_setup, ut_teardown, 14660 test_snow3g_auth_cipher_part_digest_enc_sgl), 14661 TEST_CASE_ST(ut_setup, ut_teardown, 14662 test_snow3g_auth_cipher_part_digest_enc_oop_sgl), 14663 14664 /** SNOW 3G decrypt (UEA2), then verify auth */ 14665 TEST_CASE_ST(ut_setup, ut_teardown, 14666 test_snow3g_auth_cipher_verify_test_case_1), 14667 TEST_CASE_ST(ut_setup, ut_teardown, 14668 test_snow3g_auth_cipher_verify_test_case_2), 14669 TEST_CASE_ST(ut_setup, ut_teardown, 14670 test_snow3g_auth_cipher_verify_test_case_2_oop), 14671 TEST_CASE_ST(ut_setup, ut_teardown, 14672 test_snow3g_auth_cipher_verify_part_digest_enc), 14673 TEST_CASE_ST(ut_setup, ut_teardown, 14674 test_snow3g_auth_cipher_verify_part_digest_enc_oop), 14675 TEST_CASE_ST(ut_setup, ut_teardown, 14676 test_snow3g_auth_cipher_verify_test_case_3_sgl), 14677 TEST_CASE_ST(ut_setup, ut_teardown, 14678 test_snow3g_auth_cipher_verify_test_case_3_oop_sgl), 14679 TEST_CASE_ST(ut_setup, ut_teardown, 14680 test_snow3g_auth_cipher_verify_part_digest_enc_sgl), 14681 TEST_CASE_ST(ut_setup, ut_teardown, 14682 test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl), 14683 14684 /** SNOW 3G decrypt only (UEA2) */ 14685 TEST_CASE_ST(ut_setup, ut_teardown, 14686 test_snow3g_decryption_test_case_1), 14687 TEST_CASE_ST(ut_setup, ut_teardown, 14688 test_snow3g_decryption_test_case_2), 14689 TEST_CASE_ST(ut_setup, ut_teardown, 14690 test_snow3g_decryption_test_case_3), 14691 TEST_CASE_ST(ut_setup, ut_teardown, 14692 test_snow3g_decryption_test_case_4), 14693 TEST_CASE_ST(ut_setup, ut_teardown, 14694 test_snow3g_decryption_test_case_5), 14695 TEST_CASE_ST(ut_setup, ut_teardown, 14696 test_snow3g_decryption_with_digest_test_case_1), 14697 TEST_CASE_ST(ut_setup, ut_teardown, 14698 test_snow3g_hash_generate_test_case_1), 14699 TEST_CASE_ST(ut_setup, ut_teardown, 14700 test_snow3g_hash_generate_test_case_2), 14701 TEST_CASE_ST(ut_setup, ut_teardown, 14702 test_snow3g_hash_generate_test_case_3), 14703 14704 /* Tests with buffers which length is not byte-aligned */ 14705 TEST_CASE_ST(ut_setup, ut_teardown, 14706 test_snow3g_hash_generate_test_case_4), 14707 TEST_CASE_ST(ut_setup, ut_teardown, 14708 test_snow3g_hash_generate_test_case_5), 14709 TEST_CASE_ST(ut_setup, ut_teardown, 14710 test_snow3g_hash_generate_test_case_6), 14711 TEST_CASE_ST(ut_setup, ut_teardown, 14712 test_snow3g_hash_verify_test_case_1), 14713 TEST_CASE_ST(ut_setup, ut_teardown, 14714 test_snow3g_hash_verify_test_case_2), 14715 TEST_CASE_ST(ut_setup, ut_teardown, 14716 test_snow3g_hash_verify_test_case_3), 14717 14718 /* Tests with buffers which length is not byte-aligned */ 14719 TEST_CASE_ST(ut_setup, ut_teardown, 14720 test_snow3g_hash_verify_test_case_4), 14721 TEST_CASE_ST(ut_setup, ut_teardown, 14722 test_snow3g_hash_verify_test_case_5), 14723 TEST_CASE_ST(ut_setup, ut_teardown, 14724 test_snow3g_hash_verify_test_case_6), 14725 TEST_CASE_ST(ut_setup, ut_teardown, 14726 test_snow3g_cipher_auth_test_case_1), 14727 TEST_CASE_ST(ut_setup, ut_teardown, 14728 test_snow3g_auth_cipher_with_digest_test_case_1), 14729 TEST_CASES_END() 14730 } 14731 }; 14732 14733 static struct unit_test_suite cryptodev_zuc_testsuite = { 14734 .suite_name = "ZUC Test Suite", 14735 .setup = zuc_testsuite_setup, 14736 .unit_test_cases = { 14737 /** ZUC encrypt only (EEA3) */ 14738 TEST_CASE_ST(ut_setup, ut_teardown, 14739 test_zuc_encryption_test_case_1), 14740 TEST_CASE_ST(ut_setup, ut_teardown, 14741 test_zuc_encryption_test_case_2), 14742 TEST_CASE_ST(ut_setup, ut_teardown, 14743 test_zuc_encryption_test_case_3), 14744 TEST_CASE_ST(ut_setup, ut_teardown, 14745 test_zuc_encryption_test_case_4), 14746 TEST_CASE_ST(ut_setup, ut_teardown, 14747 test_zuc_encryption_test_case_5), 14748 TEST_CASE_ST(ut_setup, ut_teardown, 14749 test_zuc_encryption_test_case_6_sgl), 14750 TEST_CASE_ST(ut_setup, ut_teardown, 14751 test_zuc_encryption_test_case_7), 14752 14753 /** ZUC authenticate (EIA3) */ 14754 TEST_CASE_ST(ut_setup, ut_teardown, 14755 test_zuc_hash_generate_test_case_1), 14756 TEST_CASE_ST(ut_setup, ut_teardown, 14757 test_zuc_hash_generate_test_case_2), 14758 TEST_CASE_ST(ut_setup, ut_teardown, 14759 test_zuc_hash_generate_test_case_3), 14760 TEST_CASE_ST(ut_setup, ut_teardown, 14761 test_zuc_hash_generate_test_case_4), 14762 TEST_CASE_ST(ut_setup, ut_teardown, 14763 test_zuc_hash_generate_test_case_5), 14764 TEST_CASE_ST(ut_setup, ut_teardown, 14765 test_zuc_hash_generate_test_case_6), 14766 TEST_CASE_ST(ut_setup, ut_teardown, 14767 test_zuc_hash_generate_test_case_7), 14768 TEST_CASE_ST(ut_setup, ut_teardown, 14769 test_zuc_hash_generate_test_case_8), 14770 TEST_CASE_ST(ut_setup, ut_teardown, 14771 test_zuc_hash_generate_test_case_9), 14772 TEST_CASE_ST(ut_setup, ut_teardown, 14773 test_zuc_hash_generate_test_case_10), 14774 14775 14776 /** ZUC alg-chain (EEA3/EIA3) */ 14777 TEST_CASE_ST(ut_setup, ut_teardown, 14778 test_zuc_cipher_auth_test_case_1), 14779 TEST_CASE_ST(ut_setup, ut_teardown, 14780 test_zuc_cipher_auth_test_case_2), 14781 14782 /** ZUC generate auth, then encrypt (EEA3) */ 14783 TEST_CASE_ST(ut_setup, ut_teardown, 14784 test_zuc_auth_cipher_test_case_1), 14785 TEST_CASE_ST(ut_setup, ut_teardown, 14786 test_zuc_auth_cipher_test_case_1_oop), 14787 TEST_CASE_ST(ut_setup, ut_teardown, 14788 test_zuc_auth_cipher_test_case_1_sgl), 14789 TEST_CASE_ST(ut_setup, ut_teardown, 14790 test_zuc_auth_cipher_test_case_1_oop_sgl), 14791 14792 /** ZUC decrypt (EEA3), then verify auth */ 14793 TEST_CASE_ST(ut_setup, ut_teardown, 14794 test_zuc_auth_cipher_verify_test_case_1), 14795 TEST_CASE_ST(ut_setup, ut_teardown, 14796 test_zuc_auth_cipher_verify_test_case_1_oop), 14797 TEST_CASE_ST(ut_setup, ut_teardown, 14798 test_zuc_auth_cipher_verify_test_case_1_sgl), 14799 TEST_CASE_ST(ut_setup, ut_teardown, 14800 test_zuc_auth_cipher_verify_test_case_1_oop_sgl), 14801 TEST_CASES_END() 14802 } 14803 }; 14804 14805 static struct unit_test_suite cryptodev_hmac_md5_auth_testsuite = { 14806 .suite_name = "HMAC_MD5 Authentication Test Suite", 14807 .setup = hmac_md5_auth_testsuite_setup, 14808 .unit_test_cases = { 14809 TEST_CASE_ST(ut_setup, ut_teardown, 14810 test_MD5_HMAC_generate_case_1), 14811 TEST_CASE_ST(ut_setup, ut_teardown, 14812 test_MD5_HMAC_verify_case_1), 14813 TEST_CASE_ST(ut_setup, ut_teardown, 14814 test_MD5_HMAC_generate_case_2), 14815 TEST_CASE_ST(ut_setup, ut_teardown, 14816 test_MD5_HMAC_verify_case_2), 14817 TEST_CASES_END() 14818 } 14819 }; 14820 14821 static struct unit_test_suite cryptodev_kasumi_testsuite = { 14822 .suite_name = "Kasumi Test Suite", 14823 .setup = kasumi_testsuite_setup, 14824 .unit_test_cases = { 14825 /** KASUMI hash only (UIA1) */ 14826 TEST_CASE_ST(ut_setup, ut_teardown, 14827 test_kasumi_hash_generate_test_case_1), 14828 TEST_CASE_ST(ut_setup, ut_teardown, 14829 test_kasumi_hash_generate_test_case_2), 14830 TEST_CASE_ST(ut_setup, ut_teardown, 14831 test_kasumi_hash_generate_test_case_3), 14832 TEST_CASE_ST(ut_setup, ut_teardown, 14833 test_kasumi_hash_generate_test_case_4), 14834 TEST_CASE_ST(ut_setup, ut_teardown, 14835 test_kasumi_hash_generate_test_case_5), 14836 TEST_CASE_ST(ut_setup, ut_teardown, 14837 test_kasumi_hash_generate_test_case_6), 14838 14839 TEST_CASE_ST(ut_setup, ut_teardown, 14840 test_kasumi_hash_verify_test_case_1), 14841 TEST_CASE_ST(ut_setup, ut_teardown, 14842 test_kasumi_hash_verify_test_case_2), 14843 TEST_CASE_ST(ut_setup, ut_teardown, 14844 test_kasumi_hash_verify_test_case_3), 14845 TEST_CASE_ST(ut_setup, ut_teardown, 14846 test_kasumi_hash_verify_test_case_4), 14847 TEST_CASE_ST(ut_setup, ut_teardown, 14848 test_kasumi_hash_verify_test_case_5), 14849 14850 /** KASUMI encrypt only (UEA1) */ 14851 TEST_CASE_ST(ut_setup, ut_teardown, 14852 test_kasumi_encryption_test_case_1), 14853 TEST_CASE_ST(ut_setup, ut_teardown, 14854 test_kasumi_encryption_test_case_1_sgl), 14855 TEST_CASE_ST(ut_setup, ut_teardown, 14856 test_kasumi_encryption_test_case_1_oop), 14857 TEST_CASE_ST(ut_setup, ut_teardown, 14858 test_kasumi_encryption_test_case_1_oop_sgl), 14859 TEST_CASE_ST(ut_setup, ut_teardown, 14860 test_kasumi_encryption_test_case_2), 14861 TEST_CASE_ST(ut_setup, ut_teardown, 14862 test_kasumi_encryption_test_case_3), 14863 TEST_CASE_ST(ut_setup, ut_teardown, 14864 test_kasumi_encryption_test_case_4), 14865 TEST_CASE_ST(ut_setup, ut_teardown, 14866 test_kasumi_encryption_test_case_5), 14867 14868 /** KASUMI decrypt only (UEA1) */ 14869 TEST_CASE_ST(ut_setup, ut_teardown, 14870 test_kasumi_decryption_test_case_1), 14871 TEST_CASE_ST(ut_setup, ut_teardown, 14872 test_kasumi_decryption_test_case_2), 14873 TEST_CASE_ST(ut_setup, ut_teardown, 14874 test_kasumi_decryption_test_case_3), 14875 TEST_CASE_ST(ut_setup, ut_teardown, 14876 test_kasumi_decryption_test_case_4), 14877 TEST_CASE_ST(ut_setup, ut_teardown, 14878 test_kasumi_decryption_test_case_5), 14879 TEST_CASE_ST(ut_setup, ut_teardown, 14880 test_kasumi_decryption_test_case_1_oop), 14881 TEST_CASE_ST(ut_setup, ut_teardown, 14882 test_kasumi_cipher_auth_test_case_1), 14883 14884 /** KASUMI generate auth, then encrypt (F8) */ 14885 TEST_CASE_ST(ut_setup, ut_teardown, 14886 test_kasumi_auth_cipher_test_case_1), 14887 TEST_CASE_ST(ut_setup, ut_teardown, 14888 test_kasumi_auth_cipher_test_case_2), 14889 TEST_CASE_ST(ut_setup, ut_teardown, 14890 test_kasumi_auth_cipher_test_case_2_oop), 14891 TEST_CASE_ST(ut_setup, ut_teardown, 14892 test_kasumi_auth_cipher_test_case_2_sgl), 14893 TEST_CASE_ST(ut_setup, ut_teardown, 14894 test_kasumi_auth_cipher_test_case_2_oop_sgl), 14895 14896 /** KASUMI decrypt (F8), then verify auth */ 14897 TEST_CASE_ST(ut_setup, ut_teardown, 14898 test_kasumi_auth_cipher_verify_test_case_1), 14899 TEST_CASE_ST(ut_setup, ut_teardown, 14900 test_kasumi_auth_cipher_verify_test_case_2), 14901 TEST_CASE_ST(ut_setup, ut_teardown, 14902 test_kasumi_auth_cipher_verify_test_case_2_oop), 14903 TEST_CASE_ST(ut_setup, ut_teardown, 14904 test_kasumi_auth_cipher_verify_test_case_2_sgl), 14905 TEST_CASE_ST(ut_setup, ut_teardown, 14906 test_kasumi_auth_cipher_verify_test_case_2_oop_sgl), 14907 14908 TEST_CASES_END() 14909 } 14910 }; 14911 14912 static struct unit_test_suite cryptodev_esn_testsuite = { 14913 .suite_name = "ESN Test Suite", 14914 .setup = esn_testsuite_setup, 14915 .unit_test_cases = { 14916 TEST_CASE_ST(ut_setup, ut_teardown, 14917 auth_encrypt_AES128CBC_HMAC_SHA1_esn_check), 14918 TEST_CASE_ST(ut_setup, ut_teardown, 14919 auth_decrypt_AES128CBC_HMAC_SHA1_esn_check), 14920 TEST_CASES_END() 14921 } 14922 }; 14923 14924 static struct unit_test_suite cryptodev_negative_aes_gcm_testsuite = { 14925 .suite_name = "Negative AES GCM Test Suite", 14926 .setup = negative_aes_gcm_testsuite_setup, 14927 .unit_test_cases = { 14928 TEST_CASE_ST(ut_setup, ut_teardown, 14929 test_AES_GCM_auth_encryption_fail_iv_corrupt), 14930 TEST_CASE_ST(ut_setup, ut_teardown, 14931 test_AES_GCM_auth_encryption_fail_in_data_corrupt), 14932 TEST_CASE_ST(ut_setup, ut_teardown, 14933 test_AES_GCM_auth_encryption_fail_out_data_corrupt), 14934 TEST_CASE_ST(ut_setup, ut_teardown, 14935 test_AES_GCM_auth_encryption_fail_aad_len_corrupt), 14936 TEST_CASE_ST(ut_setup, ut_teardown, 14937 test_AES_GCM_auth_encryption_fail_aad_corrupt), 14938 TEST_CASE_ST(ut_setup, ut_teardown, 14939 test_AES_GCM_auth_encryption_fail_tag_corrupt), 14940 TEST_CASE_ST(ut_setup, ut_teardown, 14941 test_AES_GCM_auth_decryption_fail_iv_corrupt), 14942 TEST_CASE_ST(ut_setup, ut_teardown, 14943 test_AES_GCM_auth_decryption_fail_in_data_corrupt), 14944 TEST_CASE_ST(ut_setup, ut_teardown, 14945 test_AES_GCM_auth_decryption_fail_out_data_corrupt), 14946 TEST_CASE_ST(ut_setup, ut_teardown, 14947 test_AES_GCM_auth_decryption_fail_aad_len_corrupt), 14948 TEST_CASE_ST(ut_setup, ut_teardown, 14949 test_AES_GCM_auth_decryption_fail_aad_corrupt), 14950 TEST_CASE_ST(ut_setup, ut_teardown, 14951 test_AES_GCM_auth_decryption_fail_tag_corrupt), 14952 14953 TEST_CASES_END() 14954 } 14955 }; 14956 14957 static struct unit_test_suite cryptodev_negative_aes_gmac_testsuite = { 14958 .suite_name = "Negative AES GMAC Test Suite", 14959 .setup = negative_aes_gmac_testsuite_setup, 14960 .unit_test_cases = { 14961 TEST_CASE_ST(ut_setup, ut_teardown, 14962 authentication_verify_AES128_GMAC_fail_data_corrupt), 14963 TEST_CASE_ST(ut_setup, ut_teardown, 14964 authentication_verify_AES128_GMAC_fail_tag_corrupt), 14965 14966 TEST_CASES_END() 14967 } 14968 }; 14969 14970 static struct unit_test_suite cryptodev_mixed_cipher_hash_testsuite = { 14971 .suite_name = "Mixed CIPHER + HASH algorithms Test Suite", 14972 .setup = mixed_cipher_hash_testsuite_setup, 14973 .unit_test_cases = { 14974 /** AUTH AES CMAC + CIPHER AES CTR */ 14975 TEST_CASE_ST(ut_setup, ut_teardown, 14976 test_aes_cmac_aes_ctr_digest_enc_test_case_1), 14977 TEST_CASE_ST(ut_setup, ut_teardown, 14978 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop), 14979 TEST_CASE_ST(ut_setup, ut_teardown, 14980 test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl), 14981 TEST_CASE_ST(ut_setup, ut_teardown, 14982 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl), 14983 TEST_CASE_ST(ut_setup, ut_teardown, 14984 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1), 14985 TEST_CASE_ST(ut_setup, ut_teardown, 14986 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop), 14987 TEST_CASE_ST(ut_setup, ut_teardown, 14988 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl), 14989 TEST_CASE_ST(ut_setup, ut_teardown, 14990 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl), 14991 14992 /** AUTH ZUC + CIPHER SNOW3G */ 14993 TEST_CASE_ST(ut_setup, ut_teardown, 14994 test_auth_zuc_cipher_snow_test_case_1), 14995 TEST_CASE_ST(ut_setup, ut_teardown, 14996 test_verify_auth_zuc_cipher_snow_test_case_1), 14997 /** AUTH AES CMAC + CIPHER SNOW3G */ 14998 TEST_CASE_ST(ut_setup, ut_teardown, 14999 test_auth_aes_cmac_cipher_snow_test_case_1), 15000 TEST_CASE_ST(ut_setup, ut_teardown, 15001 test_verify_auth_aes_cmac_cipher_snow_test_case_1), 15002 /** AUTH ZUC + CIPHER AES CTR */ 15003 TEST_CASE_ST(ut_setup, ut_teardown, 15004 test_auth_zuc_cipher_aes_ctr_test_case_1), 15005 TEST_CASE_ST(ut_setup, ut_teardown, 15006 test_verify_auth_zuc_cipher_aes_ctr_test_case_1), 15007 /** AUTH SNOW3G + CIPHER AES CTR */ 15008 TEST_CASE_ST(ut_setup, ut_teardown, 15009 test_auth_snow_cipher_aes_ctr_test_case_1), 15010 TEST_CASE_ST(ut_setup, ut_teardown, 15011 test_verify_auth_snow_cipher_aes_ctr_test_case_1), 15012 /** AUTH SNOW3G + CIPHER ZUC */ 15013 TEST_CASE_ST(ut_setup, ut_teardown, 15014 test_auth_snow_cipher_zuc_test_case_1), 15015 TEST_CASE_ST(ut_setup, ut_teardown, 15016 test_verify_auth_snow_cipher_zuc_test_case_1), 15017 /** AUTH AES CMAC + CIPHER ZUC */ 15018 TEST_CASE_ST(ut_setup, ut_teardown, 15019 test_auth_aes_cmac_cipher_zuc_test_case_1), 15020 TEST_CASE_ST(ut_setup, ut_teardown, 15021 test_verify_auth_aes_cmac_cipher_zuc_test_case_1), 15022 15023 /** AUTH NULL + CIPHER SNOW3G */ 15024 TEST_CASE_ST(ut_setup, ut_teardown, 15025 test_auth_null_cipher_snow_test_case_1), 15026 TEST_CASE_ST(ut_setup, ut_teardown, 15027 test_verify_auth_null_cipher_snow_test_case_1), 15028 /** AUTH NULL + CIPHER ZUC */ 15029 TEST_CASE_ST(ut_setup, ut_teardown, 15030 test_auth_null_cipher_zuc_test_case_1), 15031 TEST_CASE_ST(ut_setup, ut_teardown, 15032 test_verify_auth_null_cipher_zuc_test_case_1), 15033 /** AUTH SNOW3G + CIPHER NULL */ 15034 TEST_CASE_ST(ut_setup, ut_teardown, 15035 test_auth_snow_cipher_null_test_case_1), 15036 TEST_CASE_ST(ut_setup, ut_teardown, 15037 test_verify_auth_snow_cipher_null_test_case_1), 15038 /** AUTH ZUC + CIPHER NULL */ 15039 TEST_CASE_ST(ut_setup, ut_teardown, 15040 test_auth_zuc_cipher_null_test_case_1), 15041 TEST_CASE_ST(ut_setup, ut_teardown, 15042 test_verify_auth_zuc_cipher_null_test_case_1), 15043 /** AUTH NULL + CIPHER AES CTR */ 15044 TEST_CASE_ST(ut_setup, ut_teardown, 15045 test_auth_null_cipher_aes_ctr_test_case_1), 15046 TEST_CASE_ST(ut_setup, ut_teardown, 15047 test_verify_auth_null_cipher_aes_ctr_test_case_1), 15048 /** AUTH AES CMAC + CIPHER NULL */ 15049 TEST_CASE_ST(ut_setup, ut_teardown, 15050 test_auth_aes_cmac_cipher_null_test_case_1), 15051 TEST_CASE_ST(ut_setup, ut_teardown, 15052 test_verify_auth_aes_cmac_cipher_null_test_case_1), 15053 TEST_CASES_END() 15054 } 15055 }; 15056 15057 static int 15058 run_cryptodev_testsuite(const char *pmd_name) 15059 { 15060 uint8_t ret, j, i = 0, blk_start_idx = 0; 15061 const enum blockcipher_test_type blk_suites[] = { 15062 BLKCIPHER_AES_CHAIN_TYPE, 15063 BLKCIPHER_AES_CIPHERONLY_TYPE, 15064 BLKCIPHER_AES_DOCSIS_TYPE, 15065 BLKCIPHER_3DES_CHAIN_TYPE, 15066 BLKCIPHER_3DES_CIPHERONLY_TYPE, 15067 BLKCIPHER_DES_CIPHERONLY_TYPE, 15068 BLKCIPHER_DES_DOCSIS_TYPE, 15069 BLKCIPHER_AUTHONLY_TYPE}; 15070 struct unit_test_suite *static_suites[] = { 15071 &cryptodev_multi_session_testsuite, 15072 &cryptodev_null_testsuite, 15073 &cryptodev_aes_ccm_auth_testsuite, 15074 &cryptodev_aes_gcm_auth_testsuite, 15075 &cryptodev_aes_gmac_auth_testsuite, 15076 &cryptodev_snow3g_testsuite, 15077 &cryptodev_chacha20_poly1305_testsuite, 15078 &cryptodev_zuc_testsuite, 15079 &cryptodev_hmac_md5_auth_testsuite, 15080 &cryptodev_kasumi_testsuite, 15081 &cryptodev_esn_testsuite, 15082 &cryptodev_negative_aes_gcm_testsuite, 15083 &cryptodev_negative_aes_gmac_testsuite, 15084 &cryptodev_mixed_cipher_hash_testsuite, 15085 &cryptodev_negative_hmac_sha1_testsuite, 15086 &cryptodev_gen_testsuite, 15087 #ifdef RTE_LIB_SECURITY 15088 &ipsec_proto_testsuite, 15089 &pdcp_proto_testsuite, 15090 &docsis_proto_testsuite, 15091 #endif 15092 &end_testsuite 15093 }; 15094 static struct unit_test_suite ts = { 15095 .suite_name = "Cryptodev Unit Test Suite", 15096 .setup = testsuite_setup, 15097 .teardown = testsuite_teardown, 15098 .unit_test_cases = {TEST_CASES_END()} 15099 }; 15100 15101 gbl_driver_id = rte_cryptodev_driver_id_get(pmd_name); 15102 15103 if (gbl_driver_id == -1) { 15104 RTE_LOG(ERR, USER1, "%s PMD must be loaded.\n", pmd_name); 15105 return TEST_SKIPPED; 15106 } 15107 15108 ts.unit_test_suites = malloc(sizeof(struct unit_test_suite *) * 15109 (RTE_DIM(blk_suites) + RTE_DIM(static_suites))); 15110 15111 ADD_BLOCKCIPHER_TESTSUITE(i, ts, blk_suites, RTE_DIM(blk_suites)); 15112 ADD_STATIC_TESTSUITE(i, ts, static_suites, RTE_DIM(static_suites)); 15113 ret = unit_test_suite_runner(&ts); 15114 15115 FREE_BLOCKCIPHER_TESTSUITE(blk_start_idx, ts, RTE_DIM(blk_suites)); 15116 free(ts.unit_test_suites); 15117 return ret; 15118 } 15119 15120 static int 15121 require_feature_flag(const char *pmd_name, uint64_t flag, const char *flag_name) 15122 { 15123 struct rte_cryptodev_info dev_info; 15124 uint8_t i, nb_devs; 15125 int driver_id; 15126 15127 driver_id = rte_cryptodev_driver_id_get(pmd_name); 15128 if (driver_id == -1) { 15129 RTE_LOG(WARNING, USER1, "%s PMD must be loaded.\n", pmd_name); 15130 return TEST_SKIPPED; 15131 } 15132 15133 nb_devs = rte_cryptodev_count(); 15134 if (nb_devs < 1) { 15135 RTE_LOG(WARNING, USER1, "No crypto devices found?\n"); 15136 return TEST_SKIPPED; 15137 } 15138 15139 for (i = 0; i < nb_devs; i++) { 15140 rte_cryptodev_info_get(i, &dev_info); 15141 if (dev_info.driver_id == driver_id) { 15142 if (!(dev_info.feature_flags & flag)) { 15143 RTE_LOG(INFO, USER1, "%s not supported\n", 15144 flag_name); 15145 return TEST_SKIPPED; 15146 } 15147 return 0; /* found */ 15148 } 15149 } 15150 15151 RTE_LOG(INFO, USER1, "%s not supported\n", flag_name); 15152 return TEST_SKIPPED; 15153 } 15154 15155 static int 15156 test_cryptodev_qat(void) 15157 { 15158 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)); 15159 } 15160 15161 static int 15162 test_cryptodev_virtio(void) 15163 { 15164 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD)); 15165 } 15166 15167 static int 15168 test_cryptodev_aesni_mb(void) 15169 { 15170 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)); 15171 } 15172 15173 static int 15174 test_cryptodev_cpu_aesni_mb(void) 15175 { 15176 int32_t rc; 15177 enum rte_security_session_action_type at = gbl_action_type; 15178 gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO; 15179 rc = run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)); 15180 gbl_action_type = at; 15181 return rc; 15182 } 15183 15184 static int 15185 test_cryptodev_openssl(void) 15186 { 15187 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)); 15188 } 15189 15190 static int 15191 test_cryptodev_aesni_gcm(void) 15192 { 15193 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD)); 15194 } 15195 15196 static int 15197 test_cryptodev_cpu_aesni_gcm(void) 15198 { 15199 int32_t rc; 15200 enum rte_security_session_action_type at = gbl_action_type; 15201 gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO; 15202 rc = run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD)); 15203 gbl_action_type = at; 15204 return rc; 15205 } 15206 15207 static int 15208 test_cryptodev_mlx5(void) 15209 { 15210 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_MLX5_PMD)); 15211 } 15212 15213 static int 15214 test_cryptodev_null(void) 15215 { 15216 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_NULL_PMD)); 15217 } 15218 15219 static int 15220 test_cryptodev_sw_snow3g(void) 15221 { 15222 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD)); 15223 } 15224 15225 static int 15226 test_cryptodev_sw_kasumi(void) 15227 { 15228 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_KASUMI_PMD)); 15229 } 15230 15231 static int 15232 test_cryptodev_sw_zuc(void) 15233 { 15234 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_ZUC_PMD)); 15235 } 15236 15237 static int 15238 test_cryptodev_armv8(void) 15239 { 15240 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_ARMV8_PMD)); 15241 } 15242 15243 static int 15244 test_cryptodev_mrvl(void) 15245 { 15246 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)); 15247 } 15248 15249 #ifdef RTE_CRYPTO_SCHEDULER 15250 15251 static int 15252 test_cryptodev_scheduler(void) 15253 { 15254 uint8_t ret, sched_i, j, i = 0, blk_start_idx = 0; 15255 const enum blockcipher_test_type blk_suites[] = { 15256 BLKCIPHER_AES_CHAIN_TYPE, 15257 BLKCIPHER_AES_CIPHERONLY_TYPE, 15258 BLKCIPHER_AUTHONLY_TYPE 15259 }; 15260 static struct unit_test_suite scheduler_multicore = { 15261 .suite_name = "Scheduler Multicore Unit Test Suite", 15262 .setup = scheduler_multicore_testsuite_setup, 15263 .teardown = scheduler_mode_testsuite_teardown, 15264 .unit_test_cases = {TEST_CASES_END()} 15265 }; 15266 static struct unit_test_suite scheduler_round_robin = { 15267 .suite_name = "Scheduler Round Robin Unit Test Suite", 15268 .setup = scheduler_roundrobin_testsuite_setup, 15269 .teardown = scheduler_mode_testsuite_teardown, 15270 .unit_test_cases = {TEST_CASES_END()} 15271 }; 15272 static struct unit_test_suite scheduler_failover = { 15273 .suite_name = "Scheduler Failover Unit Test Suite", 15274 .setup = scheduler_failover_testsuite_setup, 15275 .teardown = scheduler_mode_testsuite_teardown, 15276 .unit_test_cases = {TEST_CASES_END()} 15277 }; 15278 static struct unit_test_suite scheduler_pkt_size_distr = { 15279 .suite_name = "Scheduler Pkt Size Distr Unit Test Suite", 15280 .setup = scheduler_pkt_size_distr_testsuite_setup, 15281 .teardown = scheduler_mode_testsuite_teardown, 15282 .unit_test_cases = {TEST_CASES_END()} 15283 }; 15284 struct unit_test_suite *sched_mode_suites[] = { 15285 &scheduler_multicore, 15286 &scheduler_round_robin, 15287 &scheduler_failover, 15288 &scheduler_pkt_size_distr 15289 }; 15290 static struct unit_test_suite scheduler_config = { 15291 .suite_name = "Crypto Device Scheduler Config Unit Test Suite", 15292 .unit_test_cases = { 15293 TEST_CASE(test_scheduler_attach_worker_op), 15294 TEST_CASE(test_scheduler_mode_multicore_op), 15295 TEST_CASE(test_scheduler_mode_roundrobin_op), 15296 TEST_CASE(test_scheduler_mode_failover_op), 15297 TEST_CASE(test_scheduler_mode_pkt_size_distr_op), 15298 TEST_CASE(test_scheduler_detach_worker_op), 15299 15300 TEST_CASES_END() /**< NULL terminate array */ 15301 } 15302 }; 15303 struct unit_test_suite *static_suites[] = { 15304 &scheduler_config, 15305 &end_testsuite 15306 }; 15307 static struct unit_test_suite ts = { 15308 .suite_name = "Scheduler Unit Test Suite", 15309 .setup = scheduler_testsuite_setup, 15310 .teardown = testsuite_teardown, 15311 .unit_test_cases = {TEST_CASES_END()} 15312 }; 15313 15314 gbl_driver_id = rte_cryptodev_driver_id_get( 15315 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)); 15316 15317 if (gbl_driver_id == -1) { 15318 RTE_LOG(ERR, USER1, "SCHEDULER PMD must be loaded.\n"); 15319 return TEST_SKIPPED; 15320 } 15321 15322 if (rte_cryptodev_driver_id_get( 15323 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) == -1) { 15324 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded.\n"); 15325 return TEST_SKIPPED; 15326 } 15327 15328 for (sched_i = 0; sched_i < RTE_DIM(sched_mode_suites); sched_i++) { 15329 uint8_t blk_i = 0; 15330 sched_mode_suites[sched_i]->unit_test_suites = malloc(sizeof 15331 (struct unit_test_suite *) * 15332 (RTE_DIM(blk_suites) + 1)); 15333 ADD_BLOCKCIPHER_TESTSUITE(blk_i, (*sched_mode_suites[sched_i]), 15334 blk_suites, RTE_DIM(blk_suites)); 15335 sched_mode_suites[sched_i]->unit_test_suites[blk_i] = &end_testsuite; 15336 } 15337 15338 ts.unit_test_suites = malloc(sizeof(struct unit_test_suite *) * 15339 (RTE_DIM(static_suites) + RTE_DIM(sched_mode_suites))); 15340 ADD_STATIC_TESTSUITE(i, ts, sched_mode_suites, 15341 RTE_DIM(sched_mode_suites)); 15342 ADD_STATIC_TESTSUITE(i, ts, static_suites, RTE_DIM(static_suites)); 15343 ret = unit_test_suite_runner(&ts); 15344 15345 for (sched_i = 0; sched_i < RTE_DIM(sched_mode_suites); sched_i++) { 15346 FREE_BLOCKCIPHER_TESTSUITE(blk_start_idx, 15347 (*sched_mode_suites[sched_i]), 15348 RTE_DIM(blk_suites)); 15349 free(sched_mode_suites[sched_i]->unit_test_suites); 15350 } 15351 free(ts.unit_test_suites); 15352 return ret; 15353 } 15354 15355 REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler); 15356 15357 #endif 15358 15359 static int 15360 test_cryptodev_dpaa2_sec(void) 15361 { 15362 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)); 15363 } 15364 15365 static int 15366 test_cryptodev_dpaa_sec(void) 15367 { 15368 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)); 15369 } 15370 15371 static int 15372 test_cryptodev_ccp(void) 15373 { 15374 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CCP_PMD)); 15375 } 15376 15377 static int 15378 test_cryptodev_octeontx(void) 15379 { 15380 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)); 15381 } 15382 15383 static int 15384 test_cryptodev_octeontx2(void) 15385 { 15386 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OCTEONTX2_PMD)); 15387 } 15388 15389 static int 15390 test_cryptodev_caam_jr(void) 15391 { 15392 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)); 15393 } 15394 15395 static int 15396 test_cryptodev_nitrox(void) 15397 { 15398 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_NITROX_PMD)); 15399 } 15400 15401 static int 15402 test_cryptodev_bcmfs(void) 15403 { 15404 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_BCMFS_PMD)); 15405 } 15406 15407 static int 15408 test_cryptodev_qat_raw_api(void) 15409 { 15410 static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD); 15411 int ret; 15412 15413 ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP, 15414 "RAW API"); 15415 if (ret) 15416 return ret; 15417 15418 global_api_test_type = CRYPTODEV_RAW_API_TEST; 15419 ret = run_cryptodev_testsuite(pmd_name); 15420 global_api_test_type = CRYPTODEV_API_TEST; 15421 15422 return ret; 15423 } 15424 15425 static int 15426 test_cryptodev_cn9k(void) 15427 { 15428 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CN9K_PMD)); 15429 } 15430 15431 static int 15432 test_cryptodev_cn10k(void) 15433 { 15434 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CN10K_PMD)); 15435 } 15436 15437 REGISTER_TEST_COMMAND(cryptodev_qat_raw_api_autotest, 15438 test_cryptodev_qat_raw_api); 15439 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat); 15440 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb); 15441 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_mb_autotest, 15442 test_cryptodev_cpu_aesni_mb); 15443 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl); 15444 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm); 15445 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_gcm_autotest, 15446 test_cryptodev_cpu_aesni_gcm); 15447 REGISTER_TEST_COMMAND(cryptodev_mlx5_autotest, test_cryptodev_mlx5); 15448 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null); 15449 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g); 15450 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi); 15451 REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc); 15452 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_autotest, test_cryptodev_armv8); 15453 REGISTER_TEST_COMMAND(cryptodev_sw_mvsam_autotest, test_cryptodev_mrvl); 15454 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_autotest, test_cryptodev_dpaa2_sec); 15455 REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_autotest, test_cryptodev_dpaa_sec); 15456 REGISTER_TEST_COMMAND(cryptodev_ccp_autotest, test_cryptodev_ccp); 15457 REGISTER_TEST_COMMAND(cryptodev_virtio_autotest, test_cryptodev_virtio); 15458 REGISTER_TEST_COMMAND(cryptodev_octeontx_autotest, test_cryptodev_octeontx); 15459 REGISTER_TEST_COMMAND(cryptodev_octeontx2_autotest, test_cryptodev_octeontx2); 15460 REGISTER_TEST_COMMAND(cryptodev_caam_jr_autotest, test_cryptodev_caam_jr); 15461 REGISTER_TEST_COMMAND(cryptodev_nitrox_autotest, test_cryptodev_nitrox); 15462 REGISTER_TEST_COMMAND(cryptodev_bcmfs_autotest, test_cryptodev_bcmfs); 15463 REGISTER_TEST_COMMAND(cryptodev_cn9k_autotest, test_cryptodev_cn9k); 15464 REGISTER_TEST_COMMAND(cryptodev_cn10k_autotest, test_cryptodev_cn10k); 15465