1 /*- 2 * BSD LICENSE 3 * 4 * Copyright(c) 2015-2016 Intel Corporation. All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 10 * * Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * * Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in 14 * the documentation and/or other materials provided with the 15 * distribution. 16 * * Neither the name of Intel Corporation nor the names of its 17 * contributors may be used to endorse or promote products derived 18 * from this software without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 23 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 24 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 25 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 26 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 30 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 #include <rte_common.h> 34 #include <rte_hexdump.h> 35 #include <rte_mbuf.h> 36 #include <rte_malloc.h> 37 #include <rte_memcpy.h> 38 39 #include <rte_crypto.h> 40 #include <rte_cryptodev.h> 41 #include <rte_cryptodev_pmd.h> 42 43 #include "test.h" 44 #include "test_cryptodev.h" 45 #include "test_cryptodev_blockcipher.h" 46 #include "test_cryptodev_aes_test_vectors.h" 47 #include "test_cryptodev_des_test_vectors.h" 48 #include "test_cryptodev_hash_test_vectors.h" 49 #include "test_cryptodev.h" 50 51 static int 52 test_blockcipher_one_case(const struct blockcipher_test_case *t, 53 struct rte_mempool *mbuf_pool, 54 struct rte_mempool *op_mpool, 55 uint8_t dev_id, 56 enum rte_cryptodev_type cryptodev_type, 57 char *test_msg) 58 { 59 struct rte_mbuf *ibuf = NULL; 60 struct rte_mbuf *obuf = NULL; 61 struct rte_mbuf *iobuf; 62 struct rte_crypto_sym_xform *cipher_xform = NULL; 63 struct rte_crypto_sym_xform *auth_xform = NULL; 64 struct rte_crypto_sym_xform *init_xform = NULL; 65 struct rte_crypto_sym_op *sym_op = NULL; 66 struct rte_crypto_op *op = NULL; 67 struct rte_cryptodev_sym_session *sess = NULL; 68 struct rte_cryptodev_info dev_info; 69 70 int status = TEST_SUCCESS; 71 const struct blockcipher_test_data *tdata = t->test_data; 72 uint8_t cipher_key[tdata->cipher_key.len]; 73 uint8_t auth_key[tdata->auth_key.len]; 74 uint32_t buf_len = tdata->ciphertext.len; 75 uint32_t digest_len = 0; 76 char *buf_p = NULL; 77 uint8_t src_pattern = 0xa5; 78 uint8_t dst_pattern = 0xb6; 79 uint8_t tmp_src_buf[MBUF_SIZE]; 80 uint8_t tmp_dst_buf[MBUF_SIZE]; 81 82 int nb_segs = 1; 83 84 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_SG) { 85 rte_cryptodev_info_get(dev_id, &dev_info); 86 if (!(dev_info.feature_flags & 87 RTE_CRYPTODEV_FF_MBUF_SCATTER_GATHER)) { 88 printf("Device doesn't support scatter-gather. " 89 "Test Skipped.\n"); 90 return 0; 91 } 92 nb_segs = 3; 93 } 94 95 if (tdata->cipher_key.len) 96 memcpy(cipher_key, tdata->cipher_key.data, 97 tdata->cipher_key.len); 98 if (tdata->auth_key.len) 99 memcpy(auth_key, tdata->auth_key.data, 100 tdata->auth_key.len); 101 102 switch (cryptodev_type) { 103 case RTE_CRYPTODEV_QAT_SYM_PMD: 104 case RTE_CRYPTODEV_OPENSSL_PMD: 105 case RTE_CRYPTODEV_ARMV8_PMD: /* Fall through */ 106 digest_len = tdata->digest.len; 107 break; 108 case RTE_CRYPTODEV_AESNI_MB_PMD: 109 digest_len = tdata->digest.truncated_len; 110 break; 111 default: 112 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, 113 "line %u FAILED: %s", 114 __LINE__, "Unsupported PMD type"); 115 status = TEST_FAILED; 116 goto error_exit; 117 } 118 119 /* preparing data */ 120 if (t->op_mask & BLOCKCIPHER_TEST_OP_CIPHER) 121 buf_len += tdata->iv.len; 122 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH) 123 buf_len += digest_len; 124 125 /* for contiguous mbuf, nb_segs is 1 */ 126 ibuf = create_segmented_mbuf(mbuf_pool, 127 tdata->ciphertext.len, nb_segs, src_pattern); 128 if (ibuf == NULL) { 129 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, 130 "line %u FAILED: %s", 131 __LINE__, "Cannot create source mbuf"); 132 status = TEST_FAILED; 133 goto error_exit; 134 } 135 136 /* only encryption requires plaintext.data input, 137 * decryption/(digest gen)/(digest verify) use ciphertext.data 138 * to be computed 139 */ 140 if (t->op_mask & BLOCKCIPHER_TEST_OP_ENCRYPT) 141 pktmbuf_write(ibuf, 0, tdata->plaintext.len, 142 tdata->plaintext.data); 143 else 144 pktmbuf_write(ibuf, 0, tdata->ciphertext.len, 145 tdata->ciphertext.data); 146 147 if (t->op_mask & BLOCKCIPHER_TEST_OP_CIPHER) { 148 rte_memcpy(rte_pktmbuf_prepend(ibuf, tdata->iv.len), 149 tdata->iv.data, tdata->iv.len); 150 } 151 buf_p = rte_pktmbuf_append(ibuf, digest_len); 152 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH_VERIFY) 153 rte_memcpy(buf_p, tdata->digest.data, digest_len); 154 else 155 memset(buf_p, 0, digest_len); 156 157 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_OOP) { 158 obuf = rte_pktmbuf_alloc(mbuf_pool); 159 if (!obuf) { 160 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "line %u " 161 "FAILED: %s", __LINE__, 162 "Allocation of rte_mbuf failed"); 163 status = TEST_FAILED; 164 goto error_exit; 165 } 166 memset(obuf->buf_addr, dst_pattern, obuf->buf_len); 167 168 buf_p = rte_pktmbuf_append(obuf, buf_len); 169 if (!buf_p) { 170 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "line %u " 171 "FAILED: %s", __LINE__, 172 "No room to append mbuf"); 173 status = TEST_FAILED; 174 goto error_exit; 175 } 176 memset(buf_p, 0, buf_len); 177 } 178 179 /* Generate Crypto op data structure */ 180 op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_SYMMETRIC); 181 if (!op) { 182 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, 183 "line %u FAILED: %s", 184 __LINE__, "Failed to allocate symmetric crypto " 185 "operation struct"); 186 status = TEST_FAILED; 187 goto error_exit; 188 } 189 190 sym_op = op->sym; 191 192 sym_op->m_src = ibuf; 193 194 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_OOP) { 195 sym_op->m_dst = obuf; 196 iobuf = obuf; 197 } else { 198 sym_op->m_dst = NULL; 199 iobuf = ibuf; 200 } 201 202 /* sessionless op requires allocate xform using 203 * rte_crypto_op_sym_xforms_alloc(), otherwise rte_zmalloc() 204 * is used 205 */ 206 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_SESSIONLESS) { 207 uint32_t n_xforms = 0; 208 209 if (t->op_mask & BLOCKCIPHER_TEST_OP_CIPHER) 210 n_xforms++; 211 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH) 212 n_xforms++; 213 214 if (rte_crypto_op_sym_xforms_alloc(op, n_xforms) 215 == NULL) { 216 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "line %u " 217 "FAILED: %s", __LINE__, "Failed to " 218 "allocate space for crypto transforms"); 219 status = TEST_FAILED; 220 goto error_exit; 221 } 222 } else { 223 cipher_xform = rte_zmalloc(NULL, 224 sizeof(struct rte_crypto_sym_xform), 0); 225 226 auth_xform = rte_zmalloc(NULL, 227 sizeof(struct rte_crypto_sym_xform), 0); 228 229 if (!cipher_xform || !auth_xform) { 230 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "line %u " 231 "FAILED: %s", __LINE__, "Failed to " 232 "allocate memory for crypto transforms"); 233 status = TEST_FAILED; 234 goto error_exit; 235 } 236 } 237 238 /* preparing xform, for sessioned op, init_xform is initialized 239 * here and later as param in rte_cryptodev_sym_session_create() call 240 */ 241 if (t->op_mask == BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN) { 242 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_SESSIONLESS) { 243 cipher_xform = op->sym->xform; 244 auth_xform = cipher_xform->next; 245 auth_xform->next = NULL; 246 } else { 247 cipher_xform->next = auth_xform; 248 auth_xform->next = NULL; 249 init_xform = cipher_xform; 250 } 251 } else if (t->op_mask == BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC) { 252 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_SESSIONLESS) { 253 auth_xform = op->sym->xform; 254 cipher_xform = auth_xform->next; 255 cipher_xform->next = NULL; 256 } else { 257 auth_xform->next = cipher_xform; 258 cipher_xform->next = NULL; 259 init_xform = auth_xform; 260 } 261 } else if ((t->op_mask == BLOCKCIPHER_TEST_OP_ENCRYPT) || 262 (t->op_mask == BLOCKCIPHER_TEST_OP_DECRYPT)) { 263 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_SESSIONLESS) 264 cipher_xform = op->sym->xform; 265 else 266 init_xform = cipher_xform; 267 cipher_xform->next = NULL; 268 } else if ((t->op_mask == BLOCKCIPHER_TEST_OP_AUTH_GEN) || 269 (t->op_mask == BLOCKCIPHER_TEST_OP_AUTH_VERIFY)) { 270 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_SESSIONLESS) 271 auth_xform = op->sym->xform; 272 else 273 init_xform = auth_xform; 274 auth_xform->next = NULL; 275 } else { 276 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, 277 "line %u FAILED: %s", 278 __LINE__, "Unrecognized operation"); 279 status = TEST_FAILED; 280 goto error_exit; 281 } 282 283 /*configure xforms & sym_op cipher and auth data*/ 284 if (t->op_mask & BLOCKCIPHER_TEST_OP_CIPHER) { 285 cipher_xform->type = RTE_CRYPTO_SYM_XFORM_CIPHER; 286 cipher_xform->cipher.algo = tdata->crypto_algo; 287 if (t->op_mask & BLOCKCIPHER_TEST_OP_ENCRYPT) 288 cipher_xform->cipher.op = 289 RTE_CRYPTO_CIPHER_OP_ENCRYPT; 290 else 291 cipher_xform->cipher.op = 292 RTE_CRYPTO_CIPHER_OP_DECRYPT; 293 cipher_xform->cipher.key.data = cipher_key; 294 cipher_xform->cipher.key.length = tdata->cipher_key.len; 295 296 sym_op->cipher.data.offset = tdata->iv.len; 297 sym_op->cipher.data.length = tdata->ciphertext.len; 298 sym_op->cipher.iv.data = rte_pktmbuf_mtod(sym_op->m_src, 299 uint8_t *); 300 sym_op->cipher.iv.length = tdata->iv.len; 301 sym_op->cipher.iv.phys_addr = rte_pktmbuf_mtophys( 302 sym_op->m_src); 303 } 304 305 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH) { 306 uint32_t auth_data_offset = 0; 307 uint32_t digest_offset = tdata->ciphertext.len; 308 309 if (t->op_mask & BLOCKCIPHER_TEST_OP_CIPHER) { 310 digest_offset += tdata->iv.len; 311 auth_data_offset += tdata->iv.len; 312 } 313 314 auth_xform->type = RTE_CRYPTO_SYM_XFORM_AUTH; 315 auth_xform->auth.algo = tdata->auth_algo; 316 auth_xform->auth.key.length = tdata->auth_key.len; 317 auth_xform->auth.key.data = auth_key; 318 auth_xform->auth.digest_length = digest_len; 319 320 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH_GEN) { 321 auth_xform->auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; 322 sym_op->auth.digest.data = pktmbuf_mtod_offset 323 (iobuf, digest_offset); 324 sym_op->auth.digest.phys_addr = 325 pktmbuf_mtophys_offset(iobuf, 326 digest_offset); 327 } else { 328 auth_xform->auth.op = RTE_CRYPTO_AUTH_OP_VERIFY; 329 sym_op->auth.digest.data = pktmbuf_mtod_offset 330 (sym_op->m_src, digest_offset); 331 sym_op->auth.digest.phys_addr = 332 pktmbuf_mtophys_offset(sym_op->m_src, 333 digest_offset); 334 } 335 336 sym_op->auth.data.offset = auth_data_offset; 337 sym_op->auth.data.length = tdata->ciphertext.len; 338 sym_op->auth.digest.length = digest_len; 339 } 340 341 /* create session for sessioned op */ 342 if (!(t->feature_mask & BLOCKCIPHER_TEST_FEATURE_SESSIONLESS)) { 343 sess = rte_cryptodev_sym_session_create(dev_id, 344 init_xform); 345 if (!sess) { 346 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "line %u " 347 "FAILED: %s", __LINE__, 348 "Session creation failed"); 349 status = TEST_FAILED; 350 goto error_exit; 351 } 352 353 /* attach symmetric crypto session to crypto operations */ 354 rte_crypto_op_attach_sym_session(op, sess); 355 } 356 357 TEST_HEXDUMP(stdout, "m_src(before):", 358 sym_op->m_src->buf_addr, sym_op->m_src->buf_len); 359 rte_memcpy(tmp_src_buf, sym_op->m_src->buf_addr, 360 sym_op->m_src->buf_len); 361 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_OOP) { 362 TEST_HEXDUMP(stdout, "m_dst(before):", 363 sym_op->m_dst->buf_addr, sym_op->m_dst->buf_len); 364 rte_memcpy(tmp_dst_buf, sym_op->m_dst->buf_addr, 365 sym_op->m_dst->buf_len); 366 } 367 368 /* Process crypto operation */ 369 if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) { 370 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, 371 "line %u FAILED: %s", 372 __LINE__, "Error sending packet for encryption"); 373 status = TEST_FAILED; 374 goto error_exit; 375 } 376 377 op = NULL; 378 379 while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0) 380 rte_pause(); 381 382 if (!op) { 383 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, 384 "line %u FAILED: %s", 385 __LINE__, "Failed to process sym crypto op"); 386 status = TEST_FAILED; 387 goto error_exit; 388 } 389 390 TEST_HEXDUMP(stdout, "m_src(after):", 391 sym_op->m_src->buf_addr, sym_op->m_src->buf_len); 392 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_OOP) 393 TEST_HEXDUMP(stdout, "m_dst(after):", 394 sym_op->m_dst->buf_addr, sym_op->m_dst->buf_len); 395 396 /* Verify results */ 397 if (op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) { 398 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH_VERIFY) 399 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "line %u " 400 "FAILED: Digest verification failed " 401 "(0x%X)", __LINE__, op->status); 402 else 403 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "line %u " 404 "FAILED: Digest verification failed " 405 "(0x%X)", __LINE__, op->status); 406 status = TEST_FAILED; 407 goto error_exit; 408 } 409 410 if (t->op_mask & BLOCKCIPHER_TEST_OP_CIPHER) { 411 uint8_t buffer[2048]; 412 const uint8_t *compare_ref; 413 uint32_t compare_len; 414 415 if (t->op_mask & BLOCKCIPHER_TEST_OP_ENCRYPT) { 416 compare_ref = tdata->ciphertext.data; 417 compare_len = tdata->ciphertext.len; 418 } else { 419 compare_ref = tdata->plaintext.data; 420 compare_len = tdata->plaintext.len; 421 } 422 423 if (memcmp(rte_pktmbuf_read(iobuf, tdata->iv.len, compare_len, 424 buffer), compare_ref, compare_len)) { 425 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "line %u " 426 "FAILED: %s", __LINE__, 427 "Crypto data not as expected"); 428 status = TEST_FAILED; 429 goto error_exit; 430 } 431 } 432 433 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH_GEN) { 434 uint8_t *auth_res; 435 436 if (t->op_mask & BLOCKCIPHER_TEST_OP_CIPHER) 437 auth_res = pktmbuf_mtod_offset(iobuf, 438 tdata->iv.len + tdata->ciphertext.len); 439 else 440 auth_res = pktmbuf_mtod_offset(iobuf, 441 tdata->ciphertext.len); 442 443 if (memcmp(auth_res, tdata->digest.data, digest_len)) { 444 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "line %u " 445 "FAILED: %s", __LINE__, "Generated " 446 "digest data not as expected"); 447 status = TEST_FAILED; 448 goto error_exit; 449 } 450 } 451 452 /* The only parts that should have changed in the buffer are 453 * plaintext/ciphertext and digest. 454 * In OOP only the dest buffer should change. 455 */ 456 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_OOP) { 457 struct rte_mbuf *mbuf; 458 uint8_t value; 459 uint32_t head_unchanged_len = 0, changed_len = 0; 460 uint32_t i; 461 462 mbuf = sym_op->m_src; 463 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH_VERIFY) { 464 /* white-box test: PMDs use some of the 465 * tailroom as temp storage in verify case 466 */ 467 head_unchanged_len = rte_pktmbuf_headroom(mbuf) 468 + rte_pktmbuf_data_len(mbuf); 469 changed_len = digest_len; 470 } else { 471 head_unchanged_len = mbuf->buf_len; 472 changed_len = 0; 473 } 474 475 for (i = 0; i < mbuf->buf_len; i++) { 476 if (i == head_unchanged_len) 477 i += changed_len; 478 value = *((uint8_t *)(mbuf->buf_addr)+i); 479 if (value != tmp_src_buf[i]) { 480 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, 481 "line %u FAILED: OOP src outer mbuf data (0x%x) not as expected (0x%x)", 482 __LINE__, value, tmp_src_buf[i]); 483 status = TEST_FAILED; 484 goto error_exit; 485 } 486 } 487 488 mbuf = sym_op->m_dst; 489 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH) { 490 head_unchanged_len = rte_pktmbuf_headroom(mbuf) + 491 sym_op->auth.data.offset; 492 changed_len = sym_op->auth.data.length; 493 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH_GEN) 494 changed_len += sym_op->auth.digest.length; 495 } else { 496 /* cipher-only */ 497 head_unchanged_len = rte_pktmbuf_headroom(mbuf) + 498 sym_op->cipher.data.offset; 499 changed_len = sym_op->cipher.data.length; 500 } 501 502 for (i = 0; i < mbuf->buf_len; i++) { 503 if (i == head_unchanged_len) 504 i += changed_len; 505 value = *((uint8_t *)(mbuf->buf_addr)+i); 506 if (value != tmp_dst_buf[i]) { 507 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, 508 "line %u FAILED: OOP dst outer mbuf data " 509 "(0x%x) not as expected (0x%x)", 510 __LINE__, value, tmp_dst_buf[i]); 511 status = TEST_FAILED; 512 goto error_exit; 513 } 514 } 515 } else { 516 /* In-place operation */ 517 struct rte_mbuf *mbuf; 518 uint8_t value; 519 uint32_t head_unchanged_len = 0, changed_len = 0; 520 uint32_t i; 521 522 mbuf = sym_op->m_src; 523 if (t->op_mask & BLOCKCIPHER_TEST_OP_CIPHER) { 524 head_unchanged_len = rte_pktmbuf_headroom(mbuf) + 525 sym_op->cipher.data.offset; 526 changed_len = sym_op->cipher.data.length; 527 } else { 528 /* auth-only */ 529 head_unchanged_len = rte_pktmbuf_headroom(mbuf) + 530 sym_op->auth.data.offset + 531 sym_op->auth.data.length; 532 changed_len = 0; 533 } 534 535 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH_GEN) 536 changed_len += sym_op->auth.digest.length; 537 538 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH_VERIFY) { 539 /* white-box test: PMDs use some of the 540 * tailroom as temp storage in verify case 541 */ 542 if (t->op_mask & BLOCKCIPHER_TEST_OP_CIPHER) { 543 /* This is simplified, not checking digest*/ 544 changed_len += digest_len*2; 545 } else { 546 head_unchanged_len += digest_len; 547 changed_len += digest_len; 548 } 549 } 550 551 for (i = 0; i < mbuf->buf_len; i++) { 552 if (i == head_unchanged_len) 553 i += changed_len; 554 value = *((uint8_t *)(mbuf->buf_addr)+i); 555 if (value != tmp_src_buf[i]) { 556 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, 557 "line %u FAILED: outer mbuf data (0x%x) " 558 "not as expected (0x%x)", 559 __LINE__, value, tmp_src_buf[i]); 560 status = TEST_FAILED; 561 goto error_exit; 562 } 563 } 564 } 565 566 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "PASS"); 567 568 error_exit: 569 if (!(t->feature_mask & BLOCKCIPHER_TEST_FEATURE_SESSIONLESS)) { 570 if (sess) 571 rte_cryptodev_sym_session_free(dev_id, sess); 572 if (cipher_xform) 573 rte_free(cipher_xform); 574 if (auth_xform) 575 rte_free(auth_xform); 576 } 577 578 if (op) 579 rte_crypto_op_free(op); 580 581 if (obuf) 582 rte_pktmbuf_free(obuf); 583 584 if (ibuf) 585 rte_pktmbuf_free(ibuf); 586 587 return status; 588 } 589 590 int 591 test_blockcipher_all_tests(struct rte_mempool *mbuf_pool, 592 struct rte_mempool *op_mpool, 593 uint8_t dev_id, 594 enum rte_cryptodev_type cryptodev_type, 595 enum blockcipher_test_type test_type) 596 { 597 int status, overall_status = TEST_SUCCESS; 598 uint32_t i, test_index = 0; 599 char test_msg[BLOCKCIPHER_TEST_MSG_LEN + 1]; 600 uint32_t n_test_cases = 0; 601 uint32_t target_pmd_mask = 0; 602 const struct blockcipher_test_case *tcs = NULL; 603 604 switch (test_type) { 605 case BLKCIPHER_AES_CHAIN_TYPE: 606 n_test_cases = sizeof(aes_chain_test_cases) / 607 sizeof(aes_chain_test_cases[0]); 608 tcs = aes_chain_test_cases; 609 break; 610 case BLKCIPHER_AES_CIPHERONLY_TYPE: 611 n_test_cases = sizeof(aes_cipheronly_test_cases) / 612 sizeof(aes_cipheronly_test_cases[0]); 613 tcs = aes_cipheronly_test_cases; 614 break; 615 case BLKCIPHER_3DES_CHAIN_TYPE: 616 n_test_cases = sizeof(triple_des_chain_test_cases) / 617 sizeof(triple_des_chain_test_cases[0]); 618 tcs = triple_des_chain_test_cases; 619 break; 620 case BLKCIPHER_3DES_CIPHERONLY_TYPE: 621 n_test_cases = sizeof(triple_des_cipheronly_test_cases) / 622 sizeof(triple_des_cipheronly_test_cases[0]); 623 tcs = triple_des_cipheronly_test_cases; 624 break; 625 case BLKCIPHER_DES_CIPHERONLY_TYPE: 626 n_test_cases = sizeof(des_cipheronly_test_cases) / 627 sizeof(des_cipheronly_test_cases[0]); 628 tcs = des_cipheronly_test_cases; 629 break; 630 case BLKCIPHER_AUTHONLY_TYPE: 631 n_test_cases = sizeof(hash_test_cases) / 632 sizeof(hash_test_cases[0]); 633 tcs = hash_test_cases; 634 break; 635 default: 636 break; 637 } 638 639 switch (cryptodev_type) { 640 case RTE_CRYPTODEV_AESNI_MB_PMD: 641 target_pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB; 642 break; 643 case RTE_CRYPTODEV_QAT_SYM_PMD: 644 target_pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_QAT; 645 break; 646 case RTE_CRYPTODEV_OPENSSL_PMD: 647 target_pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL; 648 break; 649 case RTE_CRYPTODEV_ARMV8_PMD: 650 target_pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_ARMV8; 651 break; 652 default: 653 TEST_ASSERT(0, "Unrecognized cryptodev type"); 654 break; 655 } 656 657 for (i = 0; i < n_test_cases; i++) { 658 const struct blockcipher_test_case *tc = &tcs[i]; 659 660 if (!(tc->pmd_mask & target_pmd_mask)) 661 continue; 662 663 status = test_blockcipher_one_case(tc, mbuf_pool, op_mpool, 664 dev_id, cryptodev_type, test_msg); 665 666 printf(" %u) TestCase %s %s\n", test_index ++, 667 tc->test_descr, test_msg); 668 669 if (status != TEST_SUCCESS) { 670 if (overall_status == TEST_SUCCESS) 671 overall_status = status; 672 673 if (tc->feature_mask & BLOCKCIPHER_TEST_FEATURE_STOPPER) 674 break; 675 } 676 } 677 678 return overall_status; 679 } 680