1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2015-2017 Intel Corporation
3 */
4
5 #include <rte_common.h>
6 #include <rte_hexdump.h>
7 #include <rte_mbuf.h>
8 #include <rte_malloc.h>
9 #include <rte_memcpy.h>
10 #include <rte_pause.h>
11
12 #include <rte_crypto.h>
13 #include <rte_cryptodev.h>
14 #include <rte_cryptodev_pmd.h>
15
16 #include "test.h"
17 #include "test_cryptodev.h"
18 #include "test_cryptodev_blockcipher.h"
19 #include "test_cryptodev_aes_test_vectors.h"
20 #include "test_cryptodev_des_test_vectors.h"
21 #include "test_cryptodev_hash_test_vectors.h"
22
23 static int
verify_algo_support(const struct blockcipher_test_case * t,const uint8_t dev_id,const uint32_t digest_len)24 verify_algo_support(const struct blockcipher_test_case *t,
25 const uint8_t dev_id, const uint32_t digest_len)
26 {
27 int ret = 0;
28 const struct blockcipher_test_data *tdata = t->test_data;
29 struct rte_cryptodev_sym_capability_idx cap_idx;
30 const struct rte_cryptodev_symmetric_capability *capability;
31
32 if (t->op_mask & BLOCKCIPHER_TEST_OP_CIPHER) {
33 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
34 cap_idx.algo.cipher = tdata->crypto_algo;
35 capability = rte_cryptodev_sym_capability_get(dev_id, &cap_idx);
36 if (capability == NULL)
37 return -1;
38
39 if (cap_idx.algo.cipher != RTE_CRYPTO_CIPHER_NULL)
40 ret = rte_cryptodev_sym_capability_check_cipher(capability,
41 tdata->cipher_key.len,
42 tdata->iv.len);
43 if (ret != 0)
44 return -1;
45 }
46
47 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH) {
48 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
49 cap_idx.algo.auth = tdata->auth_algo;
50 capability = rte_cryptodev_sym_capability_get(dev_id, &cap_idx);
51 if (capability == NULL)
52 return -1;
53
54 if (cap_idx.algo.auth != RTE_CRYPTO_AUTH_NULL)
55 ret = rte_cryptodev_sym_capability_check_auth(capability,
56 tdata->auth_key.len,
57 digest_len,
58 0);
59 if (ret != 0)
60 return -1;
61 }
62
63 return 0;
64 }
65
66 static int
test_blockcipher_one_case(const struct blockcipher_test_case * t,struct rte_mempool * mbuf_pool,struct rte_mempool * op_mpool,struct rte_mempool * sess_mpool,struct rte_mempool * sess_priv_mpool,uint8_t dev_id,char * test_msg)67 test_blockcipher_one_case(const struct blockcipher_test_case *t,
68 struct rte_mempool *mbuf_pool,
69 struct rte_mempool *op_mpool,
70 struct rte_mempool *sess_mpool,
71 struct rte_mempool *sess_priv_mpool,
72 uint8_t dev_id,
73 char *test_msg)
74 {
75 struct rte_mbuf *ibuf = NULL;
76 struct rte_mbuf *obuf = NULL;
77 struct rte_mbuf *iobuf;
78 struct rte_crypto_sym_xform *cipher_xform = NULL;
79 struct rte_crypto_sym_xform *auth_xform = NULL;
80 struct rte_crypto_sym_xform *init_xform = NULL;
81 struct rte_crypto_sym_op *sym_op = NULL;
82 struct rte_crypto_op *op = NULL;
83 struct rte_cryptodev_info dev_info;
84 struct rte_cryptodev_sym_session *sess = NULL;
85
86 int status = TEST_SUCCESS;
87 const struct blockcipher_test_data *tdata = t->test_data;
88 uint8_t cipher_key[tdata->cipher_key.len];
89 uint8_t auth_key[tdata->auth_key.len];
90 uint32_t buf_len = tdata->ciphertext.len;
91 uint32_t digest_len = tdata->digest.len;
92 char *buf_p = NULL;
93 uint8_t src_pattern = 0xa5;
94 uint8_t dst_pattern = 0xb6;
95 uint8_t tmp_src_buf[MBUF_SIZE];
96 uint8_t tmp_dst_buf[MBUF_SIZE];
97
98 int nb_segs = 1;
99 uint32_t nb_iterates = 0;
100
101 rte_cryptodev_info_get(dev_id, &dev_info);
102 uint64_t feat_flags = dev_info.feature_flags;
103
104 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_SESSIONLESS) {
105 if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
106 printf("Device doesn't support sessionless operations "
107 "Test Skipped.\n");
108 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN,
109 "SKIPPED");
110 return TEST_SKIPPED;
111 }
112 }
113 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_SG) {
114 uint64_t oop_flag = RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT;
115
116 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_OOP) {
117 if (!(feat_flags & oop_flag)) {
118 printf("Device doesn't support out-of-place "
119 "scatter-gather in input mbuf. "
120 "Test Skipped.\n");
121 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN,
122 "SKIPPED");
123 return TEST_SKIPPED;
124 }
125 } else {
126 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
127 printf("Device doesn't support in-place "
128 "scatter-gather mbufs. "
129 "Test Skipped.\n");
130 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN,
131 "SKIPPED");
132 return TEST_SKIPPED;
133 }
134 }
135
136 nb_segs = 3;
137 }
138
139 if (global_api_test_type == CRYPTODEV_RAW_API_TEST &&
140 !(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP)) {
141 printf("Device doesn't support raw data-path APIs. "
142 "Test Skipped.\n");
143 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "SKIPPED");
144 return TEST_SKIPPED;
145 }
146
147 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_OOP) {
148 uint64_t oop_flags = RTE_CRYPTODEV_FF_OOP_LB_IN_LB_OUT |
149 RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT |
150 RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT |
151 RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT;
152 if (!(feat_flags & oop_flags)) {
153 printf("Device doesn't support out-of-place operations."
154 "Test Skipped.\n");
155 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN,
156 "SKIPPED");
157 return TEST_SKIPPED;
158 }
159 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) {
160 printf("Raw Data Path APIs do not support OOP, "
161 "Test Skipped.\n");
162 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "SKIPPED");
163 status = TEST_SUCCESS;
164 goto error_exit;
165 }
166 }
167
168 if (tdata->cipher_key.len)
169 memcpy(cipher_key, tdata->cipher_key.data,
170 tdata->cipher_key.len);
171 if (tdata->auth_key.len)
172 memcpy(auth_key, tdata->auth_key.data,
173 tdata->auth_key.len);
174
175 /* Check if PMD is capable of performing that test */
176 if (verify_algo_support(t, dev_id, digest_len) < 0) {
177 RTE_LOG(DEBUG, USER1,
178 "Device does not support this algorithm."
179 "Test Skipped.\n");
180 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "SKIPPED");
181 return TEST_SKIPPED;
182 }
183
184 /* preparing data */
185 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH)
186 buf_len += digest_len;
187
188 /* for contiguous mbuf, nb_segs is 1 */
189 ibuf = create_segmented_mbuf(mbuf_pool,
190 tdata->ciphertext.len, nb_segs, src_pattern);
191 if (ibuf == NULL) {
192 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN,
193 "line %u FAILED: %s",
194 __LINE__, "Cannot create source mbuf");
195 status = TEST_FAILED;
196 goto error_exit;
197 }
198
199 /* only encryption requires plaintext.data input,
200 * decryption/(digest gen)/(digest verify) use ciphertext.data
201 * to be computed
202 */
203 if (t->op_mask & BLOCKCIPHER_TEST_OP_ENCRYPT)
204 pktmbuf_write(ibuf, 0, tdata->plaintext.len,
205 tdata->plaintext.data);
206 else
207 pktmbuf_write(ibuf, 0, tdata->ciphertext.len,
208 tdata->ciphertext.data);
209
210 buf_p = rte_pktmbuf_append(ibuf, digest_len);
211 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH_VERIFY)
212 rte_memcpy(buf_p, tdata->digest.data, digest_len);
213 else
214 memset(buf_p, 0, digest_len);
215
216 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_OOP) {
217 obuf = rte_pktmbuf_alloc(mbuf_pool);
218 if (!obuf) {
219 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "line %u "
220 "FAILED: %s", __LINE__,
221 "Allocation of rte_mbuf failed");
222 status = TEST_FAILED;
223 goto error_exit;
224 }
225 memset(obuf->buf_addr, dst_pattern, obuf->buf_len);
226
227 buf_p = rte_pktmbuf_append(obuf, buf_len);
228 if (!buf_p) {
229 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "line %u "
230 "FAILED: %s", __LINE__,
231 "No room to append mbuf");
232 status = TEST_FAILED;
233 goto error_exit;
234 }
235 memset(buf_p, 0, buf_len);
236 }
237
238 /* Generate Crypto op data structure */
239 op = rte_crypto_op_alloc(op_mpool, RTE_CRYPTO_OP_TYPE_SYMMETRIC);
240 if (!op) {
241 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN,
242 "line %u FAILED: %s",
243 __LINE__, "Failed to allocate symmetric crypto "
244 "operation struct");
245 status = TEST_FAILED;
246 goto error_exit;
247 }
248
249 sym_op = op->sym;
250
251 iterate:
252 if (nb_iterates) {
253 struct rte_mbuf *tmp_buf = ibuf;
254
255 ibuf = obuf;
256 obuf = tmp_buf;
257
258 rte_pktmbuf_reset(ibuf);
259 rte_pktmbuf_reset(obuf);
260
261 rte_pktmbuf_append(ibuf, tdata->ciphertext.len);
262
263 /* only encryption requires plaintext.data input,
264 * decryption/(digest gen)/(digest verify) use ciphertext.data
265 * to be computed
266 */
267 if (t->op_mask & BLOCKCIPHER_TEST_OP_ENCRYPT)
268 pktmbuf_write(ibuf, 0, tdata->plaintext.len,
269 tdata->plaintext.data);
270 else
271 pktmbuf_write(ibuf, 0, tdata->ciphertext.len,
272 tdata->ciphertext.data);
273
274 buf_p = rte_pktmbuf_append(ibuf, digest_len);
275 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH_VERIFY)
276 rte_memcpy(buf_p, tdata->digest.data, digest_len);
277 else
278 memset(buf_p, 0, digest_len);
279
280 memset(obuf->buf_addr, dst_pattern, obuf->buf_len);
281
282 buf_p = rte_pktmbuf_append(obuf, buf_len);
283 if (!buf_p) {
284 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "line %u "
285 "FAILED: %s", __LINE__,
286 "No room to append mbuf");
287 status = TEST_FAILED;
288 goto error_exit;
289 }
290 memset(buf_p, 0, buf_len);
291 }
292
293 sym_op->m_src = ibuf;
294
295 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_OOP) {
296 sym_op->m_dst = obuf;
297 iobuf = obuf;
298 } else {
299 sym_op->m_dst = NULL;
300 iobuf = ibuf;
301 }
302
303 /* sessionless op requires allocate xform using
304 * rte_crypto_op_sym_xforms_alloc(), otherwise rte_zmalloc()
305 * is used
306 */
307 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_SESSIONLESS) {
308 uint32_t n_xforms = 0;
309
310 if (t->op_mask & BLOCKCIPHER_TEST_OP_CIPHER)
311 n_xforms++;
312 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH)
313 n_xforms++;
314
315 if (rte_crypto_op_sym_xforms_alloc(op, n_xforms)
316 == NULL) {
317 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "line %u "
318 "FAILED: %s", __LINE__, "Failed to "
319 "allocate space for crypto transforms");
320 status = TEST_FAILED;
321 goto error_exit;
322 }
323 } else {
324 cipher_xform = rte_zmalloc(NULL,
325 sizeof(struct rte_crypto_sym_xform), 0);
326
327 auth_xform = rte_zmalloc(NULL,
328 sizeof(struct rte_crypto_sym_xform), 0);
329
330 if (!cipher_xform || !auth_xform) {
331 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "line %u "
332 "FAILED: %s", __LINE__, "Failed to "
333 "allocate memory for crypto transforms");
334 status = TEST_FAILED;
335 goto error_exit;
336 }
337 }
338
339 /* preparing xform, for sessioned op, init_xform is initialized
340 * here and later as param in rte_cryptodev_sym_session_create() call
341 */
342 if (t->op_mask == BLOCKCIPHER_TEST_OP_ENC_AUTH_GEN) {
343 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_SESSIONLESS) {
344 cipher_xform = op->sym->xform;
345 auth_xform = cipher_xform->next;
346 auth_xform->next = NULL;
347 } else {
348 cipher_xform->next = auth_xform;
349 auth_xform->next = NULL;
350 init_xform = cipher_xform;
351 }
352 } else if (t->op_mask == BLOCKCIPHER_TEST_OP_AUTH_VERIFY_DEC) {
353 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_SESSIONLESS) {
354 auth_xform = op->sym->xform;
355 cipher_xform = auth_xform->next;
356 cipher_xform->next = NULL;
357 } else {
358 auth_xform->next = cipher_xform;
359 cipher_xform->next = NULL;
360 init_xform = auth_xform;
361 }
362 } else if ((t->op_mask == BLOCKCIPHER_TEST_OP_ENCRYPT) ||
363 (t->op_mask == BLOCKCIPHER_TEST_OP_DECRYPT)) {
364 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_SESSIONLESS)
365 cipher_xform = op->sym->xform;
366 else
367 init_xform = cipher_xform;
368 cipher_xform->next = NULL;
369 } else if ((t->op_mask == BLOCKCIPHER_TEST_OP_AUTH_GEN) ||
370 (t->op_mask == BLOCKCIPHER_TEST_OP_AUTH_VERIFY)) {
371 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_SESSIONLESS)
372 auth_xform = op->sym->xform;
373 else
374 init_xform = auth_xform;
375 auth_xform->next = NULL;
376 } else {
377 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN,
378 "line %u FAILED: %s",
379 __LINE__, "Unrecognized operation");
380 status = TEST_FAILED;
381 goto error_exit;
382 }
383
384 /*configure xforms & sym_op cipher and auth data*/
385 if (t->op_mask & BLOCKCIPHER_TEST_OP_CIPHER) {
386 cipher_xform->type = RTE_CRYPTO_SYM_XFORM_CIPHER;
387 cipher_xform->cipher.algo = tdata->crypto_algo;
388 if (t->op_mask & BLOCKCIPHER_TEST_OP_ENCRYPT)
389 cipher_xform->cipher.op =
390 RTE_CRYPTO_CIPHER_OP_ENCRYPT;
391 else
392 cipher_xform->cipher.op =
393 RTE_CRYPTO_CIPHER_OP_DECRYPT;
394 cipher_xform->cipher.key.data = cipher_key;
395 cipher_xform->cipher.key.length = tdata->cipher_key.len;
396 cipher_xform->cipher.iv.offset = IV_OFFSET;
397
398 if (tdata->crypto_algo == RTE_CRYPTO_CIPHER_NULL)
399 cipher_xform->cipher.iv.length = 0;
400 else
401 cipher_xform->cipher.iv.length = tdata->iv.len;
402
403 sym_op->cipher.data.offset = tdata->cipher_offset;
404 sym_op->cipher.data.length = tdata->ciphertext.len -
405 tdata->cipher_offset;
406 rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
407 tdata->iv.data,
408 tdata->iv.len);
409 }
410
411 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH) {
412 uint32_t digest_offset = tdata->ciphertext.len;
413
414 auth_xform->type = RTE_CRYPTO_SYM_XFORM_AUTH;
415 auth_xform->auth.algo = tdata->auth_algo;
416 auth_xform->auth.key.length = tdata->auth_key.len;
417 auth_xform->auth.key.data = auth_key;
418 auth_xform->auth.digest_length = digest_len;
419
420 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH_GEN) {
421 auth_xform->auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
422 sym_op->auth.digest.data = pktmbuf_mtod_offset
423 (iobuf, digest_offset);
424 sym_op->auth.digest.phys_addr =
425 pktmbuf_iova_offset(iobuf,
426 digest_offset);
427 } else {
428 auth_xform->auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
429 sym_op->auth.digest.data = pktmbuf_mtod_offset
430 (sym_op->m_src, digest_offset);
431 sym_op->auth.digest.phys_addr =
432 pktmbuf_iova_offset(sym_op->m_src,
433 digest_offset);
434 }
435
436 sym_op->auth.data.offset = tdata->auth_offset;
437 sym_op->auth.data.length = tdata->ciphertext.len -
438 tdata->auth_offset;
439 }
440
441 /**
442 * Create session for sessioned op. For mbuf iteration test,
443 * skip the session creation for the second iteration.
444 */
445 if (!(t->feature_mask & BLOCKCIPHER_TEST_FEATURE_SESSIONLESS) &&
446 nb_iterates == 0) {
447 sess = rte_cryptodev_sym_session_create(sess_mpool);
448
449 status = rte_cryptodev_sym_session_init(dev_id, sess,
450 init_xform, sess_priv_mpool);
451 if (status == -ENOTSUP) {
452 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "UNSUPPORTED");
453 status = TEST_SKIPPED;
454 goto error_exit;
455 }
456 if (!sess || status < 0) {
457 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "line %u "
458 "FAILED: %s", __LINE__,
459 "Session creation failed");
460 status = TEST_FAILED;
461 goto error_exit;
462 }
463
464 /* attach symmetric crypto session to crypto operations */
465 rte_crypto_op_attach_sym_session(op, sess);
466 }
467
468 debug_hexdump(stdout, "m_src(before):",
469 sym_op->m_src->buf_addr, sym_op->m_src->buf_len);
470 rte_memcpy(tmp_src_buf, sym_op->m_src->buf_addr,
471 sym_op->m_src->buf_len);
472 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_OOP) {
473 debug_hexdump(stdout, "m_dst(before):",
474 sym_op->m_dst->buf_addr, sym_op->m_dst->buf_len);
475 rte_memcpy(tmp_dst_buf, sym_op->m_dst->buf_addr,
476 sym_op->m_dst->buf_len);
477 }
478
479 /* Process crypto operation */
480 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) {
481 uint8_t is_cipher = 0, is_auth = 0;
482 if (t->op_mask & BLOCKCIPHER_TEST_OP_CIPHER)
483 is_cipher = 1;
484 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH)
485 is_auth = 1;
486
487 process_sym_raw_dp_op(dev_id, 0, op, is_cipher, is_auth, 0,
488 tdata->iv.len);
489 } else {
490 if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
491 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN,
492 "line %u FAILED: %s",
493 __LINE__, "Error sending packet for encryption");
494 status = TEST_FAILED;
495 goto error_exit;
496 }
497
498 op = NULL;
499
500 while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0)
501 rte_pause();
502
503 if (!op) {
504 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN,
505 "line %u FAILED: %s",
506 __LINE__, "Failed to process sym crypto op");
507 status = TEST_FAILED;
508 goto error_exit;
509 }
510 }
511
512 debug_hexdump(stdout, "m_src(after):",
513 sym_op->m_src->buf_addr, sym_op->m_src->buf_len);
514 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_OOP)
515 debug_hexdump(stdout, "m_dst(after):",
516 sym_op->m_dst->buf_addr, sym_op->m_dst->buf_len);
517
518 /* Verify results */
519 if (op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
520 if ((t->op_mask & BLOCKCIPHER_TEST_OP_AUTH_VERIFY) &&
521 (op->status == RTE_CRYPTO_OP_STATUS_AUTH_FAILED))
522 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "line %u "
523 "FAILED: Digest verification failed "
524 "(0x%X)", __LINE__, op->status);
525 else
526 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "line %u "
527 "FAILED: Operation failed "
528 "(0x%X)", __LINE__, op->status);
529 status = TEST_FAILED;
530 goto error_exit;
531 }
532
533 if (t->op_mask & BLOCKCIPHER_TEST_OP_CIPHER) {
534 uint8_t buffer[2048];
535 const uint8_t *compare_ref;
536 uint32_t compare_len;
537
538 if (t->op_mask & BLOCKCIPHER_TEST_OP_ENCRYPT) {
539 compare_ref = tdata->ciphertext.data +
540 tdata->cipher_offset;
541 compare_len = tdata->ciphertext.len -
542 tdata->cipher_offset;
543 } else {
544 compare_ref = tdata->plaintext.data +
545 tdata->cipher_offset;
546 compare_len = tdata->plaintext.len -
547 tdata->cipher_offset;
548 }
549
550 if (memcmp(rte_pktmbuf_read(iobuf, tdata->cipher_offset,
551 compare_len, buffer), compare_ref,
552 compare_len)) {
553 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "line %u "
554 "FAILED: %s", __LINE__,
555 "Crypto data not as expected");
556 status = TEST_FAILED;
557 goto error_exit;
558 }
559 }
560
561 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH_GEN) {
562 uint8_t *auth_res = pktmbuf_mtod_offset(iobuf,
563 tdata->ciphertext.len);
564
565 if (memcmp(auth_res, tdata->digest.data, digest_len)) {
566 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "line %u "
567 "FAILED: %s", __LINE__, "Generated "
568 "digest data not as expected");
569 status = TEST_FAILED;
570 goto error_exit;
571 }
572 }
573
574 /* The only parts that should have changed in the buffer are
575 * plaintext/ciphertext and digest.
576 * In OOP only the dest buffer should change.
577 */
578 if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_OOP) {
579 struct rte_mbuf *mbuf;
580 uint8_t value;
581 uint32_t head_unchanged_len, changed_len = 0;
582 uint32_t i;
583 uint32_t hdroom_used = 0, tlroom_used = 0;
584 uint32_t hdroom = 0;
585
586 mbuf = sym_op->m_src;
587 /*
588 * Crypto PMDs specify the headroom & tailroom it would use
589 * when processing the crypto operation. PMD is free to modify
590 * this space, and so the verification check should skip that
591 * block.
592 */
593 hdroom_used = dev_info.min_mbuf_headroom_req;
594 tlroom_used = dev_info.min_mbuf_tailroom_req;
595
596 /* Get headroom */
597 hdroom = rte_pktmbuf_headroom(mbuf);
598
599 head_unchanged_len = mbuf->buf_len;
600
601 for (i = 0; i < mbuf->buf_len; i++) {
602
603 /* Skip headroom used by PMD */
604 if (i == hdroom - hdroom_used)
605 i += hdroom_used;
606
607 /* Skip tailroom used by PMD */
608 if (i == (hdroom + mbuf->data_len))
609 i += tlroom_used;
610
611 value = *((uint8_t *)(mbuf->buf_addr)+i);
612 if (value != tmp_src_buf[i]) {
613 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN,
614 "line %u FAILED: OOP src outer mbuf data (0x%x) not as expected (0x%x)",
615 __LINE__, value, tmp_src_buf[i]);
616 status = TEST_FAILED;
617 goto error_exit;
618 }
619 }
620
621 mbuf = sym_op->m_dst;
622 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH) {
623 head_unchanged_len = hdroom + sym_op->auth.data.offset;
624 changed_len = sym_op->auth.data.length;
625 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH_GEN)
626 changed_len += digest_len;
627 } else {
628 /* cipher-only */
629 head_unchanged_len = hdroom +
630 sym_op->cipher.data.offset;
631 changed_len = sym_op->cipher.data.length;
632 }
633
634 for (i = 0; i < mbuf->buf_len; i++) {
635 if (i == head_unchanged_len)
636 i += changed_len;
637 value = *((uint8_t *)(mbuf->buf_addr)+i);
638 if (value != tmp_dst_buf[i]) {
639 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN,
640 "line %u FAILED: OOP dst outer mbuf data "
641 "(0x%x) not as expected (0x%x)",
642 __LINE__, value, tmp_dst_buf[i]);
643 status = TEST_FAILED;
644 goto error_exit;
645 }
646 }
647
648 if (!nb_iterates) {
649 nb_iterates++;
650 goto iterate;
651 }
652 } else {
653 /* In-place operation */
654 struct rte_mbuf *mbuf;
655 uint8_t value;
656 uint32_t head_unchanged_len = 0, changed_len = 0;
657 uint32_t i;
658 uint32_t hdroom_used = 0, tlroom_used = 0;
659 uint32_t hdroom = 0;
660
661 /*
662 * Crypto PMDs specify the headroom & tailroom it would use
663 * when processing the crypto operation. PMD is free to modify
664 * this space, and so the verification check should skip that
665 * block.
666 */
667 hdroom_used = dev_info.min_mbuf_headroom_req;
668 tlroom_used = dev_info.min_mbuf_tailroom_req;
669
670 mbuf = sym_op->m_src;
671
672 /* Get headroom */
673 hdroom = rte_pktmbuf_headroom(mbuf);
674
675 if (t->op_mask & BLOCKCIPHER_TEST_OP_CIPHER) {
676 head_unchanged_len = hdroom +
677 sym_op->cipher.data.offset;
678 changed_len = sym_op->cipher.data.length;
679 } else {
680 /* auth-only */
681 head_unchanged_len = hdroom +
682 sym_op->auth.data.offset +
683 sym_op->auth.data.length;
684 changed_len = 0;
685 }
686
687 if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH_GEN)
688 changed_len += digest_len;
689
690 for (i = 0; i < mbuf->buf_len; i++) {
691
692 /* Skip headroom used by PMD */
693 if (i == hdroom - hdroom_used)
694 i += hdroom_used;
695
696 if (i == head_unchanged_len)
697 i += changed_len;
698
699 /* Skip tailroom used by PMD */
700 if (i == (hdroom + mbuf->data_len))
701 i += tlroom_used;
702
703 value = *((uint8_t *)(mbuf->buf_addr)+i);
704 if (value != tmp_src_buf[i]) {
705 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN,
706 "line %u FAILED: outer mbuf data (0x%x) "
707 "not as expected (0x%x)",
708 __LINE__, value, tmp_src_buf[i]);
709 status = TEST_FAILED;
710 goto error_exit;
711 }
712 }
713 }
714
715 snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "PASS");
716
717 error_exit:
718 if (!(t->feature_mask & BLOCKCIPHER_TEST_FEATURE_SESSIONLESS)) {
719 if (sess) {
720 rte_cryptodev_sym_session_clear(dev_id, sess);
721 rte_cryptodev_sym_session_free(sess);
722 }
723 if (cipher_xform)
724 rte_free(cipher_xform);
725 if (auth_xform)
726 rte_free(auth_xform);
727 }
728
729 if (op)
730 rte_crypto_op_free(op);
731
732 if (obuf)
733 rte_pktmbuf_free(obuf);
734
735 if (ibuf)
736 rte_pktmbuf_free(ibuf);
737
738 return status;
739 }
740
741 int
test_blockcipher_all_tests(struct rte_mempool * mbuf_pool,struct rte_mempool * op_mpool,struct rte_mempool * sess_mpool,struct rte_mempool * sess_priv_mpool,uint8_t dev_id,enum blockcipher_test_type test_type)742 test_blockcipher_all_tests(struct rte_mempool *mbuf_pool,
743 struct rte_mempool *op_mpool,
744 struct rte_mempool *sess_mpool,
745 struct rte_mempool *sess_priv_mpool,
746 uint8_t dev_id,
747 enum blockcipher_test_type test_type)
748 {
749 int status, overall_status = TEST_SUCCESS;
750 uint32_t i, test_index = 0;
751 char test_msg[BLOCKCIPHER_TEST_MSG_LEN + 1];
752 uint32_t n_test_cases = 0;
753 const struct blockcipher_test_case *tcs = NULL;
754
755 switch (test_type) {
756 case BLKCIPHER_AES_CHAIN_TYPE:
757 n_test_cases = sizeof(aes_chain_test_cases) /
758 sizeof(aes_chain_test_cases[0]);
759 tcs = aes_chain_test_cases;
760 break;
761 case BLKCIPHER_AES_CIPHERONLY_TYPE:
762 n_test_cases = sizeof(aes_cipheronly_test_cases) /
763 sizeof(aes_cipheronly_test_cases[0]);
764 tcs = aes_cipheronly_test_cases;
765 break;
766 case BLKCIPHER_AES_DOCSIS_TYPE:
767 n_test_cases = sizeof(aes_docsis_test_cases) /
768 sizeof(aes_docsis_test_cases[0]);
769 tcs = aes_docsis_test_cases;
770 break;
771 case BLKCIPHER_3DES_CHAIN_TYPE:
772 n_test_cases = sizeof(triple_des_chain_test_cases) /
773 sizeof(triple_des_chain_test_cases[0]);
774 tcs = triple_des_chain_test_cases;
775 break;
776 case BLKCIPHER_3DES_CIPHERONLY_TYPE:
777 n_test_cases = sizeof(triple_des_cipheronly_test_cases) /
778 sizeof(triple_des_cipheronly_test_cases[0]);
779 tcs = triple_des_cipheronly_test_cases;
780 break;
781 case BLKCIPHER_DES_CIPHERONLY_TYPE:
782 n_test_cases = sizeof(des_cipheronly_test_cases) /
783 sizeof(des_cipheronly_test_cases[0]);
784 tcs = des_cipheronly_test_cases;
785 break;
786 case BLKCIPHER_DES_DOCSIS_TYPE:
787 n_test_cases = sizeof(des_docsis_test_cases) /
788 sizeof(des_docsis_test_cases[0]);
789 tcs = des_docsis_test_cases;
790 break;
791 case BLKCIPHER_AUTHONLY_TYPE:
792 n_test_cases = sizeof(hash_test_cases) /
793 sizeof(hash_test_cases[0]);
794 tcs = hash_test_cases;
795 break;
796 default:
797 break;
798 }
799
800 for (i = 0; i < n_test_cases; i++) {
801 const struct blockcipher_test_case *tc = &tcs[i];
802
803 status = test_blockcipher_one_case(tc, mbuf_pool, op_mpool,
804 sess_mpool, sess_priv_mpool, dev_id,
805 test_msg);
806
807 printf(" %u) TestCase %s %s\n", test_index ++,
808 tc->test_descr, test_msg);
809
810 if (status == TEST_FAILED) {
811 overall_status = status;
812
813 if (tc->feature_mask & BLOCKCIPHER_TEST_FEATURE_STOPPER)
814 break;
815 }
816 }
817
818 return overall_status;
819 }
820