1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2015-2017 Intel Corporation 3 */ 4 5 #ifndef RTE_EXEC_ENV_WINDOWS 6 7 #include <rte_common.h> 8 #include <rte_hexdump.h> 9 #include <rte_mbuf.h> 10 #include <rte_malloc.h> 11 #include <rte_memcpy.h> 12 #include <rte_pause.h> 13 14 #include <rte_crypto.h> 15 #include <rte_cryptodev.h> 16 17 #include "test.h" 18 #include "test_cryptodev.h" 19 #include "test_cryptodev_blockcipher.h" 20 #include "test_cryptodev_aes_test_vectors.h" 21 #include "test_cryptodev_des_test_vectors.h" 22 #include "test_cryptodev_hash_test_vectors.h" 23 24 static int 25 verify_algo_support(const struct blockcipher_test_case *t, 26 const uint8_t dev_id, const uint32_t digest_len) 27 { 28 int ret = 0; 29 const struct blockcipher_test_data *tdata = t->test_data; 30 struct rte_cryptodev_sym_capability_idx cap_idx; 31 const struct rte_cryptodev_symmetric_capability *capability; 32 33 if (t->op_mask & BLOCKCIPHER_TEST_OP_CIPHER) { 34 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 35 cap_idx.algo.cipher = tdata->crypto_algo; 36 capability = rte_cryptodev_sym_capability_get(dev_id, &cap_idx); 37 if (capability == NULL) 38 return -1; 39 40 if (cap_idx.algo.cipher != RTE_CRYPTO_CIPHER_NULL && 41 !(t->test_data->wrapped_key)) 42 ret = rte_cryptodev_sym_capability_check_cipher(capability, 43 tdata->cipher_key.len, 44 tdata->iv.len); 45 if (ret != 0) 46 return -1; 47 } 48 49 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH) { 50 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; 51 cap_idx.algo.auth = tdata->auth_algo; 52 capability = rte_cryptodev_sym_capability_get(dev_id, &cap_idx); 53 if (capability == NULL) 54 return -1; 55 56 if (cap_idx.algo.auth != RTE_CRYPTO_AUTH_NULL) 57 ret = rte_cryptodev_sym_capability_check_auth(capability, 58 tdata->auth_key.len, 59 digest_len, 60 0); 61 if (ret != 0) 62 return -1; 63 } 64 65 return 0; 66 } 67 68 static int 69 test_blockcipher_one_case(const struct blockcipher_test_case *t, 70 struct rte_mempool *mbuf_pool, 71 struct rte_mempool *op_mpool, 72 struct rte_mempool *sess_mpool, 73 struct rte_mempool *sess_priv_mpool, 74 uint8_t dev_id, 75 char *test_msg) 76 { 77 struct rte_mbuf *ibuf = NULL; 78 struct rte_mbuf *obuf = NULL; 79 struct rte_mbuf *iobuf; 80 struct rte_crypto_sym_xform *cipher_xform = NULL; 81 struct rte_crypto_sym_xform *auth_xform = NULL; 82 struct rte_crypto_sym_xform *init_xform = NULL; 83 struct rte_crypto_sym_op *sym_op = NULL; 84 struct rte_crypto_op *op = NULL; 85 struct rte_cryptodev_info dev_info; 86 struct rte_cryptodev_sym_session *sess = NULL; 87 88 int status = TEST_SUCCESS; 89 const struct blockcipher_test_data *tdata = t->test_data; 90 uint8_t cipher_key[tdata->cipher_key.len]; 91 uint8_t auth_key[tdata->auth_key.len]; 92 uint32_t buf_len = tdata->ciphertext.len; 93 uint32_t digest_len = tdata->digest.len; 94 char *buf_p = NULL; 95 uint8_t src_pattern = 0xa5; 96 uint8_t dst_pattern = 0xb6; 97 uint8_t tmp_src_buf[MBUF_SIZE]; 98 uint8_t tmp_dst_buf[MBUF_SIZE]; 99 uint32_t pad_len; 100 101 int nb_segs = 1; 102 uint32_t nb_iterates = 0; 103 104 rte_cryptodev_info_get(dev_id, &dev_info); 105 uint64_t feat_flags = dev_info.feature_flags; 106 107 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_SESSIONLESS) { 108 if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) { 109 printf("Device doesn't support sessionless operations " 110 "Test Skipped.\n"); 111 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, 112 "SKIPPED"); 113 return TEST_SKIPPED; 114 } 115 } 116 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_DIGEST_ENCRYPTED) { 117 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) { 118 printf("Device doesn't support encrypted digest " 119 "Test Skipped.\n"); 120 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, 121 "SKIPPED"); 122 return TEST_SKIPPED; 123 } 124 } 125 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_SG) { 126 uint64_t oop_flag = RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT; 127 128 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_OOP) { 129 if (!(feat_flags & oop_flag)) { 130 printf("Device doesn't support out-of-place " 131 "scatter-gather in input mbuf. " 132 "Test Skipped.\n"); 133 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, 134 "SKIPPED"); 135 return TEST_SKIPPED; 136 } 137 } else { 138 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) { 139 printf("Device doesn't support in-place " 140 "scatter-gather mbufs. " 141 "Test Skipped.\n"); 142 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, 143 "SKIPPED"); 144 return TEST_SKIPPED; 145 } 146 } 147 148 nb_segs = 3; 149 } 150 if (!!(feat_flags & RTE_CRYPTODEV_FF_CIPHER_WRAPPED_KEY) ^ 151 tdata->wrapped_key) { 152 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, 153 "SKIPPED"); 154 return TEST_SKIPPED; 155 } 156 157 if (global_api_test_type == CRYPTODEV_RAW_API_TEST && 158 !(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP)) { 159 printf("Device doesn't support raw data-path APIs. " 160 "Test Skipped.\n"); 161 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "SKIPPED"); 162 return TEST_SKIPPED; 163 } 164 165 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_OOP) { 166 uint64_t oop_flags = RTE_CRYPTODEV_FF_OOP_LB_IN_LB_OUT | 167 RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT | 168 RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT | 169 RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT; 170 if (!(feat_flags & oop_flags)) { 171 printf("Device doesn't support out-of-place operations." 172 "Test Skipped.\n"); 173 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, 174 "SKIPPED"); 175 return TEST_SKIPPED; 176 } 177 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) { 178 printf("Raw Data Path APIs do not support OOP, " 179 "Test Skipped.\n"); 180 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "SKIPPED"); 181 status = TEST_SKIPPED; 182 goto error_exit; 183 } 184 } 185 186 if (tdata->cipher_key.len) 187 memcpy(cipher_key, tdata->cipher_key.data, 188 tdata->cipher_key.len); 189 if (tdata->auth_key.len) 190 memcpy(auth_key, tdata->auth_key.data, 191 tdata->auth_key.len); 192 193 /* Check if PMD is capable of performing that test */ 194 if (verify_algo_support(t, dev_id, digest_len) < 0) { 195 RTE_LOG(DEBUG, USER1, 196 "Device does not support this algorithm." 197 "Test Skipped.\n"); 198 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "SKIPPED"); 199 return TEST_SKIPPED; 200 } 201 202 /* preparing data */ 203 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH) 204 buf_len += digest_len; 205 206 pad_len = RTE_ALIGN(buf_len, 16) - buf_len; 207 if (t->op_mask & BLOCKCIPHER_TEST_OP_DIGEST_ENCRYPTED) 208 buf_len += pad_len; 209 210 /* for contiguous mbuf, nb_segs is 1 */ 211 ibuf = create_segmented_mbuf(mbuf_pool, 212 tdata->ciphertext.len, nb_segs, src_pattern); 213 if (ibuf == NULL) { 214 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, 215 "line %u FAILED: %s", 216 __LINE__, "Cannot create source mbuf"); 217 status = TEST_FAILED; 218 goto error_exit; 219 } 220 221 /* only encryption requires plaintext.data input, 222 * decryption/(digest gen)/(digest verify) use ciphertext.data 223 * to be computed 224 */ 225 if (t->op_mask & BLOCKCIPHER_TEST_OP_ENCRYPT) 226 pktmbuf_write(ibuf, 0, tdata->plaintext.len, 227 tdata->plaintext.data); 228 else 229 pktmbuf_write(ibuf, 0, tdata->ciphertext.len, 230 tdata->ciphertext.data); 231 232 buf_p = rte_pktmbuf_append(ibuf, digest_len); 233 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH_VERIFY) 234 if (t->op_mask & BLOCKCIPHER_TEST_OP_DIGEST_ENCRYPTED) 235 rte_memcpy(buf_p, 236 tdata->ciphertext.data + tdata->ciphertext.len, 237 digest_len); 238 else 239 rte_memcpy(buf_p, tdata->digest.data, digest_len); 240 else 241 memset(buf_p, 0, digest_len); 242 if (t->op_mask & BLOCKCIPHER_TEST_OP_DIGEST_ENCRYPTED) { 243 buf_p = rte_pktmbuf_append(ibuf, pad_len); 244 if (!buf_p) { 245 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "line %u " 246 "FAILED: %s", __LINE__, 247 "No room to append mbuf"); 248 status = TEST_FAILED; 249 goto error_exit; 250 } 251 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH_VERIFY) { 252 const uint8_t *temp_p = tdata->ciphertext.data + 253 tdata->ciphertext.len + 254 digest_len; 255 rte_memcpy(buf_p, temp_p, pad_len); 256 } else 257 memset(buf_p, 0xa5, pad_len); 258 } 259 260 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_OOP) { 261 obuf = rte_pktmbuf_alloc(mbuf_pool); 262 if (!obuf) { 263 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "line %u " 264 "FAILED: %s", __LINE__, 265 "Allocation of rte_mbuf failed"); 266 status = TEST_FAILED; 267 goto error_exit; 268 } 269 memset(obuf->buf_addr, dst_pattern, obuf->buf_len); 270 271 if (t->op_mask & BLOCKCIPHER_TEST_OP_DIGEST_ENCRYPTED) 272 buf_p = rte_pktmbuf_append(obuf, buf_len + pad_len); 273 else 274 buf_p = rte_pktmbuf_append(obuf, buf_len); 275 if (!buf_p) { 276 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "line %u " 277 "FAILED: %s", __LINE__, 278 "No room to append mbuf"); 279 status = TEST_FAILED; 280 goto error_exit; 281 } 282 memset(buf_p, 0, buf_len); 283 } 284 285 /* Generate Crypto op data structure */ 286 op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_SYMMETRIC); 287 if (!op) { 288 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, 289 "line %u FAILED: %s", 290 __LINE__, "Failed to allocate symmetric crypto " 291 "operation struct"); 292 status = TEST_FAILED; 293 goto error_exit; 294 } 295 296 sym_op = op->sym; 297 298 iterate: 299 if (nb_iterates) { 300 struct rte_mbuf *tmp_buf = ibuf; 301 302 ibuf = obuf; 303 obuf = tmp_buf; 304 305 rte_pktmbuf_reset(ibuf); 306 rte_pktmbuf_reset(obuf); 307 308 rte_pktmbuf_append(ibuf, tdata->ciphertext.len); 309 310 /* only encryption requires plaintext.data input, 311 * decryption/(digest gen)/(digest verify) use ciphertext.data 312 * to be computed 313 */ 314 if (t->op_mask & BLOCKCIPHER_TEST_OP_ENCRYPT) 315 pktmbuf_write(ibuf, 0, tdata->plaintext.len, 316 tdata->plaintext.data); 317 else 318 pktmbuf_write(ibuf, 0, tdata->ciphertext.len, 319 tdata->ciphertext.data); 320 321 buf_p = rte_pktmbuf_append(ibuf, digest_len); 322 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH_VERIFY) 323 rte_memcpy(buf_p, tdata->digest.data, digest_len); 324 else 325 memset(buf_p, 0, digest_len); 326 327 memset(obuf->buf_addr, dst_pattern, obuf->buf_len); 328 329 buf_p = rte_pktmbuf_append(obuf, buf_len); 330 if (!buf_p) { 331 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "line %u " 332 "FAILED: %s", __LINE__, 333 "No room to append mbuf"); 334 status = TEST_FAILED; 335 goto error_exit; 336 } 337 memset(buf_p, 0, buf_len); 338 } 339 340 sym_op->m_src = ibuf; 341 342 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_OOP) { 343 sym_op->m_dst = obuf; 344 iobuf = obuf; 345 } else { 346 sym_op->m_dst = NULL; 347 iobuf = ibuf; 348 } 349 350 /* sessionless op requires allocate xform using 351 * rte_crypto_op_sym_xforms_alloc(), otherwise rte_zmalloc() 352 * is used 353 */ 354 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_SESSIONLESS) { 355 uint32_t n_xforms = 0; 356 357 if (t->op_mask & BLOCKCIPHER_TEST_OP_CIPHER) 358 n_xforms++; 359 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH) 360 n_xforms++; 361 362 if (rte_crypto_op_sym_xforms_alloc(op, n_xforms) 363 == NULL) { 364 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "line %u " 365 "FAILED: %s", __LINE__, "Failed to " 366 "allocate space for crypto transforms"); 367 status = TEST_FAILED; 368 goto error_exit; 369 } 370 } else { 371 cipher_xform = rte_zmalloc(NULL, 372 sizeof(struct rte_crypto_sym_xform), 0); 373 374 auth_xform = rte_zmalloc(NULL, 375 sizeof(struct rte_crypto_sym_xform), 0); 376 377 if (!cipher_xform || !auth_xform) { 378 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "line %u " 379 "FAILED: %s", __LINE__, "Failed to " 380 "allocate memory for crypto transforms"); 381 status = TEST_FAILED; 382 goto error_exit; 383 } 384 } 385 386 /* preparing xform, for sessioned op, init_xform is initialized 387 * here and later as param in rte_cryptodev_sym_session_create() call 388 */ 389 if (t->op_mask == BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN) { 390 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_SESSIONLESS) { 391 cipher_xform = op->sym->xform; 392 auth_xform = cipher_xform->next; 393 auth_xform->next = NULL; 394 } else { 395 cipher_xform->next = auth_xform; 396 auth_xform->next = NULL; 397 init_xform = cipher_xform; 398 } 399 } else if (t->op_mask == BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC) { 400 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_SESSIONLESS) { 401 auth_xform = op->sym->xform; 402 cipher_xform = auth_xform->next; 403 cipher_xform->next = NULL; 404 } else { 405 auth_xform->next = cipher_xform; 406 cipher_xform->next = NULL; 407 init_xform = auth_xform; 408 } 409 } else if (t->op_mask == BLOCKCIPHER_TEST_OP_AUTH_GEN_ENC) { 410 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_SESSIONLESS) { 411 auth_xform = op->sym->xform; 412 cipher_xform = auth_xform->next; 413 cipher_xform->next = NULL; 414 } else { 415 auth_xform->next = cipher_xform; 416 cipher_xform->next = NULL; 417 init_xform = auth_xform; 418 } 419 } else if (t->op_mask == BLOCKCIPHER_TEST_OP_DEC_AUTH_VERIFY) { 420 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_SESSIONLESS) { 421 cipher_xform = op->sym->xform; 422 auth_xform = cipher_xform->next; 423 auth_xform->next = NULL; 424 } else { 425 cipher_xform->next = auth_xform; 426 auth_xform->next = NULL; 427 init_xform = cipher_xform; 428 } 429 } else if ((t->op_mask == BLOCKCIPHER_TEST_OP_ENCRYPT) || 430 (t->op_mask == BLOCKCIPHER_TEST_OP_DECRYPT)) { 431 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_SESSIONLESS) 432 cipher_xform = op->sym->xform; 433 else 434 init_xform = cipher_xform; 435 cipher_xform->next = NULL; 436 } else if ((t->op_mask == BLOCKCIPHER_TEST_OP_AUTH_GEN) || 437 (t->op_mask == BLOCKCIPHER_TEST_OP_AUTH_VERIFY)) { 438 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_SESSIONLESS) 439 auth_xform = op->sym->xform; 440 else 441 init_xform = auth_xform; 442 auth_xform->next = NULL; 443 } else { 444 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, 445 "line %u FAILED: %s", 446 __LINE__, "Unrecognized operation"); 447 status = TEST_FAILED; 448 goto error_exit; 449 } 450 451 /*configure xforms & sym_op cipher and auth data*/ 452 if (t->op_mask & BLOCKCIPHER_TEST_OP_CIPHER) { 453 cipher_xform->type = RTE_CRYPTO_SYM_XFORM_CIPHER; 454 cipher_xform->cipher.algo = tdata->crypto_algo; 455 if (t->op_mask & BLOCKCIPHER_TEST_OP_ENCRYPT) 456 cipher_xform->cipher.op = 457 RTE_CRYPTO_CIPHER_OP_ENCRYPT; 458 else 459 cipher_xform->cipher.op = 460 RTE_CRYPTO_CIPHER_OP_DECRYPT; 461 cipher_xform->cipher.key.data = cipher_key; 462 cipher_xform->cipher.key.length = tdata->cipher_key.len; 463 cipher_xform->cipher.iv.offset = IV_OFFSET; 464 cipher_xform->cipher.dataunit_len = tdata->xts_dataunit_len; 465 466 if (tdata->crypto_algo == RTE_CRYPTO_CIPHER_NULL) 467 cipher_xform->cipher.iv.length = 0; 468 else 469 cipher_xform->cipher.iv.length = tdata->iv.len; 470 471 sym_op->cipher.data.offset = tdata->cipher_offset; 472 sym_op->cipher.data.length = tdata->ciphertext.len - 473 tdata->cipher_offset; 474 if (t->op_mask & BLOCKCIPHER_TEST_OP_DIGEST_ENCRYPTED) { 475 sym_op->cipher.data.length += tdata->digest.len; 476 sym_op->cipher.data.length += pad_len; 477 } 478 rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET), 479 tdata->iv.data, 480 tdata->iv.len); 481 } 482 483 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH) { 484 uint32_t digest_offset = tdata->ciphertext.len; 485 486 auth_xform->type = RTE_CRYPTO_SYM_XFORM_AUTH; 487 auth_xform->auth.algo = tdata->auth_algo; 488 auth_xform->auth.key.length = tdata->auth_key.len; 489 auth_xform->auth.key.data = auth_key; 490 auth_xform->auth.digest_length = digest_len; 491 492 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH_GEN) { 493 auth_xform->auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; 494 sym_op->auth.digest.data = pktmbuf_mtod_offset 495 (iobuf, digest_offset); 496 sym_op->auth.digest.phys_addr = 497 pktmbuf_iova_offset(iobuf, 498 digest_offset); 499 } else { 500 auth_xform->auth.op = RTE_CRYPTO_AUTH_OP_VERIFY; 501 sym_op->auth.digest.data = pktmbuf_mtod_offset 502 (sym_op->m_src, digest_offset); 503 sym_op->auth.digest.phys_addr = 504 pktmbuf_iova_offset(sym_op->m_src, 505 digest_offset); 506 } 507 508 sym_op->auth.data.offset = tdata->auth_offset; 509 sym_op->auth.data.length = tdata->ciphertext.len - 510 tdata->auth_offset; 511 } 512 513 /** 514 * Create session for sessioned op. For mbuf iteration test, 515 * skip the session creation for the second iteration. 516 */ 517 if (!(t->feature_mask & BLOCKCIPHER_TEST_FEATURE_SESSIONLESS) && 518 nb_iterates == 0) { 519 sess = rte_cryptodev_sym_session_create(sess_mpool); 520 521 status = rte_cryptodev_sym_session_init(dev_id, sess, 522 init_xform, sess_priv_mpool); 523 if (status == -ENOTSUP) { 524 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "UNSUPPORTED"); 525 status = TEST_SKIPPED; 526 goto error_exit; 527 } 528 if (!sess || status < 0) { 529 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "line %u " 530 "FAILED: %s", __LINE__, 531 "Session creation failed"); 532 status = TEST_FAILED; 533 goto error_exit; 534 } 535 536 /* attach symmetric crypto session to crypto operations */ 537 rte_crypto_op_attach_sym_session(op, sess); 538 } 539 540 debug_hexdump(stdout, "m_src(before):", 541 sym_op->m_src->buf_addr, sym_op->m_src->buf_len); 542 rte_memcpy(tmp_src_buf, sym_op->m_src->buf_addr, 543 sym_op->m_src->buf_len); 544 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_OOP) { 545 debug_hexdump(stdout, "m_dst(before):", 546 sym_op->m_dst->buf_addr, sym_op->m_dst->buf_len); 547 rte_memcpy(tmp_dst_buf, sym_op->m_dst->buf_addr, 548 sym_op->m_dst->buf_len); 549 } 550 551 /* Process crypto operation */ 552 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) { 553 uint8_t is_cipher = 0, is_auth = 0; 554 if (t->op_mask & BLOCKCIPHER_TEST_OP_CIPHER) 555 is_cipher = 1; 556 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH) 557 is_auth = 1; 558 559 process_sym_raw_dp_op(dev_id, 0, op, is_cipher, is_auth, 0, 560 tdata->iv.len); 561 } else { 562 if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) { 563 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, 564 "line %u FAILED: %s", 565 __LINE__, "Error sending packet for encryption"); 566 status = TEST_FAILED; 567 goto error_exit; 568 } 569 570 op = NULL; 571 572 while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0) 573 rte_pause(); 574 575 if (!op) { 576 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, 577 "line %u FAILED: %s", 578 __LINE__, "Failed to process sym crypto op"); 579 status = TEST_FAILED; 580 goto error_exit; 581 } 582 } 583 584 debug_hexdump(stdout, "m_src(after):", 585 sym_op->m_src->buf_addr, sym_op->m_src->buf_len); 586 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_OOP) 587 debug_hexdump(stdout, "m_dst(after):", 588 sym_op->m_dst->buf_addr, sym_op->m_dst->buf_len); 589 590 /* Verify results */ 591 if (op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) { 592 if ((t->op_mask & BLOCKCIPHER_TEST_OP_AUTH_VERIFY) && 593 (op->status == RTE_CRYPTO_OP_STATUS_AUTH_FAILED)) 594 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "line %u " 595 "FAILED: Digest verification failed " 596 "(0x%X)", __LINE__, op->status); 597 else 598 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "line %u " 599 "FAILED: Operation failed " 600 "(0x%X)", __LINE__, op->status); 601 status = TEST_FAILED; 602 goto error_exit; 603 } 604 605 if (t->op_mask & BLOCKCIPHER_TEST_OP_CIPHER) { 606 uint8_t buffer[2048]; 607 const uint8_t *compare_ref; 608 uint32_t compare_len; 609 610 if (t->op_mask & BLOCKCIPHER_TEST_OP_ENCRYPT) { 611 compare_ref = tdata->ciphertext.data + 612 tdata->cipher_offset; 613 compare_len = tdata->ciphertext.len - 614 tdata->cipher_offset; 615 if (t->op_mask & BLOCKCIPHER_TEST_OP_DIGEST_ENCRYPTED) 616 compare_len += tdata->digest.len; 617 } else { 618 compare_ref = tdata->plaintext.data + 619 tdata->cipher_offset; 620 compare_len = tdata->plaintext.len - 621 tdata->cipher_offset; 622 } 623 624 if (memcmp(rte_pktmbuf_read(iobuf, tdata->cipher_offset, 625 compare_len, buffer), compare_ref, 626 compare_len)) { 627 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "line %u " 628 "FAILED: %s", __LINE__, 629 "Crypto data not as expected"); 630 status = TEST_FAILED; 631 goto error_exit; 632 } 633 } 634 635 /* Check digest data only in enc-then-auth_gen case. 636 * In auth_gen-then-enc case, cipher text contains both encrypted 637 * plain text and encrypted digest value. If cipher text is correct, 638 * it implies digest is also generated properly. 639 */ 640 if (!(t->op_mask & BLOCKCIPHER_TEST_OP_DIGEST_ENCRYPTED)) 641 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH_GEN) { 642 uint8_t *auth_res = pktmbuf_mtod_offset(iobuf, 643 tdata->ciphertext.len); 644 645 if (memcmp(auth_res, tdata->digest.data, digest_len)) { 646 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "line %u " 647 "FAILED: %s", __LINE__, "Generated " 648 "digest data not as expected"); 649 status = TEST_FAILED; 650 goto error_exit; 651 } 652 } 653 654 /* The only parts that should have changed in the buffer are 655 * plaintext/ciphertext and digest. 656 * In OOP only the dest buffer should change. 657 */ 658 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_OOP) { 659 struct rte_mbuf *mbuf; 660 uint8_t value; 661 uint32_t head_unchanged_len, changed_len = 0; 662 uint32_t i; 663 uint32_t hdroom_used = 0, tlroom_used = 0; 664 uint32_t hdroom = 0; 665 666 mbuf = sym_op->m_src; 667 /* 668 * Crypto PMDs specify the headroom & tailroom it would use 669 * when processing the crypto operation. PMD is free to modify 670 * this space, and so the verification check should skip that 671 * block. 672 */ 673 hdroom_used = dev_info.min_mbuf_headroom_req; 674 tlroom_used = dev_info.min_mbuf_tailroom_req; 675 676 /* Get headroom */ 677 hdroom = rte_pktmbuf_headroom(mbuf); 678 679 head_unchanged_len = mbuf->buf_len; 680 681 for (i = 0; i < mbuf->buf_len; i++) { 682 683 /* Skip headroom used by PMD */ 684 if (i == hdroom - hdroom_used) 685 i += hdroom_used; 686 687 /* Skip tailroom used by PMD */ 688 if (i == (hdroom + mbuf->data_len)) 689 i += tlroom_used; 690 691 value = *((uint8_t *)(mbuf->buf_addr)+i); 692 if (value != tmp_src_buf[i]) { 693 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, 694 "line %u FAILED: OOP src outer mbuf data (0x%x) not as expected (0x%x)", 695 __LINE__, value, tmp_src_buf[i]); 696 status = TEST_FAILED; 697 goto error_exit; 698 } 699 } 700 701 mbuf = sym_op->m_dst; 702 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH) { 703 head_unchanged_len = hdroom + sym_op->auth.data.offset; 704 changed_len = sym_op->auth.data.length; 705 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH_GEN) 706 changed_len += digest_len; 707 } else { 708 /* cipher-only */ 709 head_unchanged_len = hdroom + 710 sym_op->cipher.data.offset; 711 changed_len = sym_op->cipher.data.length; 712 } 713 714 if (t->op_mask & BLOCKCIPHER_TEST_OP_DIGEST_ENCRYPTED) 715 changed_len = sym_op->cipher.data.length + 716 digest_len + pad_len; 717 718 for (i = 0; i < mbuf->buf_len; i++) { 719 if (i == head_unchanged_len) 720 i += changed_len; 721 value = *((uint8_t *)(mbuf->buf_addr)+i); 722 if (value != tmp_dst_buf[i]) { 723 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, 724 "line %u FAILED: OOP dst outer mbuf data " 725 "(0x%x) not as expected (0x%x)", 726 __LINE__, value, tmp_dst_buf[i]); 727 status = TEST_FAILED; 728 goto error_exit; 729 } 730 } 731 732 if (!nb_iterates) { 733 nb_iterates++; 734 goto iterate; 735 } 736 } else { 737 /* In-place operation */ 738 struct rte_mbuf *mbuf; 739 uint8_t value; 740 uint32_t head_unchanged_len = 0, changed_len = 0; 741 uint32_t i; 742 uint32_t hdroom_used = 0, tlroom_used = 0; 743 uint32_t hdroom = 0; 744 745 /* 746 * Crypto PMDs specify the headroom & tailroom it would use 747 * when processing the crypto operation. PMD is free to modify 748 * this space, and so the verification check should skip that 749 * block. 750 */ 751 hdroom_used = dev_info.min_mbuf_headroom_req; 752 tlroom_used = dev_info.min_mbuf_tailroom_req; 753 754 mbuf = sym_op->m_src; 755 756 /* Get headroom */ 757 hdroom = rte_pktmbuf_headroom(mbuf); 758 759 if (t->op_mask & BLOCKCIPHER_TEST_OP_CIPHER) { 760 head_unchanged_len = hdroom + 761 sym_op->cipher.data.offset; 762 changed_len = sym_op->cipher.data.length; 763 } else { 764 /* auth-only */ 765 head_unchanged_len = hdroom + 766 sym_op->auth.data.offset + 767 sym_op->auth.data.length; 768 changed_len = 0; 769 } 770 771 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH_GEN) 772 changed_len += digest_len; 773 774 if (t->op_mask & BLOCKCIPHER_TEST_OP_DIGEST_ENCRYPTED) 775 changed_len = sym_op->cipher.data.length; 776 777 for (i = 0; i < mbuf->buf_len; i++) { 778 779 /* Skip headroom used by PMD */ 780 if (i == hdroom - hdroom_used) 781 i += hdroom_used; 782 783 if (i == head_unchanged_len) 784 i += changed_len; 785 786 /* Skip tailroom used by PMD */ 787 if (i == (hdroom + mbuf->data_len)) 788 i += tlroom_used; 789 790 value = *((uint8_t *)(mbuf->buf_addr)+i); 791 if (value != tmp_src_buf[i]) { 792 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, 793 "line %u FAILED: outer mbuf data (0x%x) " 794 "not as expected (0x%x)", 795 __LINE__, value, tmp_src_buf[i]); 796 status = TEST_FAILED; 797 goto error_exit; 798 } 799 } 800 } 801 802 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "PASS"); 803 804 error_exit: 805 if (!(t->feature_mask & BLOCKCIPHER_TEST_FEATURE_SESSIONLESS)) { 806 if (sess) { 807 rte_cryptodev_sym_session_clear(dev_id, sess); 808 rte_cryptodev_sym_session_free(sess); 809 } 810 rte_free(cipher_xform); 811 rte_free(auth_xform); 812 } 813 814 if (op) 815 rte_crypto_op_free(op); 816 817 rte_pktmbuf_free(obuf); 818 819 rte_pktmbuf_free(ibuf); 820 821 return status; 822 } 823 824 static int 825 blockcipher_test_case_run(const void *data) 826 { 827 const struct blockcipher_test_case *tc_data = data; 828 int status; 829 char test_msg[BLOCKCIPHER_TEST_MSG_LEN + 1]; 830 831 status = test_blockcipher_one_case(tc_data, 832 p_testsuite_params->mbuf_pool, 833 p_testsuite_params->op_mpool, 834 p_testsuite_params->session_mpool, 835 p_testsuite_params->session_priv_mpool, 836 p_testsuite_params->valid_devs[0], 837 test_msg); 838 return status; 839 } 840 841 static int 842 aes_chain_setup(void) 843 { 844 uint8_t dev_id = p_testsuite_params->valid_devs[0]; 845 struct rte_cryptodev_info dev_info; 846 uint64_t feat_flags; 847 const enum rte_crypto_cipher_algorithm ciphers[] = { 848 RTE_CRYPTO_CIPHER_NULL, 849 RTE_CRYPTO_CIPHER_AES_CTR, 850 RTE_CRYPTO_CIPHER_AES_CBC 851 }; 852 const enum rte_crypto_auth_algorithm auths[] = { 853 RTE_CRYPTO_AUTH_NULL, 854 RTE_CRYPTO_AUTH_SHA1_HMAC, 855 RTE_CRYPTO_AUTH_AES_XCBC_MAC, 856 RTE_CRYPTO_AUTH_SHA256_HMAC, 857 RTE_CRYPTO_AUTH_SHA512_HMAC, 858 RTE_CRYPTO_AUTH_SHA224_HMAC, 859 RTE_CRYPTO_AUTH_SHA384_HMAC 860 }; 861 862 rte_cryptodev_info_get(dev_id, &dev_info); 863 feat_flags = dev_info.feature_flags; 864 865 if (!(feat_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) || 866 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 867 !(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 868 RTE_LOG(INFO, USER1, "Feature flag requirements for AES Chain " 869 "testsuite not met\n"); 870 return TEST_SKIPPED; 871 } 872 873 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0 874 && check_auth_capabilities_supported(auths, 875 RTE_DIM(auths)) != 0) { 876 RTE_LOG(INFO, USER1, "Capability requirements for AES Chain " 877 "testsuite not met\n"); 878 return TEST_SKIPPED; 879 } 880 881 return 0; 882 } 883 884 static int 885 aes_cipheronly_setup(void) 886 { 887 uint8_t dev_id = p_testsuite_params->valid_devs[0]; 888 struct rte_cryptodev_info dev_info; 889 uint64_t feat_flags; 890 const enum rte_crypto_cipher_algorithm ciphers[] = { 891 RTE_CRYPTO_CIPHER_NULL, 892 RTE_CRYPTO_CIPHER_AES_CTR, 893 RTE_CRYPTO_CIPHER_AES_CBC, 894 RTE_CRYPTO_CIPHER_AES_ECB, 895 RTE_CRYPTO_CIPHER_AES_XTS 896 }; 897 const enum rte_crypto_auth_algorithm auths[] = { 898 RTE_CRYPTO_AUTH_NULL, 899 RTE_CRYPTO_AUTH_SHA1_HMAC, 900 RTE_CRYPTO_AUTH_AES_XCBC_MAC 901 }; 902 903 rte_cryptodev_info_get(dev_id, &dev_info); 904 feat_flags = dev_info.feature_flags; 905 906 if (!(feat_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) || 907 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 908 !(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 909 RTE_LOG(INFO, USER1, "Feature flag requirements for AES Cipheronly " 910 "testsuite not met\n"); 911 return TEST_SKIPPED; 912 } 913 914 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0 915 && check_auth_capabilities_supported(auths, 916 RTE_DIM(auths)) != 0) { 917 RTE_LOG(INFO, USER1, "Capability requirements for AES Cipheronly " 918 "testsuite not met\n"); 919 return TEST_SKIPPED; 920 } 921 922 return 0; 923 } 924 925 static int 926 aes_docsis_setup(void) 927 { 928 uint8_t dev_id = p_testsuite_params->valid_devs[0]; 929 struct rte_cryptodev_info dev_info; 930 uint64_t feat_flags; 931 const enum rte_crypto_cipher_algorithm ciphers[] = { 932 RTE_CRYPTO_CIPHER_AES_DOCSISBPI 933 }; 934 935 rte_cryptodev_info_get(dev_id, &dev_info); 936 feat_flags = dev_info.feature_flags; 937 938 /* Data-path service does not support DOCSIS yet */ 939 if (!(feat_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) || 940 (global_api_test_type == CRYPTODEV_RAW_API_TEST)) { 941 RTE_LOG(INFO, USER1, "Feature flag requirements for AES Docsis " 942 "testsuite not met\n"); 943 return TEST_SKIPPED; 944 } 945 946 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0) { 947 RTE_LOG(INFO, USER1, "Capability requirements for AES Docsis " 948 "testsuite not met\n"); 949 return TEST_SKIPPED; 950 } 951 952 return 0; 953 } 954 955 static int 956 triple_des_chain_setup(void) 957 { 958 uint8_t dev_id = p_testsuite_params->valid_devs[0]; 959 struct rte_cryptodev_info dev_info; 960 uint64_t feat_flags; 961 const enum rte_crypto_cipher_algorithm ciphers[] = { 962 RTE_CRYPTO_CIPHER_3DES_CTR, 963 RTE_CRYPTO_CIPHER_3DES_CBC 964 }; 965 const enum rte_crypto_auth_algorithm auths[] = { 966 RTE_CRYPTO_AUTH_SHA1_HMAC, 967 RTE_CRYPTO_AUTH_SHA1 968 }; 969 970 rte_cryptodev_info_get(dev_id, &dev_info); 971 feat_flags = dev_info.feature_flags; 972 973 if (!(feat_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) || 974 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 975 !(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 976 RTE_LOG(INFO, USER1, "Feature flag requirements for 3DES Chain " 977 "testsuite not met\n"); 978 return TEST_SKIPPED; 979 } 980 981 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0 982 && check_auth_capabilities_supported(auths, 983 RTE_DIM(auths)) != 0) { 984 RTE_LOG(INFO, USER1, "Capability requirements for 3DES Chain " 985 "testsuite not met\n"); 986 return TEST_SKIPPED; 987 } 988 989 return 0; 990 } 991 992 static int 993 triple_des_cipheronly_setup(void) 994 { 995 uint8_t dev_id = p_testsuite_params->valid_devs[0]; 996 struct rte_cryptodev_info dev_info; 997 uint64_t feat_flags; 998 const enum rte_crypto_cipher_algorithm ciphers[] = { 999 RTE_CRYPTO_CIPHER_3DES_CTR, 1000 RTE_CRYPTO_CIPHER_3DES_CBC 1001 }; 1002 1003 rte_cryptodev_info_get(dev_id, &dev_info); 1004 feat_flags = dev_info.feature_flags; 1005 1006 if (!(feat_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) || 1007 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 1008 !(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 1009 RTE_LOG(INFO, USER1, "Feature flag requirements for 3DES " 1010 "Cipheronly testsuite not met\n"); 1011 return TEST_SKIPPED; 1012 } 1013 1014 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0) { 1015 RTE_LOG(INFO, USER1, "Capability requirements for 3DES " 1016 "Cipheronly testsuite not met\n"); 1017 return TEST_SKIPPED; 1018 } 1019 1020 return 0; 1021 } 1022 1023 static int 1024 des_cipheronly_setup(void) 1025 { 1026 uint8_t dev_id = p_testsuite_params->valid_devs[0]; 1027 struct rte_cryptodev_info dev_info; 1028 uint64_t feat_flags; 1029 const enum rte_crypto_cipher_algorithm ciphers[] = { 1030 RTE_CRYPTO_CIPHER_DES_CBC 1031 }; 1032 1033 rte_cryptodev_info_get(dev_id, &dev_info); 1034 feat_flags = dev_info.feature_flags; 1035 1036 if (!(feat_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) || 1037 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 1038 !(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 1039 RTE_LOG(INFO, USER1, "Feature flag requirements for DES " 1040 "Cipheronly testsuite not met\n"); 1041 return TEST_SKIPPED; 1042 } 1043 1044 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0) { 1045 RTE_LOG(INFO, USER1, "Capability requirements for DES " 1046 "Cipheronly testsuite not met\n"); 1047 return TEST_SKIPPED; 1048 } 1049 1050 return 0; 1051 } 1052 1053 static int 1054 des_docsis_setup(void) 1055 { 1056 uint8_t dev_id = p_testsuite_params->valid_devs[0]; 1057 struct rte_cryptodev_info dev_info; 1058 uint64_t feat_flags; 1059 const enum rte_crypto_cipher_algorithm ciphers[] = { 1060 RTE_CRYPTO_CIPHER_DES_DOCSISBPI 1061 }; 1062 1063 rte_cryptodev_info_get(dev_id, &dev_info); 1064 feat_flags = dev_info.feature_flags; 1065 1066 /* Data-path service does not support DOCSIS yet */ 1067 if (!(feat_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) || 1068 (global_api_test_type == CRYPTODEV_RAW_API_TEST)) { 1069 RTE_LOG(INFO, USER1, "Feature flag requirements for DES Docsis " 1070 "testsuite not met\n"); 1071 return TEST_SKIPPED; 1072 } 1073 1074 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0) { 1075 RTE_LOG(INFO, USER1, "Capability requirements for DES Docsis " 1076 "testsuite not met\n"); 1077 return TEST_SKIPPED; 1078 } 1079 1080 return 0; 1081 } 1082 1083 static int 1084 authonly_setup(void) 1085 { 1086 uint8_t dev_id = p_testsuite_params->valid_devs[0]; 1087 struct rte_cryptodev_info dev_info; 1088 uint64_t feat_flags; 1089 const enum rte_crypto_auth_algorithm auths[] = { 1090 RTE_CRYPTO_AUTH_MD5, 1091 RTE_CRYPTO_AUTH_MD5_HMAC, 1092 RTE_CRYPTO_AUTH_SHA1, 1093 RTE_CRYPTO_AUTH_SHA1_HMAC, 1094 RTE_CRYPTO_AUTH_SHA224, 1095 RTE_CRYPTO_AUTH_SHA224_HMAC, 1096 RTE_CRYPTO_AUTH_SHA256, 1097 RTE_CRYPTO_AUTH_SHA256_HMAC, 1098 RTE_CRYPTO_AUTH_SHA384, 1099 RTE_CRYPTO_AUTH_SHA384_HMAC, 1100 RTE_CRYPTO_AUTH_SHA512, 1101 RTE_CRYPTO_AUTH_SHA512_HMAC, 1102 RTE_CRYPTO_AUTH_AES_CMAC, 1103 RTE_CRYPTO_AUTH_NULL, 1104 RTE_CRYPTO_AUTH_AES_XCBC_MAC 1105 }; 1106 1107 rte_cryptodev_info_get(dev_id, &dev_info); 1108 feat_flags = dev_info.feature_flags; 1109 1110 if (!(feat_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) || 1111 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && 1112 !(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { 1113 RTE_LOG(INFO, USER1, "Feature flag requirements for Auth Only " 1114 "testsuite not met\n"); 1115 return TEST_SKIPPED; 1116 } 1117 1118 if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) { 1119 RTE_LOG(INFO, USER1, "Capability requirements for Auth Only " 1120 "testsuite not met\n"); 1121 return TEST_SKIPPED; 1122 } 1123 1124 return 0; 1125 } 1126 1127 struct unit_test_suite * 1128 build_blockcipher_test_suite(enum blockcipher_test_type test_type) 1129 { 1130 int i, n_test_cases = 0; 1131 struct unit_test_suite *ts; 1132 const char *ts_name = NULL; 1133 const struct blockcipher_test_case *blk_tcs; 1134 struct unit_test_case *tc; 1135 int (*ts_setup)(void) = NULL; 1136 1137 switch (test_type) { 1138 case BLKCIPHER_AES_CHAIN_TYPE: 1139 n_test_cases = RTE_DIM(aes_chain_test_cases); 1140 blk_tcs = aes_chain_test_cases; 1141 ts_name = "AES Chain"; 1142 ts_setup = aes_chain_setup; 1143 break; 1144 case BLKCIPHER_AES_CIPHERONLY_TYPE: 1145 n_test_cases = RTE_DIM(aes_cipheronly_test_cases); 1146 blk_tcs = aes_cipheronly_test_cases; 1147 ts_name = "AES Cipher Only"; 1148 ts_setup = aes_cipheronly_setup; 1149 break; 1150 case BLKCIPHER_AES_DOCSIS_TYPE: 1151 n_test_cases = RTE_DIM(aes_docsis_test_cases); 1152 blk_tcs = aes_docsis_test_cases; 1153 ts_name = "AES Docsis"; 1154 ts_setup = aes_docsis_setup; 1155 break; 1156 case BLKCIPHER_3DES_CHAIN_TYPE: 1157 n_test_cases = RTE_DIM(triple_des_chain_test_cases); 1158 blk_tcs = triple_des_chain_test_cases; 1159 ts_name = "3DES Chain"; 1160 ts_setup = triple_des_chain_setup; 1161 break; 1162 case BLKCIPHER_3DES_CIPHERONLY_TYPE: 1163 n_test_cases = RTE_DIM(triple_des_cipheronly_test_cases); 1164 blk_tcs = triple_des_cipheronly_test_cases; 1165 ts_name = "3DES Cipher Only"; 1166 ts_setup = triple_des_cipheronly_setup; 1167 break; 1168 case BLKCIPHER_DES_CIPHERONLY_TYPE: 1169 n_test_cases = RTE_DIM(des_cipheronly_test_cases); 1170 blk_tcs = des_cipheronly_test_cases; 1171 ts_name = "DES Cipher Only"; 1172 ts_setup = des_cipheronly_setup; 1173 break; 1174 case BLKCIPHER_DES_DOCSIS_TYPE: 1175 n_test_cases = RTE_DIM(des_docsis_test_cases); 1176 blk_tcs = des_docsis_test_cases; 1177 ts_name = "DES Docsis"; 1178 ts_setup = des_docsis_setup; 1179 break; 1180 case BLKCIPHER_AUTHONLY_TYPE: 1181 n_test_cases = RTE_DIM(hash_test_cases); 1182 blk_tcs = hash_test_cases; 1183 ts_name = "Auth Only"; 1184 ts_setup = authonly_setup; 1185 break; 1186 default: 1187 return NULL; 1188 } 1189 1190 ts = calloc(1, sizeof(struct unit_test_suite) + 1191 (sizeof(struct unit_test_case) * (n_test_cases + 1))); 1192 ts->suite_name = ts_name; 1193 ts->setup = ts_setup; 1194 1195 for (i = 0; i < n_test_cases; i++) { 1196 tc = &ts->unit_test_cases[i]; 1197 tc->name = blk_tcs[i].test_descr; 1198 tc->enabled = 1; 1199 tc->setup = ut_setup; 1200 tc->teardown = ut_teardown; 1201 tc->testcase = NULL; 1202 tc->testcase_with_data = blockcipher_test_case_run; 1203 tc->data = &blk_tcs[i]; 1204 } 1205 tc = &ts->unit_test_cases[i]; 1206 tc->name = NULL; 1207 tc->enabled = 0; 1208 tc->setup = NULL; 1209 tc->teardown = NULL; 1210 tc->testcase = NULL; 1211 tc->testcase_with_data = NULL; 1212 tc->data = NULL; 1213 1214 return ts; 1215 } 1216 1217 void 1218 free_blockcipher_test_suite(struct unit_test_suite *ts) 1219 { 1220 free(ts); 1221 } 1222 1223 #endif /* !RTE_EXEC_ENV_WINDOWS */ 1224