1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2015-2020 Intel Corporation
8 #include <rte_common.h>
9 #include <rte_hexdump.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>
17 #include <rte_crypto.h>
18 #include <rte_cryptodev.h>
19 #include <rte_cryptodev_pmd.h>
20 #include <rte_string_fns.h>
22 #ifdef RTE_CRYPTO_SCHEDULER
23 #include <rte_cryptodev_scheduler.h>
24 #include <rte_cryptodev_scheduler_operations.h>
27 #include <rte_lcore.h>
30 #include "test_cryptodev.h"
32 #include "test_cryptodev_blockcipher.h"
33 #include "test_cryptodev_aes_test_vectors.h"
34 #include "test_cryptodev_des_test_vectors.h"
35 #include "test_cryptodev_hash_test_vectors.h"
36 #include "test_cryptodev_kasumi_test_vectors.h"
37 #include "test_cryptodev_kasumi_hash_test_vectors.h"
38 #include "test_cryptodev_snow3g_test_vectors.h"
39 #include "test_cryptodev_snow3g_hash_test_vectors.h"
40 #include "test_cryptodev_zuc_test_vectors.h"
41 #include "test_cryptodev_aead_test_vectors.h"
42 #include "test_cryptodev_hmac_test_vectors.h"
43 #include "test_cryptodev_mixed_test_vectors.h"
44 #ifdef RTE_LIB_SECURITY
45 #include "test_cryptodev_security_pdcp_test_vectors.h"
46 #include "test_cryptodev_security_pdcp_sdap_test_vectors.h"
47 #include "test_cryptodev_security_pdcp_test_func.h"
48 #include "test_cryptodev_security_docsis_test_vectors.h"
50 #define SDAP_DISABLED 0
51 #define SDAP_ENABLED 1
54 #define VDEV_ARGS_SIZE 100
55 #define MAX_NB_SESSIONS 4
57 #define MAX_DRV_SERVICE_CTX_SIZE 256
59 #define MAX_RAW_DEQUEUE_COUNT 65535
62 #define OUT_OF_PLACE 1
65 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
68 static int gbl_driver_id;
70 static enum rte_security_session_action_type gbl_action_type =
71 RTE_SECURITY_ACTION_TYPE_NONE;
73 enum cryptodev_api_test_type global_api_test_type = CRYPTODEV_API_TEST;
75 struct crypto_testsuite_params {
76 struct rte_mempool *mbuf_pool;
77 struct rte_mempool *large_mbuf_pool;
78 struct rte_mempool *op_mpool;
79 struct rte_mempool *session_mpool;
80 struct rte_mempool *session_priv_mpool;
81 struct rte_cryptodev_config conf;
82 struct rte_cryptodev_qp_conf qp_conf;
84 uint8_t valid_devs[RTE_CRYPTO_MAX_DEVS];
85 uint8_t valid_dev_count;
88 struct crypto_unittest_params {
89 struct rte_crypto_sym_xform cipher_xform;
90 struct rte_crypto_sym_xform auth_xform;
91 struct rte_crypto_sym_xform aead_xform;
92 #ifdef RTE_LIB_SECURITY
93 struct rte_security_docsis_xform docsis_xform;
97 struct rte_cryptodev_sym_session *sess;
98 #ifdef RTE_LIB_SECURITY
99 struct rte_security_session *sec_session;
102 #ifdef RTE_LIB_SECURITY
103 enum rte_security_session_action_type type;
105 struct rte_crypto_op *op;
107 struct rte_mbuf *obuf, *ibuf;
112 #define ALIGN_POW2_ROUNDUP(num, align) \
113 (((num) + (align) - 1) & ~((align) - 1))
116 * Forward declarations.
119 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
120 struct crypto_unittest_params *ut_params, uint8_t *cipher_key,
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,
131 static struct rte_mbuf *
132 setup_test_string(struct rte_mempool *mpool,
133 const char *string, size_t len, uint8_t blocksize)
135 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
136 size_t t_len = len - (blocksize ? (len % blocksize) : 0);
138 memset(m->buf_addr, 0, m->buf_len);
140 char *dst = rte_pktmbuf_append(m, t_len);
147 rte_memcpy(dst, string, t_len);
149 memset(dst, 0, t_len);
155 /* Get number of bytes in X bits (rounding up) */
157 ceil_byte_length(uint32_t num_bits)
160 return ((num_bits >> 3) + 1);
162 return (num_bits >> 3);
166 get_raw_dp_dequeue_count(void *user_data __rte_unused)
172 post_process_raw_dp_op(void *user_data, uint32_t index __rte_unused,
173 uint8_t is_op_success)
175 struct rte_crypto_op *op = user_data;
176 op->status = is_op_success ? RTE_CRYPTO_OP_STATUS_SUCCESS :
177 RTE_CRYPTO_OP_STATUS_ERROR;
181 process_sym_raw_dp_op(uint8_t dev_id, uint16_t qp_id,
182 struct rte_crypto_op *op, uint8_t is_cipher, uint8_t is_auth,
183 uint8_t len_in_bits, uint8_t cipher_iv_len)
185 struct rte_crypto_sym_op *sop = op->sym;
186 struct rte_crypto_op *ret_op = NULL;
187 struct rte_crypto_vec data_vec[UINT8_MAX];
188 struct rte_crypto_va_iova_ptr cipher_iv, digest, aad_auth_iv;
189 union rte_crypto_sym_ofs ofs;
190 struct rte_crypto_sym_vec vec;
191 struct rte_crypto_sgl sgl;
193 union rte_cryptodev_session_ctx sess;
195 struct rte_crypto_raw_dp_ctx *ctx;
196 uint32_t cipher_offset = 0, cipher_len = 0, auth_offset = 0,
200 int ctx_service_size;
202 int enqueue_status, dequeue_status;
204 ctx_service_size = rte_cryptodev_get_raw_dp_ctx_size(dev_id);
205 if (ctx_service_size < 0) {
206 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
210 ctx = malloc(ctx_service_size);
212 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
216 /* Both are enums, setting crypto_sess will suit any session type */
217 sess.crypto_sess = op->sym->session;
219 if (rte_cryptodev_configure_raw_dp_ctx(dev_id, qp_id, ctx,
220 op->sess_type, sess, 0) < 0) {
221 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
227 aad_auth_iv.iova = 0;
228 aad_auth_iv.va = NULL;
235 vec.digest = &digest;
236 vec.aad = &aad_auth_iv;
237 vec.status = &status;
241 if (is_cipher && is_auth) {
242 cipher_offset = sop->cipher.data.offset;
243 cipher_len = sop->cipher.data.length;
244 auth_offset = sop->auth.data.offset;
245 auth_len = sop->auth.data.length;
246 max_len = RTE_MAX(cipher_offset + cipher_len,
247 auth_offset + auth_len);
249 max_len = max_len >> 3;
250 cipher_offset = cipher_offset >> 3;
251 auth_offset = auth_offset >> 3;
252 cipher_len = cipher_len >> 3;
253 auth_len = auth_len >> 3;
255 ofs.ofs.cipher.head = cipher_offset;
256 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
257 ofs.ofs.auth.head = auth_offset;
258 ofs.ofs.auth.tail = max_len - auth_offset - auth_len;
259 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
260 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
261 aad_auth_iv.va = rte_crypto_op_ctod_offset(
262 op, void *, IV_OFFSET + cipher_iv_len);
263 aad_auth_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET +
265 digest.va = (void *)sop->auth.digest.data;
266 digest.iova = sop->auth.digest.phys_addr;
268 } else if (is_cipher) {
269 cipher_offset = sop->cipher.data.offset;
270 cipher_len = sop->cipher.data.length;
271 max_len = cipher_len + cipher_offset;
273 max_len = max_len >> 3;
274 cipher_offset = cipher_offset >> 3;
275 cipher_len = cipher_len >> 3;
277 ofs.ofs.cipher.head = cipher_offset;
278 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
279 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
280 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
282 } else if (is_auth) {
283 auth_offset = sop->auth.data.offset;
284 auth_len = sop->auth.data.length;
285 max_len = auth_len + auth_offset;
287 max_len = max_len >> 3;
288 auth_offset = auth_offset >> 3;
289 auth_len = auth_len >> 3;
291 ofs.ofs.auth.head = auth_offset;
292 ofs.ofs.auth.tail = max_len - auth_offset - auth_len;
293 aad_auth_iv.va = rte_crypto_op_ctod_offset(
294 op, void *, IV_OFFSET + cipher_iv_len);
295 aad_auth_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET +
297 digest.va = (void *)sop->auth.digest.data;
298 digest.iova = sop->auth.digest.phys_addr;
301 cipher_offset = sop->aead.data.offset;
302 cipher_len = sop->aead.data.length;
303 max_len = cipher_len + cipher_offset;
305 max_len = max_len >> 3;
306 cipher_offset = cipher_offset >> 3;
307 cipher_len = cipher_len >> 3;
309 ofs.ofs.cipher.head = cipher_offset;
310 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
311 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
312 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
313 aad_auth_iv.va = (void *)sop->aead.aad.data;
314 aad_auth_iv.iova = sop->aead.aad.phys_addr;
315 digest.va = (void *)sop->aead.digest.data;
316 digest.iova = sop->aead.digest.phys_addr;
319 n = rte_crypto_mbuf_to_vec(sop->m_src, 0, max_len,
320 data_vec, RTE_DIM(data_vec));
321 if (n < 0 || n > sop->m_src->nb_segs) {
322 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
328 if (rte_cryptodev_raw_enqueue_burst(ctx, &vec, ofs, (void **)&op,
329 &enqueue_status) < 1) {
330 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
334 if (enqueue_status == 0) {
335 status = rte_cryptodev_raw_enqueue_done(ctx, 1);
337 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
340 } else if (enqueue_status < 0) {
341 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
346 while (count++ < MAX_RAW_DEQUEUE_COUNT && n == 0) {
347 n = rte_cryptodev_raw_dequeue_burst(ctx,
348 get_raw_dp_dequeue_count, post_process_raw_dp_op,
349 (void **)&ret_op, 0, &n_success,
351 if (dequeue_status < 0) {
352 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
359 if (n == 1 && dequeue_status == 0) {
360 if (rte_cryptodev_raw_dequeue_done(ctx, 1) < 0) {
361 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
366 op->status = (count == MAX_RAW_DEQUEUE_COUNT + 1 || ret_op != op ||
367 n_success < 1) ? RTE_CRYPTO_OP_STATUS_ERROR :
368 RTE_CRYPTO_OP_STATUS_SUCCESS;
375 process_cpu_aead_op(uint8_t dev_id, struct rte_crypto_op *op)
378 struct rte_crypto_sym_op *sop;
379 union rte_crypto_sym_ofs ofs;
380 struct rte_crypto_sgl sgl;
381 struct rte_crypto_sym_vec symvec;
382 struct rte_crypto_va_iova_ptr iv_ptr, aad_ptr, digest_ptr;
383 struct rte_crypto_vec vec[UINT8_MAX];
387 n = rte_crypto_mbuf_to_vec(sop->m_src, sop->aead.data.offset,
388 sop->aead.data.length, vec, RTE_DIM(vec));
390 if (n < 0 || n != sop->m_src->nb_segs) {
391 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
399 symvec.digest = &digest_ptr;
400 symvec.aad = &aad_ptr;
404 /* for CPU crypto the IOVA address is not required */
405 iv_ptr.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
406 digest_ptr.va = (void *)sop->aead.digest.data;
407 aad_ptr.va = (void *)sop->aead.aad.data;
411 n = rte_cryptodev_sym_cpu_crypto_process(dev_id, sop->session, ofs,
415 op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
417 op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
421 process_cpu_crypt_auth_op(uint8_t dev_id, struct rte_crypto_op *op)
424 struct rte_crypto_sym_op *sop;
425 union rte_crypto_sym_ofs ofs;
426 struct rte_crypto_sgl sgl;
427 struct rte_crypto_sym_vec symvec;
428 struct rte_crypto_va_iova_ptr iv_ptr, digest_ptr;
429 struct rte_crypto_vec vec[UINT8_MAX];
433 n = rte_crypto_mbuf_to_vec(sop->m_src, sop->auth.data.offset,
434 sop->auth.data.length, vec, RTE_DIM(vec));
436 if (n < 0 || n != sop->m_src->nb_segs) {
437 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
445 symvec.digest = &digest_ptr;
449 iv_ptr.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
450 digest_ptr.va = (void *)sop->auth.digest.data;
453 ofs.ofs.cipher.head = sop->cipher.data.offset - sop->auth.data.offset;
454 ofs.ofs.cipher.tail = (sop->auth.data.offset + sop->auth.data.length) -
455 (sop->cipher.data.offset + sop->cipher.data.length);
457 n = rte_cryptodev_sym_cpu_crypto_process(dev_id, sop->session, ofs,
461 op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
463 op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
466 static struct rte_crypto_op *
467 process_crypto_request(uint8_t dev_id, struct rte_crypto_op *op)
470 RTE_VERIFY(gbl_action_type != RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO);
472 if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
473 RTE_LOG(ERR, USER1, "Error sending packet for encryption\n");
479 while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0)
482 if (op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
483 RTE_LOG(DEBUG, USER1, "Operation status %d\n", op->status);
490 static struct crypto_testsuite_params testsuite_params = { NULL };
491 static struct crypto_unittest_params unittest_params;
494 testsuite_setup(void)
496 struct crypto_testsuite_params *ts_params = &testsuite_params;
497 struct rte_cryptodev_info info;
498 uint32_t i = 0, nb_devs, dev_id;
502 memset(ts_params, 0, sizeof(*ts_params));
504 ts_params->mbuf_pool = rte_mempool_lookup("CRYPTO_MBUFPOOL");
505 if (ts_params->mbuf_pool == NULL) {
506 /* Not already created so create */
507 ts_params->mbuf_pool = rte_pktmbuf_pool_create(
509 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
511 if (ts_params->mbuf_pool == NULL) {
512 RTE_LOG(ERR, USER1, "Can't create CRYPTO_MBUFPOOL\n");
517 ts_params->large_mbuf_pool = rte_mempool_lookup(
518 "CRYPTO_LARGE_MBUFPOOL");
519 if (ts_params->large_mbuf_pool == NULL) {
520 /* Not already created so create */
521 ts_params->large_mbuf_pool = rte_pktmbuf_pool_create(
522 "CRYPTO_LARGE_MBUFPOOL",
525 if (ts_params->large_mbuf_pool == NULL) {
527 "Can't create CRYPTO_LARGE_MBUFPOOL\n");
532 ts_params->op_mpool = rte_crypto_op_pool_create(
533 "MBUF_CRYPTO_SYM_OP_POOL",
534 RTE_CRYPTO_OP_TYPE_SYMMETRIC,
535 NUM_MBUFS, MBUF_CACHE_SIZE,
537 sizeof(struct rte_crypto_sym_xform) +
540 if (ts_params->op_mpool == NULL) {
541 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
545 /* Create an AESNI MB device if required */
546 if (gbl_driver_id == rte_cryptodev_driver_id_get(
547 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD))) {
548 nb_devs = rte_cryptodev_device_count_by_driver(
549 rte_cryptodev_driver_id_get(
550 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)));
553 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL);
555 TEST_ASSERT(ret == 0,
556 "Failed to create instance of"
558 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
562 /* Create an AESNI GCM device if required */
563 if (gbl_driver_id == rte_cryptodev_driver_id_get(
564 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD))) {
565 nb_devs = rte_cryptodev_device_count_by_driver(
566 rte_cryptodev_driver_id_get(
567 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD)));
569 TEST_ASSERT_SUCCESS(rte_vdev_init(
570 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD), NULL),
571 "Failed to create instance of"
573 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
577 /* Create a SNOW 3G device if required */
578 if (gbl_driver_id == rte_cryptodev_driver_id_get(
579 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD))) {
580 nb_devs = rte_cryptodev_device_count_by_driver(
581 rte_cryptodev_driver_id_get(
582 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD)));
584 TEST_ASSERT_SUCCESS(rte_vdev_init(
585 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD), NULL),
586 "Failed to create instance of"
588 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
592 /* Create a KASUMI device if required */
593 if (gbl_driver_id == rte_cryptodev_driver_id_get(
594 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD))) {
595 nb_devs = rte_cryptodev_device_count_by_driver(
596 rte_cryptodev_driver_id_get(
597 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD)));
599 TEST_ASSERT_SUCCESS(rte_vdev_init(
600 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD), NULL),
601 "Failed to create instance of"
603 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
607 /* Create a ZUC device if required */
608 if (gbl_driver_id == rte_cryptodev_driver_id_get(
609 RTE_STR(CRYPTODEV_NAME_ZUC_PMD))) {
610 nb_devs = rte_cryptodev_device_count_by_driver(
611 rte_cryptodev_driver_id_get(
612 RTE_STR(CRYPTODEV_NAME_ZUC_PMD)));
614 TEST_ASSERT_SUCCESS(rte_vdev_init(
615 RTE_STR(CRYPTODEV_NAME_ZUC_PMD), NULL),
616 "Failed to create instance of"
618 RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
622 /* Create a NULL device if required */
623 if (gbl_driver_id == rte_cryptodev_driver_id_get(
624 RTE_STR(CRYPTODEV_NAME_NULL_PMD))) {
625 nb_devs = rte_cryptodev_device_count_by_driver(
626 rte_cryptodev_driver_id_get(
627 RTE_STR(CRYPTODEV_NAME_NULL_PMD)));
630 RTE_STR(CRYPTODEV_NAME_NULL_PMD), NULL);
632 TEST_ASSERT(ret == 0,
633 "Failed to create instance of"
635 RTE_STR(CRYPTODEV_NAME_NULL_PMD));
639 /* Create an OPENSSL device if required */
640 if (gbl_driver_id == rte_cryptodev_driver_id_get(
641 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD))) {
642 nb_devs = rte_cryptodev_device_count_by_driver(
643 rte_cryptodev_driver_id_get(
644 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)));
647 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD),
650 TEST_ASSERT(ret == 0, "Failed to create "
651 "instance of pmd : %s",
652 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
656 /* Create a ARMv8 device if required */
657 if (gbl_driver_id == rte_cryptodev_driver_id_get(
658 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD))) {
659 nb_devs = rte_cryptodev_device_count_by_driver(
660 rte_cryptodev_driver_id_get(
661 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD)));
664 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD),
667 TEST_ASSERT(ret == 0, "Failed to create "
668 "instance of pmd : %s",
669 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
673 /* Create a MVSAM device if required */
674 if (gbl_driver_id == rte_cryptodev_driver_id_get(
675 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD))) {
676 nb_devs = rte_cryptodev_device_count_by_driver(
677 rte_cryptodev_driver_id_get(
678 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)));
681 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD),
684 TEST_ASSERT(ret == 0, "Failed to create "
685 "instance of pmd : %s",
686 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
690 /* Create an CCP device if required */
691 if (gbl_driver_id == rte_cryptodev_driver_id_get(
692 RTE_STR(CRYPTODEV_NAME_CCP_PMD))) {
693 nb_devs = rte_cryptodev_device_count_by_driver(
694 rte_cryptodev_driver_id_get(
695 RTE_STR(CRYPTODEV_NAME_CCP_PMD)));
698 RTE_STR(CRYPTODEV_NAME_CCP_PMD),
701 TEST_ASSERT(ret == 0, "Failed to create "
702 "instance of pmd : %s",
703 RTE_STR(CRYPTODEV_NAME_CCP_PMD));
707 #ifdef RTE_CRYPTO_SCHEDULER
708 char vdev_args[VDEV_ARGS_SIZE] = {""};
709 char temp_str[VDEV_ARGS_SIZE] = {"mode=multi-core,"
710 "ordering=enable,name=cryptodev_test_scheduler,corelist="};
711 uint16_t worker_core_count = 0;
712 uint16_t socket_id = 0;
714 if (gbl_driver_id == rte_cryptodev_driver_id_get(
715 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD))) {
717 /* Identify the Worker Cores
718 * Use 2 worker cores for the device args
720 RTE_LCORE_FOREACH_WORKER(i) {
721 if (worker_core_count > 1)
723 snprintf(vdev_args, sizeof(vdev_args),
724 "%s%d", temp_str, i);
725 strcpy(temp_str, vdev_args);
726 strlcat(temp_str, ";", sizeof(temp_str));
728 socket_id = rte_lcore_to_socket_id(i);
730 if (worker_core_count != 2) {
732 "Cryptodev scheduler test require at least "
733 "two worker cores to run. "
734 "Please use the correct coremask.\n");
737 strcpy(temp_str, vdev_args);
738 snprintf(vdev_args, sizeof(vdev_args), "%s,socket_id=%d",
739 temp_str, socket_id);
740 RTE_LOG(DEBUG, USER1, "vdev_args: %s\n", vdev_args);
741 nb_devs = rte_cryptodev_device_count_by_driver(
742 rte_cryptodev_driver_id_get(
743 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)));
746 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),
748 TEST_ASSERT(ret == 0,
749 "Failed to create instance %u of"
751 i, RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
754 #endif /* RTE_CRYPTO_SCHEDULER */
756 nb_devs = rte_cryptodev_count();
758 RTE_LOG(WARNING, USER1, "No crypto devices found?\n");
762 /* Create list of valid crypto devs */
763 for (i = 0; i < nb_devs; i++) {
764 rte_cryptodev_info_get(i, &info);
765 if (info.driver_id == gbl_driver_id)
766 ts_params->valid_devs[ts_params->valid_dev_count++] = i;
769 if (ts_params->valid_dev_count < 1)
772 /* Set up all the qps on the first of the valid devices found */
774 dev_id = ts_params->valid_devs[0];
776 rte_cryptodev_info_get(dev_id, &info);
778 ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
779 ts_params->conf.socket_id = SOCKET_ID_ANY;
780 ts_params->conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY;
782 unsigned int session_size =
783 rte_cryptodev_sym_get_private_session_size(dev_id);
785 #ifdef RTE_LIB_SECURITY
786 unsigned int security_session_size = rte_security_session_get_size(
787 rte_cryptodev_get_sec_ctx(dev_id));
789 if (session_size < security_session_size)
790 session_size = security_session_size;
793 * Create mempool with maximum number of sessions.
795 if (info.sym.max_nb_sessions != 0 &&
796 info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
797 RTE_LOG(ERR, USER1, "Device does not support "
798 "at least %u sessions\n",
803 ts_params->session_mpool = rte_cryptodev_sym_session_pool_create(
804 "test_sess_mp", MAX_NB_SESSIONS, 0, 0, 0,
806 TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
807 "session mempool allocation failed");
809 ts_params->session_priv_mpool = rte_mempool_create(
813 0, 0, NULL, NULL, NULL,
816 TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
817 "session mempool allocation failed");
821 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id,
823 "Failed to configure cryptodev %u with %u qps",
824 dev_id, ts_params->conf.nb_queue_pairs);
826 ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
827 ts_params->qp_conf.mp_session = ts_params->session_mpool;
828 ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
830 for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) {
831 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
832 dev_id, qp_id, &ts_params->qp_conf,
833 rte_cryptodev_socket_id(dev_id)),
834 "Failed to setup queue pair %u on cryptodev %u",
842 testsuite_teardown(void)
844 struct crypto_testsuite_params *ts_params = &testsuite_params;
846 if (ts_params->mbuf_pool != NULL) {
847 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
848 rte_mempool_avail_count(ts_params->mbuf_pool));
851 if (ts_params->op_mpool != NULL) {
852 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n",
853 rte_mempool_avail_count(ts_params->op_mpool));
856 /* Free session mempools */
857 if (ts_params->session_priv_mpool != NULL) {
858 rte_mempool_free(ts_params->session_priv_mpool);
859 ts_params->session_priv_mpool = NULL;
862 if (ts_params->session_mpool != NULL) {
863 rte_mempool_free(ts_params->session_mpool);
864 ts_params->session_mpool = NULL;
869 dev_configure_and_start(uint64_t ff_disable)
871 struct crypto_testsuite_params *ts_params = &testsuite_params;
872 struct crypto_unittest_params *ut_params = &unittest_params;
876 /* Clear unit test parameters before running test */
877 memset(ut_params, 0, sizeof(*ut_params));
879 /* Reconfigure device to default parameters */
880 ts_params->conf.socket_id = SOCKET_ID_ANY;
881 ts_params->conf.ff_disable = ff_disable;
882 ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
883 ts_params->qp_conf.mp_session = ts_params->session_mpool;
884 ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
886 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
888 "Failed to configure cryptodev %u",
889 ts_params->valid_devs[0]);
891 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
892 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
893 ts_params->valid_devs[0], qp_id,
895 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
896 "Failed to setup queue pair %u on cryptodev %u",
897 qp_id, ts_params->valid_devs[0]);
901 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
903 /* Start the device */
904 TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
905 "Failed to start cryptodev %u",
906 ts_params->valid_devs[0]);
914 /* Configure and start the device with security feature disabled */
915 return dev_configure_and_start(RTE_CRYPTODEV_FF_SECURITY);
919 ut_setup_security(void)
921 /* Configure and start the device with no features disabled */
922 return dev_configure_and_start(0);
928 struct crypto_testsuite_params *ts_params = &testsuite_params;
929 struct crypto_unittest_params *ut_params = &unittest_params;
930 struct rte_cryptodev_stats stats;
932 /* free crypto session structure */
933 #ifdef RTE_LIB_SECURITY
934 if (ut_params->type == RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL) {
935 if (ut_params->sec_session) {
936 rte_security_session_destroy(rte_cryptodev_get_sec_ctx
937 (ts_params->valid_devs[0]),
938 ut_params->sec_session);
939 ut_params->sec_session = NULL;
944 if (ut_params->sess) {
945 rte_cryptodev_sym_session_clear(
946 ts_params->valid_devs[0],
948 rte_cryptodev_sym_session_free(ut_params->sess);
949 ut_params->sess = NULL;
953 /* free crypto operation structure */
955 rte_crypto_op_free(ut_params->op);
958 * free mbuf - both obuf and ibuf are usually the same,
959 * so check if they point at the same address is necessary,
960 * to avoid freeing the mbuf twice.
962 if (ut_params->obuf) {
963 rte_pktmbuf_free(ut_params->obuf);
964 if (ut_params->ibuf == ut_params->obuf)
968 if (ut_params->ibuf) {
969 rte_pktmbuf_free(ut_params->ibuf);
973 if (ts_params->mbuf_pool != NULL)
974 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
975 rte_mempool_avail_count(ts_params->mbuf_pool));
977 rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats);
979 /* Stop the device */
980 rte_cryptodev_stop(ts_params->valid_devs[0]);
984 test_device_configure_invalid_dev_id(void)
986 struct crypto_testsuite_params *ts_params = &testsuite_params;
987 uint16_t dev_id, num_devs = 0;
989 TEST_ASSERT((num_devs = rte_cryptodev_count()) >= 1,
990 "Need at least %d devices for test", 1);
992 /* valid dev_id values */
993 dev_id = ts_params->valid_devs[0];
995 /* Stop the device in case it's started so it can be configured */
996 rte_cryptodev_stop(dev_id);
998 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf),
999 "Failed test for rte_cryptodev_configure: "
1000 "invalid dev_num %u", dev_id);
1002 /* invalid dev_id values */
1005 TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
1006 "Failed test for rte_cryptodev_configure: "
1007 "invalid dev_num %u", dev_id);
1011 TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
1012 "Failed test for rte_cryptodev_configure:"
1013 "invalid dev_num %u", dev_id);
1015 return TEST_SUCCESS;
1019 test_device_configure_invalid_queue_pair_ids(void)
1021 struct crypto_testsuite_params *ts_params = &testsuite_params;
1022 uint16_t orig_nb_qps = ts_params->conf.nb_queue_pairs;
1024 /* Stop the device in case it's started so it can be configured */
1025 rte_cryptodev_stop(ts_params->valid_devs[0]);
1027 /* valid - max value queue pairs */
1028 ts_params->conf.nb_queue_pairs = orig_nb_qps;
1030 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1032 "Failed to configure cryptodev: dev_id %u, qp_id %u",
1033 ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
1035 /* valid - one queue pairs */
1036 ts_params->conf.nb_queue_pairs = 1;
1038 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1040 "Failed to configure cryptodev: dev_id %u, qp_id %u",
1041 ts_params->valid_devs[0],
1042 ts_params->conf.nb_queue_pairs);
1045 /* invalid - zero queue pairs */
1046 ts_params->conf.nb_queue_pairs = 0;
1048 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1050 "Failed test for rte_cryptodev_configure, dev_id %u,"
1052 ts_params->valid_devs[0],
1053 ts_params->conf.nb_queue_pairs);
1056 /* invalid - max value supported by field queue pairs */
1057 ts_params->conf.nb_queue_pairs = UINT16_MAX;
1059 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1061 "Failed test for rte_cryptodev_configure, dev_id %u,"
1063 ts_params->valid_devs[0],
1064 ts_params->conf.nb_queue_pairs);
1067 /* invalid - max value + 1 queue pairs */
1068 ts_params->conf.nb_queue_pairs = orig_nb_qps + 1;
1070 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1072 "Failed test for rte_cryptodev_configure, dev_id %u,"
1074 ts_params->valid_devs[0],
1075 ts_params->conf.nb_queue_pairs);
1077 /* revert to original testsuite value */
1078 ts_params->conf.nb_queue_pairs = orig_nb_qps;
1080 return TEST_SUCCESS;
1084 test_queue_pair_descriptor_setup(void)
1086 struct crypto_testsuite_params *ts_params = &testsuite_params;
1087 struct rte_cryptodev_qp_conf qp_conf = {
1088 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
1092 /* Stop the device in case it's started so it can be configured */
1093 rte_cryptodev_stop(ts_params->valid_devs[0]);
1095 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1097 "Failed to configure cryptodev %u",
1098 ts_params->valid_devs[0]);
1101 * Test various ring sizes on this device. memzones can't be
1102 * freed so are re-used if ring is released and re-created.
1104 qp_conf.nb_descriptors = MIN_NUM_OPS_INFLIGHT; /* min size*/
1105 qp_conf.mp_session = ts_params->session_mpool;
1106 qp_conf.mp_session_private = ts_params->session_priv_mpool;
1108 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1109 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1110 ts_params->valid_devs[0], qp_id, &qp_conf,
1111 rte_cryptodev_socket_id(
1112 ts_params->valid_devs[0])),
1114 "rte_cryptodev_queue_pair_setup: num_inflights "
1115 "%u on qp %u on cryptodev %u",
1116 qp_conf.nb_descriptors, qp_id,
1117 ts_params->valid_devs[0]);
1120 qp_conf.nb_descriptors = (uint32_t)(MAX_NUM_OPS_INFLIGHT / 2);
1122 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1123 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1124 ts_params->valid_devs[0], qp_id, &qp_conf,
1125 rte_cryptodev_socket_id(
1126 ts_params->valid_devs[0])),
1128 " rte_cryptodev_queue_pair_setup: num_inflights"
1129 " %u on qp %u on cryptodev %u",
1130 qp_conf.nb_descriptors, qp_id,
1131 ts_params->valid_devs[0]);
1134 qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; /* valid */
1136 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1137 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1138 ts_params->valid_devs[0], qp_id, &qp_conf,
1139 rte_cryptodev_socket_id(
1140 ts_params->valid_devs[0])),
1142 "rte_cryptodev_queue_pair_setup: num_inflights"
1143 " %u on qp %u on cryptodev %u",
1144 qp_conf.nb_descriptors, qp_id,
1145 ts_params->valid_devs[0]);
1148 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
1150 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1151 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1152 ts_params->valid_devs[0], qp_id, &qp_conf,
1153 rte_cryptodev_socket_id(
1154 ts_params->valid_devs[0])),
1156 " rte_cryptodev_queue_pair_setup:"
1157 "num_inflights %u on qp %u on cryptodev %u",
1158 qp_conf.nb_descriptors, qp_id,
1159 ts_params->valid_devs[0]);
1162 /* test invalid queue pair id */
1163 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT; /*valid */
1165 qp_id = ts_params->conf.nb_queue_pairs; /*invalid */
1167 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
1168 ts_params->valid_devs[0],
1170 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1171 "Failed test for rte_cryptodev_queue_pair_setup:"
1172 "invalid qp %u on cryptodev %u",
1173 qp_id, ts_params->valid_devs[0]);
1175 qp_id = 0xffff; /*invalid*/
1177 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
1178 ts_params->valid_devs[0],
1180 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1181 "Failed test for rte_cryptodev_queue_pair_setup:"
1182 "invalid qp %u on cryptodev %u",
1183 qp_id, ts_params->valid_devs[0]);
1185 return TEST_SUCCESS;
1188 /* ***** Plaintext data for tests ***** */
1190 const char catch_22_quote_1[] =
1191 "There was only one catch and that was Catch-22, which "
1192 "specified that a concern for one's safety in the face of "
1193 "dangers that were real and immediate was the process of a "
1194 "rational mind. Orr was crazy and could be grounded. All he "
1195 "had to do was ask; and as soon as he did, he would no longer "
1196 "be crazy and would have to fly more missions. Orr would be "
1197 "crazy to fly more missions and sane if he didn't, but if he "
1198 "was sane he had to fly them. If he flew them he was crazy "
1199 "and didn't have to; but if he didn't want to he was sane and "
1200 "had to. Yossarian was moved very deeply by the absolute "
1201 "simplicity of this clause of Catch-22 and let out a "
1202 "respectful whistle. \"That's some catch, that Catch-22\", he "
1203 "observed. \"It's the best there is,\" Doc Daneeka agreed.";
1205 const char catch_22_quote[] =
1206 "What a lousy earth! He wondered how many people were "
1207 "destitute that same night even in his own prosperous country, "
1208 "how many homes were shanties, how many husbands were drunk "
1209 "and wives socked, and how many children were bullied, abused, "
1210 "or abandoned. How many families hungered for food they could "
1211 "not afford to buy? How many hearts were broken? How many "
1212 "suicides would take place that same night, how many people "
1213 "would go insane? How many cockroaches and landlords would "
1214 "triumph? How many winners were losers, successes failures, "
1215 "and rich men poor men? How many wise guys were stupid? How "
1216 "many happy endings were unhappy endings? How many honest men "
1217 "were liars, brave men cowards, loyal men traitors, how many "
1218 "sainted men were corrupt, how many people in positions of "
1219 "trust had sold their souls to bodyguards, how many had never "
1220 "had souls? How many straight-and-narrow paths were crooked "
1221 "paths? How many best families were worst families and how "
1222 "many good people were bad people? When you added them all up "
1223 "and then subtracted, you might be left with only the children, "
1224 "and perhaps with Albert Einstein and an old violinist or "
1225 "sculptor somewhere.";
1227 #define QUOTE_480_BYTES (480)
1228 #define QUOTE_512_BYTES (512)
1229 #define QUOTE_768_BYTES (768)
1230 #define QUOTE_1024_BYTES (1024)
1234 /* ***** SHA1 Hash Tests ***** */
1236 #define HMAC_KEY_LENGTH_SHA1 (DIGEST_BYTE_LENGTH_SHA1)
1238 static uint8_t hmac_sha1_key[] = {
1239 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
1240 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
1241 0xDE, 0xF4, 0xDE, 0xAD };
1243 /* ***** SHA224 Hash Tests ***** */
1245 #define HMAC_KEY_LENGTH_SHA224 (DIGEST_BYTE_LENGTH_SHA224)
1248 /* ***** AES-CBC Cipher Tests ***** */
1250 #define CIPHER_KEY_LENGTH_AES_CBC (16)
1251 #define CIPHER_IV_LENGTH_AES_CBC (CIPHER_KEY_LENGTH_AES_CBC)
1253 static uint8_t aes_cbc_key[] = {
1254 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
1255 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A };
1257 static uint8_t aes_cbc_iv[] = {
1258 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1259 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
1262 /* ***** AES-CBC / HMAC-SHA1 Hash Tests ***** */
1264 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_ciphertext[] = {
1265 0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31,
1266 0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76,
1267 0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E,
1268 0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A,
1269 0x3F, 0x6B, 0x5D, 0xDF, 0x52, 0x85, 0x5F, 0x8E,
1270 0x42, 0x3C, 0xFB, 0xE9, 0x1A, 0x24, 0xD6, 0x08,
1271 0xDD, 0xFD, 0x16, 0xFB, 0xE9, 0x55, 0xEF, 0xF0,
1272 0xA0, 0x8D, 0x13, 0xAB, 0x81, 0xC6, 0x90, 0x01,
1273 0xB5, 0x18, 0x84, 0xB3, 0xF6, 0xE6, 0x11, 0x57,
1274 0xD6, 0x71, 0xC6, 0x3C, 0x3F, 0x2F, 0x33, 0xEE,
1275 0x24, 0x42, 0x6E, 0xAC, 0x0B, 0xCA, 0xEC, 0xF9,
1276 0x84, 0xF8, 0x22, 0xAA, 0x60, 0xF0, 0x32, 0xA9,
1277 0x75, 0x75, 0x3B, 0xCB, 0x70, 0x21, 0x0A, 0x8D,
1278 0x0F, 0xE0, 0xC4, 0x78, 0x2B, 0xF8, 0x97, 0xE3,
1279 0xE4, 0x26, 0x4B, 0x29, 0xDA, 0x88, 0xCD, 0x46,
1280 0xEC, 0xAA, 0xF9, 0x7F, 0xF1, 0x15, 0xEA, 0xC3,
1281 0x87, 0xE6, 0x31, 0xF2, 0xCF, 0xDE, 0x4D, 0x80,
1282 0x70, 0x91, 0x7E, 0x0C, 0xF7, 0x26, 0x3A, 0x92,
1283 0x4F, 0x18, 0x83, 0xC0, 0x8F, 0x59, 0x01, 0xA5,
1284 0x88, 0xD1, 0xDB, 0x26, 0x71, 0x27, 0x16, 0xF5,
1285 0xEE, 0x10, 0x82, 0xAC, 0x68, 0x26, 0x9B, 0xE2,
1286 0x6D, 0xD8, 0x9A, 0x80, 0xDF, 0x04, 0x31, 0xD5,
1287 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1288 0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
1289 0x73, 0x02, 0x42, 0xC9, 0x23, 0x18, 0x8E, 0xB4,
1290 0x6F, 0xB4, 0xA3, 0x54, 0x6E, 0x88, 0x3B, 0x62,
1291 0x7C, 0x02, 0x8D, 0x4C, 0x9F, 0xC8, 0x45, 0xF4,
1292 0xC9, 0xDE, 0x4F, 0xEB, 0x22, 0x83, 0x1B, 0xE4,
1293 0x49, 0x37, 0xE4, 0xAD, 0xE7, 0xCD, 0x21, 0x54,
1294 0xBC, 0x1C, 0xC2, 0x04, 0x97, 0xB4, 0x10, 0x61,
1295 0xF0, 0xE4, 0xEF, 0x27, 0x63, 0x3A, 0xDA, 0x91,
1296 0x41, 0x25, 0x62, 0x1C, 0x5C, 0xB6, 0x38, 0x4A,
1297 0x88, 0x71, 0x59, 0x5A, 0x8D, 0xA0, 0x09, 0xAF,
1298 0x72, 0x94, 0xD7, 0x79, 0x5C, 0x60, 0x7C, 0x8F,
1299 0x4C, 0xF5, 0xD9, 0xA1, 0x39, 0x6D, 0x81, 0x28,
1300 0xEF, 0x13, 0x28, 0xDF, 0xF5, 0x3E, 0xF7, 0x8E,
1301 0x09, 0x9C, 0x78, 0x18, 0x79, 0xB8, 0x68, 0xD7,
1302 0xA8, 0x29, 0x62, 0xAD, 0xDE, 0xE1, 0x61, 0x76,
1303 0x1B, 0x05, 0x16, 0xCD, 0xBF, 0x02, 0x8E, 0xA6,
1304 0x43, 0x6E, 0x92, 0x55, 0x4F, 0x60, 0x9C, 0x03,
1305 0xB8, 0x4F, 0xA3, 0x02, 0xAC, 0xA8, 0xA7, 0x0C,
1306 0x1E, 0xB5, 0x6B, 0xF8, 0xC8, 0x4D, 0xDE, 0xD2,
1307 0xB0, 0x29, 0x6E, 0x40, 0xE6, 0xD6, 0xC9, 0xE6,
1308 0xB9, 0x0F, 0xB6, 0x63, 0xF5, 0xAA, 0x2B, 0x96,
1309 0xA7, 0x16, 0xAC, 0x4E, 0x0A, 0x33, 0x1C, 0xA6,
1310 0xE6, 0xBD, 0x8A, 0xCF, 0x40, 0xA9, 0xB2, 0xFA,
1311 0x63, 0x27, 0xFD, 0x9B, 0xD9, 0xFC, 0xD5, 0x87,
1312 0x8D, 0x4C, 0xB6, 0xA4, 0xCB, 0xE7, 0x74, 0x55,
1313 0xF4, 0xFB, 0x41, 0x25, 0xB5, 0x4B, 0x0A, 0x1B,
1314 0xB1, 0xD6, 0xB7, 0xD9, 0x47, 0x2A, 0xC3, 0x98,
1315 0x6A, 0xC4, 0x03, 0x73, 0x1F, 0x93, 0x6E, 0x53,
1316 0x19, 0x25, 0x64, 0x15, 0x83, 0xF9, 0x73, 0x2A,
1317 0x74, 0xB4, 0x93, 0x69, 0xC4, 0x72, 0xFC, 0x26,
1318 0xA2, 0x9F, 0x43, 0x45, 0xDD, 0xB9, 0xEF, 0x36,
1319 0xC8, 0x3A, 0xCD, 0x99, 0x9B, 0x54, 0x1A, 0x36,
1320 0xC1, 0x59, 0xF8, 0x98, 0xA8, 0xCC, 0x28, 0x0D,
1321 0x73, 0x4C, 0xEE, 0x98, 0xCB, 0x7C, 0x58, 0x7E,
1322 0x20, 0x75, 0x1E, 0xB7, 0xC9, 0xF8, 0xF2, 0x0E,
1323 0x63, 0x9E, 0x05, 0x78, 0x1A, 0xB6, 0xA8, 0x7A,
1324 0xF9, 0x98, 0x6A, 0xA6, 0x46, 0x84, 0x2E, 0xF6,
1325 0x4B, 0xDC, 0x9B, 0x8F, 0x9B, 0x8F, 0xEE, 0xB4,
1326 0xAA, 0x3F, 0xEE, 0xC0, 0x37, 0x27, 0x76, 0xC7,
1327 0x95, 0xBB, 0x26, 0x74, 0x69, 0x12, 0x7F, 0xF1,
1328 0xBB, 0xFF, 0xAE, 0xB5, 0x99, 0x6E, 0xCB, 0x0C
1331 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest[] = {
1332 0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60,
1333 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1334 0x18, 0x8c, 0x1d, 0x32
1338 /* Multisession Vector context Test */
1339 /*Begin Session 0 */
1340 static uint8_t ms_aes_cbc_key0[] = {
1341 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1342 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1345 static uint8_t ms_aes_cbc_iv0[] = {
1346 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1347 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1350 static const uint8_t ms_aes_cbc_cipher0[] = {
1351 0x3C, 0xE4, 0xEE, 0x42, 0xB6, 0x9B, 0xC3, 0x38,
1352 0x5F, 0xAD, 0x54, 0xDC, 0xA8, 0x32, 0x81, 0xDC,
1353 0x7A, 0x6F, 0x85, 0x58, 0x07, 0x35, 0xED, 0xEB,
1354 0xAD, 0x79, 0x79, 0x96, 0xD3, 0x0E, 0xA6, 0xD9,
1355 0xAA, 0x86, 0xA4, 0x8F, 0xB5, 0xD6, 0x6E, 0x6D,
1356 0x0C, 0x91, 0x2F, 0xC4, 0x67, 0x98, 0x0E, 0xC4,
1357 0x8D, 0x83, 0x68, 0x69, 0xC4, 0xD3, 0x94, 0x34,
1358 0xC4, 0x5D, 0x60, 0x55, 0x22, 0x87, 0x8F, 0x6F,
1359 0x17, 0x8E, 0x75, 0xE4, 0x02, 0xF5, 0x1B, 0x99,
1360 0xC8, 0x39, 0xA9, 0xAB, 0x23, 0x91, 0x12, 0xED,
1361 0x08, 0xE7, 0xD9, 0x25, 0x89, 0x24, 0x4F, 0x8D,
1362 0x68, 0xF3, 0x10, 0x39, 0x0A, 0xEE, 0x45, 0x24,
1363 0xDF, 0x7A, 0x9D, 0x00, 0x25, 0xE5, 0x35, 0x71,
1364 0x4E, 0x40, 0x59, 0x6F, 0x0A, 0x13, 0xB3, 0x72,
1365 0x1D, 0x98, 0x63, 0x94, 0x89, 0xA5, 0x39, 0x8E,
1366 0xD3, 0x9C, 0x8A, 0x7F, 0x71, 0x2F, 0xC7, 0xCD,
1367 0x81, 0x05, 0xDC, 0xC0, 0x8D, 0xCE, 0x6D, 0x18,
1368 0x30, 0xC4, 0x72, 0x51, 0xF0, 0x27, 0xC8, 0xF6,
1369 0x60, 0x5B, 0x7C, 0xB2, 0xE3, 0x49, 0x0C, 0x29,
1370 0xC6, 0x9F, 0x39, 0x57, 0x80, 0x55, 0x24, 0x2C,
1371 0x9B, 0x0F, 0x5A, 0xB3, 0x89, 0x55, 0x31, 0x96,
1372 0x0D, 0xCD, 0xF6, 0x51, 0x03, 0x2D, 0x89, 0x26,
1373 0x74, 0x44, 0xD6, 0xE8, 0xDC, 0xEA, 0x44, 0x55,
1374 0x64, 0x71, 0x9C, 0x9F, 0x5D, 0xBA, 0x39, 0x46,
1375 0xA8, 0x17, 0xA1, 0x9C, 0x52, 0x9D, 0xBC, 0x6B,
1376 0x4A, 0x98, 0xE6, 0xEA, 0x33, 0xEC, 0x58, 0xB4,
1377 0x43, 0xF0, 0x32, 0x45, 0xA4, 0xC1, 0x55, 0xB7,
1378 0x5D, 0xB5, 0x59, 0xB2, 0xE3, 0x96, 0xFF, 0xA5,
1379 0xAF, 0xE1, 0x86, 0x1B, 0x42, 0xE6, 0x3B, 0xA0,
1380 0x90, 0x4A, 0xE8, 0x8C, 0x21, 0x7F, 0x36, 0x1E,
1381 0x5B, 0x65, 0x25, 0xD1, 0xC1, 0x5A, 0xCA, 0x3D,
1382 0x10, 0xED, 0x2D, 0x79, 0xD0, 0x0F, 0x58, 0x44,
1383 0x69, 0x81, 0xF5, 0xD4, 0xC9, 0x0F, 0x90, 0x76,
1384 0x1F, 0x54, 0xD2, 0xD5, 0x97, 0xCE, 0x2C, 0xE3,
1385 0xEF, 0xF4, 0xB7, 0xC6, 0x3A, 0x87, 0x7F, 0x83,
1386 0x2A, 0xAF, 0xCD, 0x90, 0x12, 0xA7, 0x7D, 0x85,
1387 0x1D, 0x62, 0xD3, 0x85, 0x25, 0x05, 0xDB, 0x45,
1388 0x92, 0xA3, 0xF6, 0xA2, 0xA8, 0x41, 0xE4, 0x25,
1389 0x86, 0x87, 0x67, 0x24, 0xEC, 0x89, 0x23, 0x2A,
1390 0x9B, 0x20, 0x4D, 0x93, 0xEE, 0xE2, 0x2E, 0xC1,
1391 0x0B, 0x15, 0x33, 0xCF, 0x00, 0xD1, 0x1A, 0xDA,
1392 0x93, 0xFD, 0x28, 0x21, 0x5B, 0xCF, 0xD1, 0xF3,
1393 0x5A, 0x81, 0xBA, 0x82, 0x5E, 0x2F, 0x61, 0xB4,
1394 0x05, 0x71, 0xB5, 0xF4, 0x39, 0x3C, 0x1F, 0x60,
1395 0x00, 0x7A, 0xC4, 0xF8, 0x35, 0x20, 0x6C, 0x3A,
1396 0xCC, 0x03, 0x8F, 0x7B, 0xA2, 0xB6, 0x65, 0x8A,
1397 0xB6, 0x5F, 0xFD, 0x25, 0xD3, 0x5F, 0x92, 0xF9,
1398 0xAE, 0x17, 0x9B, 0x5E, 0x6E, 0x9A, 0xE4, 0x55,
1399 0x10, 0x25, 0x07, 0xA4, 0xAF, 0x21, 0x69, 0x13,
1400 0xD8, 0xFA, 0x31, 0xED, 0xF7, 0xA7, 0xA7, 0x3B,
1401 0xB8, 0x96, 0x8E, 0x10, 0x86, 0x74, 0xD8, 0xB1,
1402 0x34, 0x9E, 0x9B, 0x6A, 0x26, 0xA8, 0xD4, 0xD0,
1403 0xB5, 0xF6, 0xDE, 0xE7, 0xCA, 0x06, 0xDC, 0xA3,
1404 0x6F, 0xEE, 0x6B, 0x1E, 0xB5, 0x30, 0x99, 0x23,
1405 0xF9, 0x76, 0xF0, 0xA0, 0xCF, 0x3B, 0x94, 0x7B,
1406 0x19, 0x8D, 0xA5, 0x0C, 0x18, 0xA6, 0x1D, 0x07,
1407 0x89, 0xBE, 0x5B, 0x61, 0xE5, 0xF1, 0x42, 0xDB,
1408 0xD4, 0x2E, 0x02, 0x1F, 0xCE, 0xEF, 0x92, 0xB1,
1409 0x1B, 0x56, 0x50, 0xF2, 0x16, 0xE5, 0xE7, 0x4F,
1410 0xFD, 0xBB, 0x3E, 0xD2, 0xFC, 0x3C, 0xC6, 0x0F,
1411 0xF9, 0x12, 0x4E, 0xCB, 0x1E, 0x0C, 0x15, 0x84,
1412 0x2A, 0x14, 0x8A, 0x02, 0xE4, 0x7E, 0x95, 0x5B,
1413 0x86, 0xDB, 0x9B, 0x62, 0x5B, 0x19, 0xD2, 0x17,
1414 0xFA, 0x13, 0xBB, 0x6B, 0x3F, 0x45, 0x9F, 0xBF
1418 static uint8_t ms_hmac_key0[] = {
1419 0xFF, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1420 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1421 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1422 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1423 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1424 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1425 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1426 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1429 static const uint8_t ms_hmac_digest0[] = {
1430 0x43, 0x52, 0xED, 0x34, 0xAB, 0x36, 0xB2, 0x51,
1431 0xFB, 0xA3, 0xA6, 0x7C, 0x38, 0xFC, 0x42, 0x8F,
1432 0x57, 0x64, 0xAB, 0x81, 0xA7, 0x89, 0xB7, 0x6C,
1433 0xA0, 0xDC, 0xB9, 0x4D, 0xC4, 0x30, 0xF9, 0xD4,
1434 0x10, 0x82, 0x55, 0xD0, 0xAB, 0x32, 0xFB, 0x56,
1435 0x0D, 0xE4, 0x68, 0x3D, 0x76, 0xD0, 0x7B, 0xE4,
1436 0xA6, 0x2C, 0x34, 0x9E, 0x8C, 0x41, 0xF8, 0x23,
1437 0x28, 0x1B, 0x3A, 0x90, 0x26, 0x34, 0x47, 0x90
1441 /* Begin session 1 */
1443 static uint8_t ms_aes_cbc_key1[] = {
1444 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1445 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1448 static uint8_t ms_aes_cbc_iv1[] = {
1449 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1450 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1453 static const uint8_t ms_aes_cbc_cipher1[] = {
1454 0x5A, 0x7A, 0x67, 0x5D, 0xB8, 0xE1, 0xDC, 0x71,
1455 0x39, 0xA8, 0x74, 0x93, 0x9C, 0x4C, 0xFE, 0x23,
1456 0x61, 0xCD, 0xA4, 0xB3, 0xD9, 0xCE, 0x99, 0x09,
1457 0x2A, 0x23, 0xF3, 0x29, 0xBF, 0x4C, 0xB4, 0x6A,
1458 0x1B, 0x6B, 0x73, 0x4D, 0x48, 0x0C, 0xCF, 0x6C,
1459 0x5E, 0x34, 0x9E, 0x7F, 0xBC, 0x8F, 0xCC, 0x8F,
1460 0x75, 0x1D, 0x3D, 0x77, 0x10, 0x76, 0xC8, 0xB9,
1461 0x99, 0x6F, 0xD6, 0x56, 0x75, 0xA9, 0xB2, 0x66,
1462 0xC2, 0x24, 0x2B, 0x9C, 0xFE, 0x40, 0x8E, 0x43,
1463 0x20, 0x97, 0x1B, 0xFA, 0xD0, 0xCF, 0x04, 0xAB,
1464 0xBB, 0xF6, 0x5D, 0xF5, 0xA0, 0x19, 0x7C, 0x23,
1465 0x5D, 0x80, 0x8C, 0x49, 0xF6, 0x76, 0x88, 0x29,
1466 0x27, 0x4C, 0x59, 0x2B, 0x43, 0xA6, 0xB2, 0x26,
1467 0x27, 0x78, 0xBE, 0x1B, 0xE1, 0x4F, 0x5A, 0x1F,
1468 0xFC, 0x68, 0x08, 0xE7, 0xC4, 0xD1, 0x34, 0x68,
1469 0xB7, 0x13, 0x14, 0x41, 0x62, 0x6B, 0x1F, 0x77,
1470 0x0C, 0x68, 0x1D, 0x0D, 0xED, 0x89, 0xAA, 0xD8,
1471 0x97, 0x02, 0xBA, 0x5E, 0xD4, 0x84, 0x25, 0x97,
1472 0x03, 0xA5, 0xA6, 0x13, 0x66, 0x02, 0xF4, 0xC3,
1473 0xF3, 0xD3, 0xCC, 0x95, 0xC3, 0x87, 0x46, 0x90,
1474 0x1F, 0x6E, 0x14, 0xA8, 0x00, 0xF2, 0x6F, 0xD5,
1475 0xA1, 0xAD, 0xD5, 0x40, 0xA2, 0x0F, 0x32, 0x7E,
1476 0x99, 0xA3, 0xF5, 0x53, 0xC3, 0x26, 0xA1, 0x45,
1477 0x01, 0x88, 0x57, 0x84, 0x3E, 0x7B, 0x4E, 0x0B,
1478 0x3C, 0xB5, 0x3E, 0x9E, 0xE9, 0x78, 0x77, 0xC5,
1479 0xC0, 0x89, 0xA8, 0xF8, 0xF1, 0xA5, 0x2D, 0x5D,
1480 0xF9, 0xC6, 0xFB, 0xCB, 0x05, 0x23, 0xBD, 0x6E,
1481 0x5E, 0x14, 0xC6, 0x57, 0x73, 0xCF, 0x98, 0xBD,
1482 0x10, 0x8B, 0x18, 0xA6, 0x01, 0x5B, 0x13, 0xAE,
1483 0x8E, 0xDE, 0x1F, 0xB5, 0xB7, 0x40, 0x6C, 0xC1,
1484 0x1E, 0xA1, 0x19, 0x20, 0x9E, 0x95, 0xE0, 0x2F,
1485 0x1C, 0xF5, 0xD9, 0xD0, 0x2B, 0x1E, 0x82, 0x25,
1486 0x62, 0xB4, 0xEB, 0xA1, 0x1F, 0xCE, 0x44, 0xA1,
1487 0xCB, 0x92, 0x01, 0x6B, 0xE4, 0x26, 0x23, 0xE3,
1488 0xC5, 0x67, 0x35, 0x55, 0xDA, 0xE5, 0x27, 0xEE,
1489 0x8D, 0x12, 0x84, 0xB7, 0xBA, 0xA7, 0x1C, 0xD6,
1490 0x32, 0x3F, 0x67, 0xED, 0xFB, 0x5B, 0x8B, 0x52,
1491 0x46, 0x8C, 0xF9, 0x69, 0xCD, 0xAE, 0x79, 0xAA,
1492 0x37, 0x78, 0x49, 0xEB, 0xC6, 0x8E, 0x76, 0x63,
1493 0x84, 0xFF, 0x9D, 0x22, 0x99, 0x51, 0xB7, 0x5E,
1494 0x83, 0x4C, 0x8B, 0xDF, 0x5A, 0x07, 0xCC, 0xBA,
1495 0x42, 0xA5, 0x98, 0xB6, 0x47, 0x0E, 0x66, 0xEB,
1496 0x23, 0x0E, 0xBA, 0x44, 0xA8, 0xAA, 0x20, 0x71,
1497 0x79, 0x9C, 0x77, 0x5F, 0xF5, 0xFE, 0xEC, 0xEF,
1498 0xC6, 0x64, 0x3D, 0x84, 0xD0, 0x2B, 0xA7, 0x0A,
1499 0xC3, 0x72, 0x5B, 0x9C, 0xFA, 0xA8, 0x87, 0x95,
1500 0x94, 0x11, 0x38, 0xA7, 0x1E, 0x58, 0xE3, 0x73,
1501 0xC6, 0xC9, 0xD1, 0x7B, 0x92, 0xDB, 0x0F, 0x49,
1502 0x74, 0xC2, 0xA2, 0x0E, 0x35, 0x57, 0xAC, 0xDB,
1503 0x9A, 0x1C, 0xCF, 0x5A, 0x32, 0x3E, 0x26, 0x9B,
1504 0xEC, 0xB3, 0xEF, 0x9C, 0xFE, 0xBE, 0x52, 0xAC,
1505 0xB1, 0x29, 0xDD, 0xFD, 0x07, 0xE2, 0xEE, 0xED,
1506 0xE4, 0x46, 0x37, 0xFE, 0xD1, 0xDC, 0xCD, 0x02,
1507 0xF9, 0x31, 0xB0, 0xFB, 0x36, 0xB7, 0x34, 0xA4,
1508 0x76, 0xE8, 0x57, 0xBF, 0x99, 0x92, 0xC7, 0xAF,
1509 0x98, 0x10, 0xE2, 0x70, 0xCA, 0xC9, 0x2B, 0x82,
1510 0x06, 0x96, 0x88, 0x0D, 0xB3, 0xAC, 0x9E, 0x6D,
1511 0x43, 0xBC, 0x5B, 0x31, 0xCF, 0x65, 0x8D, 0xA6,
1512 0xC7, 0xFE, 0x73, 0xE1, 0x54, 0xF7, 0x10, 0xF9,
1513 0x86, 0xF7, 0xDF, 0xA1, 0xA1, 0xD8, 0xAE, 0x35,
1514 0xB3, 0x90, 0xDC, 0x6F, 0x43, 0x7A, 0x8B, 0xE0,
1515 0xFE, 0x8F, 0x33, 0x4D, 0x29, 0x6C, 0x45, 0x53,
1516 0x73, 0xDD, 0x21, 0x0B, 0x85, 0x30, 0xB5, 0xA5,
1517 0xF3, 0x5D, 0xEC, 0x79, 0x61, 0x9D, 0x9E, 0xB3
1521 static uint8_t ms_hmac_key1[] = {
1522 0xFE, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1523 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1524 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1525 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1526 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1527 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1528 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1529 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1532 static const uint8_t ms_hmac_digest1[] = {
1533 0xCE, 0x6E, 0x5F, 0x77, 0x96, 0x9A, 0xB1, 0x69,
1534 0x2D, 0x5E, 0xF3, 0x2F, 0x32, 0x10, 0xCB, 0x50,
1535 0x0E, 0x09, 0x56, 0x25, 0x07, 0x34, 0xC9, 0x20,
1536 0xEC, 0x13, 0x43, 0x23, 0x5C, 0x08, 0x8B, 0xCD,
1537 0xDC, 0x86, 0x8C, 0xEE, 0x0A, 0x95, 0x2E, 0xB9,
1538 0x8C, 0x7B, 0x02, 0x7A, 0xD4, 0xE1, 0x49, 0xB4,
1539 0x45, 0xB5, 0x52, 0x37, 0xC6, 0xFF, 0xFE, 0xAA,
1540 0x0A, 0x87, 0xB8, 0x51, 0xF9, 0x2A, 0x01, 0x8F
1543 /* Begin Session 2 */
1544 static uint8_t ms_aes_cbc_key2[] = {
1545 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1546 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1549 static uint8_t ms_aes_cbc_iv2[] = {
1550 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1551 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1554 static const uint8_t ms_aes_cbc_cipher2[] = {
1555 0xBB, 0x3C, 0x68, 0x25, 0xFD, 0xB6, 0xA2, 0x91,
1556 0x20, 0x56, 0xF6, 0x30, 0x35, 0xFC, 0x9E, 0x97,
1557 0xF2, 0x90, 0xFC, 0x7E, 0x3E, 0x0A, 0x75, 0xC8,
1558 0x4C, 0xF2, 0x2D, 0xAC, 0xD3, 0x93, 0xF0, 0xC5,
1559 0x14, 0x88, 0x8A, 0x23, 0xC2, 0x59, 0x9A, 0x98,
1560 0x4B, 0xD5, 0x2C, 0xDA, 0x43, 0xA9, 0x34, 0x69,
1561 0x7C, 0x6D, 0xDB, 0xDC, 0xCB, 0xC0, 0xA0, 0x09,
1562 0xA7, 0x86, 0x16, 0x4B, 0xBF, 0xA8, 0xB6, 0xCF,
1563 0x7F, 0x74, 0x1F, 0x22, 0xF0, 0xF6, 0xBB, 0x44,
1564 0x8B, 0x4C, 0x9E, 0x23, 0xF8, 0x9F, 0xFC, 0x5B,
1565 0x9E, 0x9C, 0x2A, 0x79, 0x30, 0x8F, 0xBF, 0xA9,
1566 0x68, 0xA1, 0x20, 0x71, 0x7C, 0x77, 0x22, 0x34,
1567 0x07, 0xCD, 0xC6, 0xF6, 0x50, 0x0A, 0x08, 0x99,
1568 0x17, 0x98, 0xE3, 0x93, 0x8A, 0xB0, 0xEE, 0xDF,
1569 0xC2, 0xBA, 0x3B, 0x44, 0x73, 0xDF, 0xDD, 0xDC,
1570 0x14, 0x4D, 0x3B, 0xBB, 0x5E, 0x58, 0xC1, 0x26,
1571 0xA7, 0xAE, 0x47, 0xF3, 0x24, 0x6D, 0x4F, 0xD3,
1572 0x6E, 0x3E, 0x33, 0xE6, 0x7F, 0xCA, 0x50, 0xAF,
1573 0x5D, 0x3D, 0xA0, 0xDD, 0xC9, 0xF3, 0x30, 0xD3,
1574 0x6E, 0x8B, 0x2E, 0x12, 0x24, 0x34, 0xF0, 0xD3,
1575 0xC7, 0x8D, 0x23, 0x29, 0xAA, 0x05, 0xE1, 0xFA,
1576 0x2E, 0xF6, 0x8D, 0x37, 0x86, 0xC0, 0x6D, 0x13,
1577 0x2D, 0x98, 0xF3, 0x52, 0x39, 0x22, 0xCE, 0x38,
1578 0xC2, 0x1A, 0x72, 0xED, 0xFB, 0xCC, 0xE4, 0x71,
1579 0x5A, 0x0C, 0x0D, 0x09, 0xF8, 0xE8, 0x1B, 0xBC,
1580 0x53, 0xC8, 0xD8, 0x8F, 0xE5, 0x98, 0x5A, 0xB1,
1581 0x06, 0xA6, 0x5B, 0xE6, 0xA2, 0x88, 0x21, 0x9E,
1582 0x36, 0xC0, 0x34, 0xF9, 0xFB, 0x3B, 0x0A, 0x22,
1583 0x00, 0x00, 0x39, 0x48, 0x8D, 0x23, 0x74, 0x62,
1584 0x72, 0x91, 0xE6, 0x36, 0xAA, 0x77, 0x9C, 0x72,
1585 0x9D, 0xA8, 0xC3, 0xA9, 0xD5, 0x44, 0x72, 0xA6,
1586 0xB9, 0x28, 0x8F, 0x64, 0x4C, 0x8A, 0x64, 0xE6,
1587 0x4E, 0xFA, 0xEF, 0x87, 0xDE, 0x7B, 0x22, 0x44,
1588 0xB0, 0xDF, 0x2E, 0x5F, 0x0B, 0xA5, 0xF2, 0x24,
1589 0x07, 0x5C, 0x2D, 0x39, 0xB7, 0x3D, 0x8A, 0xE5,
1590 0x0E, 0x9D, 0x4E, 0x50, 0xED, 0x03, 0x99, 0x8E,
1591 0xF0, 0x06, 0x55, 0x4E, 0xA2, 0x24, 0xE7, 0x17,
1592 0x46, 0xDF, 0x6C, 0xCD, 0xC6, 0x44, 0xE8, 0xF9,
1593 0xB9, 0x1B, 0x36, 0xF6, 0x7F, 0x10, 0xA4, 0x7D,
1594 0x90, 0xBD, 0xE4, 0xAA, 0xD6, 0x9E, 0x18, 0x9D,
1595 0x22, 0x35, 0xD6, 0x55, 0x54, 0xAA, 0xF7, 0x22,
1596 0xA3, 0x3E, 0xEF, 0xC8, 0xA2, 0x34, 0x8D, 0xA9,
1597 0x37, 0x63, 0xA6, 0xC3, 0x57, 0xCB, 0x0C, 0x49,
1598 0x7D, 0x02, 0xBE, 0xAA, 0x13, 0x75, 0xB7, 0x4E,
1599 0x52, 0x62, 0xA5, 0xC2, 0x33, 0xC7, 0x6C, 0x1B,
1600 0xF6, 0x34, 0xF6, 0x09, 0xA5, 0x0C, 0xC7, 0xA2,
1601 0x61, 0x48, 0x62, 0x7D, 0x17, 0x15, 0xE3, 0x95,
1602 0xC8, 0x63, 0xD2, 0xA4, 0x43, 0xA9, 0x49, 0x07,
1603 0xB2, 0x3B, 0x2B, 0x62, 0x7D, 0xCB, 0x51, 0xB3,
1604 0x25, 0x33, 0x47, 0x0E, 0x14, 0x67, 0xDC, 0x6A,
1605 0x9B, 0x51, 0xAC, 0x9D, 0x8F, 0xA2, 0x2B, 0x57,
1606 0x8C, 0x5C, 0x5F, 0x76, 0x23, 0x92, 0x0F, 0x84,
1607 0x46, 0x0E, 0x40, 0x85, 0x38, 0x60, 0xFA, 0x61,
1608 0x20, 0xC5, 0xE3, 0xF1, 0x70, 0xAC, 0x1B, 0xBF,
1609 0xC4, 0x2B, 0xC5, 0x67, 0xD1, 0x43, 0xC5, 0x17,
1610 0x74, 0x71, 0x69, 0x6F, 0x82, 0x89, 0x19, 0x8A,
1611 0x70, 0x43, 0x92, 0x01, 0xC4, 0x63, 0x7E, 0xB1,
1612 0x59, 0x4E, 0xCD, 0xEA, 0x93, 0xA4, 0x52, 0x53,
1613 0x9B, 0x61, 0x5B, 0xD2, 0x3E, 0x19, 0x39, 0xB7,
1614 0x32, 0xEA, 0x8E, 0xF8, 0x1D, 0x76, 0x5C, 0xB2,
1615 0x73, 0x2D, 0x91, 0xC0, 0x18, 0xED, 0x25, 0x2A,
1616 0x53, 0x64, 0xF0, 0x92, 0x31, 0x55, 0x21, 0xA8,
1617 0x24, 0xA9, 0xD1, 0x02, 0xF6, 0x6C, 0x2B, 0x70,
1618 0xA9, 0x59, 0xC1, 0xD6, 0xC3, 0x57, 0x5B, 0x92
1621 static uint8_t ms_hmac_key2[] = {
1622 0xFC, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1623 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1624 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1625 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1626 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1627 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1628 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1629 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1632 static const uint8_t ms_hmac_digest2[] = {
1633 0xA5, 0x0F, 0x9C, 0xFB, 0x08, 0x62, 0x59, 0xFF,
1634 0x80, 0x2F, 0xEB, 0x4B, 0xE1, 0x46, 0x21, 0xD6,
1635 0x02, 0x98, 0xF2, 0x8E, 0xF4, 0xEC, 0xD4, 0x77,
1636 0x86, 0x4C, 0x31, 0x28, 0xC8, 0x25, 0x80, 0x27,
1637 0x3A, 0x72, 0x5D, 0x6A, 0x56, 0x8A, 0xD3, 0x82,
1638 0xB0, 0xEC, 0x31, 0x6D, 0x8B, 0x6B, 0xB4, 0x24,
1639 0xE7, 0x62, 0xC1, 0x52, 0xBC, 0x14, 0x1B, 0x8E,
1640 0xEC, 0x9A, 0xF1, 0x47, 0x80, 0xD2, 0xB0, 0x59
1647 test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
1649 struct crypto_testsuite_params *ts_params = &testsuite_params;
1650 struct crypto_unittest_params *ut_params = &unittest_params;
1652 /* Verify the capabilities */
1653 struct rte_cryptodev_sym_capability_idx cap_idx;
1654 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1655 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
1656 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
1659 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1660 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
1661 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
1665 /* Generate test mbuf data and space for digest */
1666 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1667 catch_22_quote, QUOTE_512_BYTES, 0);
1669 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1670 DIGEST_BYTE_LENGTH_SHA1);
1671 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1673 /* Setup Cipher Parameters */
1674 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1675 ut_params->cipher_xform.next = &ut_params->auth_xform;
1677 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1678 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
1679 ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
1680 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1681 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
1682 ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1684 /* Setup HMAC Parameters */
1685 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1687 ut_params->auth_xform.next = NULL;
1689 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
1690 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
1691 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1;
1692 ut_params->auth_xform.auth.key.data = hmac_sha1_key;
1693 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
1695 ut_params->sess = rte_cryptodev_sym_session_create(
1696 ts_params->session_mpool);
1698 /* Create crypto session*/
1699 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
1700 ut_params->sess, &ut_params->cipher_xform,
1701 ts_params->session_priv_mpool);
1702 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1704 /* Generate crypto op data structure */
1705 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1706 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1707 TEST_ASSERT_NOT_NULL(ut_params->op,
1708 "Failed to allocate symmetric crypto operation struct");
1710 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1712 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1714 /* set crypto operation source mbuf */
1715 sym_op->m_src = ut_params->ibuf;
1717 /* Set crypto operation authentication parameters */
1718 sym_op->auth.digest.data = ut_params->digest;
1719 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
1720 ut_params->ibuf, QUOTE_512_BYTES);
1722 sym_op->auth.data.offset = 0;
1723 sym_op->auth.data.length = QUOTE_512_BYTES;
1725 /* Copy IV at the end of the crypto operation */
1726 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
1727 aes_cbc_iv, CIPHER_IV_LENGTH_AES_CBC);
1729 /* Set crypto operation cipher parameters */
1730 sym_op->cipher.data.offset = 0;
1731 sym_op->cipher.data.length = QUOTE_512_BYTES;
1733 /* Process crypto operation */
1734 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
1735 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
1738 TEST_ASSERT_NOT_NULL(
1739 process_crypto_request(ts_params->valid_devs[0],
1741 "failed to process sym crypto op");
1743 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1744 "crypto op processing failed");
1747 uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
1750 TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext,
1751 catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1753 "ciphertext data not as expected");
1755 uint8_t *digest = ciphertext + QUOTE_512_BYTES;
1757 TEST_ASSERT_BUFFERS_ARE_EQUAL(digest,
1758 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
1759 gbl_driver_id == rte_cryptodev_driver_id_get(
1760 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) ?
1761 TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
1762 DIGEST_BYTE_LENGTH_SHA1,
1763 "Generated digest data not as expected");
1765 return TEST_SUCCESS;
1768 /* ***** AES-CBC / HMAC-SHA512 Hash Tests ***** */
1770 #define HMAC_KEY_LENGTH_SHA512 (DIGEST_BYTE_LENGTH_SHA512)
1772 static uint8_t hmac_sha512_key[] = {
1773 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1774 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1775 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1776 0x9a, 0xaf, 0x88, 0x1b, 0xb6, 0x8f, 0xf8, 0x60,
1777 0xa2, 0x5a, 0x7f, 0x3f, 0xf4, 0x72, 0x70, 0xf1,
1778 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1779 0x47, 0x3a, 0x75, 0x61, 0x5C, 0xa2, 0x10, 0x76,
1780 0x9a, 0xaf, 0x77, 0x5b, 0xb6, 0x7f, 0xf7, 0x60 };
1782 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest[] = {
1783 0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8,
1784 0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48,
1785 0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8,
1786 0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70,
1787 0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8,
1788 0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E,
1789 0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D,
1790 0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A };
1795 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1796 struct crypto_unittest_params *ut_params,
1797 uint8_t *cipher_key,
1801 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
1802 struct crypto_unittest_params *ut_params,
1803 struct crypto_testsuite_params *ts_params,
1804 const uint8_t *cipher,
1805 const uint8_t *digest,
1810 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1811 struct crypto_unittest_params *ut_params,
1812 uint8_t *cipher_key,
1816 /* Setup Cipher Parameters */
1817 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1818 ut_params->cipher_xform.next = NULL;
1820 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1821 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
1822 ut_params->cipher_xform.cipher.key.data = cipher_key;
1823 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1824 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
1825 ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1827 /* Setup HMAC Parameters */
1828 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1829 ut_params->auth_xform.next = &ut_params->cipher_xform;
1831 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
1832 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC;
1833 ut_params->auth_xform.auth.key.data = hmac_key;
1834 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512;
1835 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512;
1837 return TEST_SUCCESS;
1842 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
1843 struct crypto_unittest_params *ut_params,
1844 struct crypto_testsuite_params *ts_params,
1845 const uint8_t *cipher,
1846 const uint8_t *digest,
1849 /* Generate test mbuf data and digest */
1850 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1853 QUOTE_512_BYTES, 0);
1855 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1856 DIGEST_BYTE_LENGTH_SHA512);
1857 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1859 rte_memcpy(ut_params->digest,
1861 DIGEST_BYTE_LENGTH_SHA512);
1863 /* Generate Crypto op data structure */
1864 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1865 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1866 TEST_ASSERT_NOT_NULL(ut_params->op,
1867 "Failed to allocate symmetric crypto operation struct");
1869 rte_crypto_op_attach_sym_session(ut_params->op, sess);
1871 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1873 /* set crypto operation source mbuf */
1874 sym_op->m_src = ut_params->ibuf;
1876 sym_op->auth.digest.data = ut_params->digest;
1877 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
1878 ut_params->ibuf, QUOTE_512_BYTES);
1880 sym_op->auth.data.offset = 0;
1881 sym_op->auth.data.length = QUOTE_512_BYTES;
1883 /* Copy IV at the end of the crypto operation */
1884 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
1885 iv, CIPHER_IV_LENGTH_AES_CBC);
1887 sym_op->cipher.data.offset = 0;
1888 sym_op->cipher.data.length = QUOTE_512_BYTES;
1890 /* Process crypto operation */
1891 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
1892 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
1894 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
1895 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
1896 ut_params->op, 1, 1, 0, 0);
1898 TEST_ASSERT_NOT_NULL(
1899 process_crypto_request(ts_params->valid_devs[0],
1901 "failed to process sym crypto op");
1903 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1904 "crypto op processing failed");
1906 ut_params->obuf = ut_params->op->sym->m_src;
1909 TEST_ASSERT_BUFFERS_ARE_EQUAL(
1910 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *),
1913 "Plaintext data not as expected");
1916 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1917 "Digest verification failed");
1919 return TEST_SUCCESS;
1923 test_blockcipher(enum blockcipher_test_type test_type)
1925 struct crypto_testsuite_params *ts_params = &testsuite_params;
1928 status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1929 ts_params->op_mpool,
1930 ts_params->session_mpool, ts_params->session_priv_mpool,
1931 ts_params->valid_devs[0],
1934 if (status == -ENOTSUP)
1937 TEST_ASSERT_EQUAL(status, 0, "Test failed");
1939 return TEST_SUCCESS;
1943 test_AES_cipheronly_all(void)
1945 return test_blockcipher(BLKCIPHER_AES_CIPHERONLY_TYPE);
1949 test_AES_docsis_all(void)
1951 /* Data-path service does not support DOCSIS yet */
1952 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
1954 return test_blockcipher(BLKCIPHER_AES_DOCSIS_TYPE);
1958 test_DES_docsis_all(void)
1960 /* Data-path service does not support DOCSIS yet */
1961 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
1963 return test_blockcipher(BLKCIPHER_DES_DOCSIS_TYPE);
1967 test_DES_cipheronly_all(void)
1969 return test_blockcipher(BLKCIPHER_DES_CIPHERONLY_TYPE);
1973 test_authonly_all(void)
1975 return test_blockcipher(BLKCIPHER_AUTHONLY_TYPE);
1979 test_AES_chain_all(void)
1981 return test_blockcipher(BLKCIPHER_AES_CHAIN_TYPE);
1985 test_3DES_chain_all(void)
1987 return test_blockcipher(BLKCIPHER_3DES_CHAIN_TYPE);
1991 test_3DES_cipheronly_all(void)
1993 return test_blockcipher(BLKCIPHER_3DES_CIPHERONLY_TYPE);
1996 /* ***** SNOW 3G Tests ***** */
1998 create_wireless_algo_hash_session(uint8_t dev_id,
1999 const uint8_t *key, const uint8_t key_len,
2000 const uint8_t iv_len, const uint8_t auth_len,
2001 enum rte_crypto_auth_operation op,
2002 enum rte_crypto_auth_algorithm algo)
2004 uint8_t hash_key[key_len];
2007 struct crypto_testsuite_params *ts_params = &testsuite_params;
2008 struct crypto_unittest_params *ut_params = &unittest_params;
2010 memcpy(hash_key, key, key_len);
2012 debug_hexdump(stdout, "key:", key, key_len);
2014 /* Setup Authentication Parameters */
2015 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2016 ut_params->auth_xform.next = NULL;
2018 ut_params->auth_xform.auth.op = op;
2019 ut_params->auth_xform.auth.algo = algo;
2020 ut_params->auth_xform.auth.key.length = key_len;
2021 ut_params->auth_xform.auth.key.data = hash_key;
2022 ut_params->auth_xform.auth.digest_length = auth_len;
2023 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
2024 ut_params->auth_xform.auth.iv.length = iv_len;
2025 ut_params->sess = rte_cryptodev_sym_session_create(
2026 ts_params->session_mpool);
2028 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2029 &ut_params->auth_xform,
2030 ts_params->session_priv_mpool);
2031 TEST_ASSERT_EQUAL(status, 0, "session init failed");
2032 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2037 create_wireless_algo_cipher_session(uint8_t dev_id,
2038 enum rte_crypto_cipher_operation op,
2039 enum rte_crypto_cipher_algorithm algo,
2040 const uint8_t *key, const uint8_t key_len,
2043 uint8_t cipher_key[key_len];
2045 struct crypto_testsuite_params *ts_params = &testsuite_params;
2046 struct crypto_unittest_params *ut_params = &unittest_params;
2048 memcpy(cipher_key, key, key_len);
2050 /* Setup Cipher Parameters */
2051 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2052 ut_params->cipher_xform.next = NULL;
2054 ut_params->cipher_xform.cipher.algo = algo;
2055 ut_params->cipher_xform.cipher.op = op;
2056 ut_params->cipher_xform.cipher.key.data = cipher_key;
2057 ut_params->cipher_xform.cipher.key.length = key_len;
2058 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2059 ut_params->cipher_xform.cipher.iv.length = iv_len;
2061 debug_hexdump(stdout, "key:", key, key_len);
2063 /* Create Crypto session */
2064 ut_params->sess = rte_cryptodev_sym_session_create(
2065 ts_params->session_mpool);
2067 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2068 &ut_params->cipher_xform,
2069 ts_params->session_priv_mpool);
2070 TEST_ASSERT_EQUAL(status, 0, "session init failed");
2071 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2076 create_wireless_algo_cipher_operation(const uint8_t *iv, uint8_t iv_len,
2077 unsigned int cipher_len,
2078 unsigned int cipher_offset)
2080 struct crypto_testsuite_params *ts_params = &testsuite_params;
2081 struct crypto_unittest_params *ut_params = &unittest_params;
2083 /* Generate Crypto op data structure */
2084 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2085 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2086 TEST_ASSERT_NOT_NULL(ut_params->op,
2087 "Failed to allocate pktmbuf offload");
2089 /* Set crypto operation data parameters */
2090 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2092 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2094 /* set crypto operation source mbuf */
2095 sym_op->m_src = ut_params->ibuf;
2098 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2100 sym_op->cipher.data.length = cipher_len;
2101 sym_op->cipher.data.offset = cipher_offset;
2106 create_wireless_algo_cipher_operation_oop(const uint8_t *iv, uint8_t iv_len,
2107 unsigned int cipher_len,
2108 unsigned int cipher_offset)
2110 struct crypto_testsuite_params *ts_params = &testsuite_params;
2111 struct crypto_unittest_params *ut_params = &unittest_params;
2113 /* Generate Crypto op data structure */
2114 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2115 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2116 TEST_ASSERT_NOT_NULL(ut_params->op,
2117 "Failed to allocate pktmbuf offload");
2119 /* Set crypto operation data parameters */
2120 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2122 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2124 /* set crypto operation source mbuf */
2125 sym_op->m_src = ut_params->ibuf;
2126 sym_op->m_dst = ut_params->obuf;
2129 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2131 sym_op->cipher.data.length = cipher_len;
2132 sym_op->cipher.data.offset = cipher_offset;
2137 create_wireless_algo_cipher_auth_session(uint8_t dev_id,
2138 enum rte_crypto_cipher_operation cipher_op,
2139 enum rte_crypto_auth_operation auth_op,
2140 enum rte_crypto_auth_algorithm auth_algo,
2141 enum rte_crypto_cipher_algorithm cipher_algo,
2142 const uint8_t *key, uint8_t key_len,
2143 uint8_t auth_iv_len, uint8_t auth_len,
2144 uint8_t cipher_iv_len)
2147 uint8_t cipher_auth_key[key_len];
2150 struct crypto_testsuite_params *ts_params = &testsuite_params;
2151 struct crypto_unittest_params *ut_params = &unittest_params;
2153 memcpy(cipher_auth_key, key, key_len);
2155 /* Setup Authentication Parameters */
2156 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2157 ut_params->auth_xform.next = NULL;
2159 ut_params->auth_xform.auth.op = auth_op;
2160 ut_params->auth_xform.auth.algo = auth_algo;
2161 ut_params->auth_xform.auth.key.length = key_len;
2162 /* Hash key = cipher key */
2163 ut_params->auth_xform.auth.key.data = cipher_auth_key;
2164 ut_params->auth_xform.auth.digest_length = auth_len;
2165 /* Auth IV will be after cipher IV */
2166 ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2167 ut_params->auth_xform.auth.iv.length = auth_iv_len;
2169 /* Setup Cipher Parameters */
2170 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2171 ut_params->cipher_xform.next = &ut_params->auth_xform;
2173 ut_params->cipher_xform.cipher.algo = cipher_algo;
2174 ut_params->cipher_xform.cipher.op = cipher_op;
2175 ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2176 ut_params->cipher_xform.cipher.key.length = key_len;
2177 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2178 ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2180 debug_hexdump(stdout, "key:", key, key_len);
2182 /* Create Crypto session*/
2183 ut_params->sess = rte_cryptodev_sym_session_create(
2184 ts_params->session_mpool);
2185 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2187 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2188 &ut_params->cipher_xform,
2189 ts_params->session_priv_mpool);
2190 if (status == -ENOTSUP)
2193 TEST_ASSERT_EQUAL(status, 0, "session init failed");
2198 create_wireless_cipher_auth_session(uint8_t dev_id,
2199 enum rte_crypto_cipher_operation cipher_op,
2200 enum rte_crypto_auth_operation auth_op,
2201 enum rte_crypto_auth_algorithm auth_algo,
2202 enum rte_crypto_cipher_algorithm cipher_algo,
2203 const struct wireless_test_data *tdata)
2205 const uint8_t key_len = tdata->key.len;
2206 uint8_t cipher_auth_key[key_len];
2209 struct crypto_testsuite_params *ts_params = &testsuite_params;
2210 struct crypto_unittest_params *ut_params = &unittest_params;
2211 const uint8_t *key = tdata->key.data;
2212 const uint8_t auth_len = tdata->digest.len;
2213 uint8_t cipher_iv_len = tdata->cipher_iv.len;
2214 uint8_t auth_iv_len = tdata->auth_iv.len;
2216 memcpy(cipher_auth_key, key, key_len);
2218 /* Setup Authentication Parameters */
2219 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2220 ut_params->auth_xform.next = NULL;
2222 ut_params->auth_xform.auth.op = auth_op;
2223 ut_params->auth_xform.auth.algo = auth_algo;
2224 ut_params->auth_xform.auth.key.length = key_len;
2225 /* Hash key = cipher key */
2226 ut_params->auth_xform.auth.key.data = cipher_auth_key;
2227 ut_params->auth_xform.auth.digest_length = auth_len;
2228 /* Auth IV will be after cipher IV */
2229 ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2230 ut_params->auth_xform.auth.iv.length = auth_iv_len;
2232 /* Setup Cipher Parameters */
2233 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2234 ut_params->cipher_xform.next = &ut_params->auth_xform;
2236 ut_params->cipher_xform.cipher.algo = cipher_algo;
2237 ut_params->cipher_xform.cipher.op = cipher_op;
2238 ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2239 ut_params->cipher_xform.cipher.key.length = key_len;
2240 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2241 ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2244 debug_hexdump(stdout, "key:", key, key_len);
2246 /* Create Crypto session*/
2247 ut_params->sess = rte_cryptodev_sym_session_create(
2248 ts_params->session_mpool);
2250 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2251 &ut_params->cipher_xform,
2252 ts_params->session_priv_mpool);
2253 if (status == -ENOTSUP)
2256 TEST_ASSERT_EQUAL(status, 0, "session init failed");
2257 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2262 create_zuc_cipher_auth_encrypt_generate_session(uint8_t dev_id,
2263 const struct wireless_test_data *tdata)
2265 return create_wireless_cipher_auth_session(dev_id,
2266 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2267 RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_ZUC_EIA3,
2268 RTE_CRYPTO_CIPHER_ZUC_EEA3, tdata);
2272 create_wireless_algo_auth_cipher_session(uint8_t dev_id,
2273 enum rte_crypto_cipher_operation cipher_op,
2274 enum rte_crypto_auth_operation auth_op,
2275 enum rte_crypto_auth_algorithm auth_algo,
2276 enum rte_crypto_cipher_algorithm cipher_algo,
2277 const uint8_t *key, const uint8_t key_len,
2278 uint8_t auth_iv_len, uint8_t auth_len,
2279 uint8_t cipher_iv_len)
2281 uint8_t auth_cipher_key[key_len];
2283 struct crypto_testsuite_params *ts_params = &testsuite_params;
2284 struct crypto_unittest_params *ut_params = &unittest_params;
2286 memcpy(auth_cipher_key, key, key_len);
2288 /* Setup Authentication Parameters */
2289 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2290 ut_params->auth_xform.auth.op = auth_op;
2291 ut_params->auth_xform.next = &ut_params->cipher_xform;
2292 ut_params->auth_xform.auth.algo = auth_algo;
2293 ut_params->auth_xform.auth.key.length = key_len;
2294 ut_params->auth_xform.auth.key.data = auth_cipher_key;
2295 ut_params->auth_xform.auth.digest_length = auth_len;
2296 /* Auth IV will be after cipher IV */
2297 ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2298 ut_params->auth_xform.auth.iv.length = auth_iv_len;
2300 /* Setup Cipher Parameters */
2301 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2302 ut_params->cipher_xform.next = NULL;
2303 ut_params->cipher_xform.cipher.algo = cipher_algo;
2304 ut_params->cipher_xform.cipher.op = cipher_op;
2305 ut_params->cipher_xform.cipher.key.data = auth_cipher_key;
2306 ut_params->cipher_xform.cipher.key.length = key_len;
2307 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2308 ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2310 debug_hexdump(stdout, "key:", key, key_len);
2312 /* Create Crypto session*/
2313 ut_params->sess = rte_cryptodev_sym_session_create(
2314 ts_params->session_mpool);
2315 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2317 if (cipher_op == RTE_CRYPTO_CIPHER_OP_DECRYPT) {
2318 ut_params->auth_xform.next = NULL;
2319 ut_params->cipher_xform.next = &ut_params->auth_xform;
2320 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2321 &ut_params->cipher_xform,
2322 ts_params->session_priv_mpool);
2325 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2326 &ut_params->auth_xform,
2327 ts_params->session_priv_mpool);
2329 if (status == -ENOTSUP)
2332 TEST_ASSERT_EQUAL(status, 0, "session init failed");
2338 create_wireless_algo_hash_operation(const uint8_t *auth_tag,
2339 unsigned int auth_tag_len,
2340 const uint8_t *iv, unsigned int iv_len,
2341 unsigned int data_pad_len,
2342 enum rte_crypto_auth_operation op,
2343 unsigned int auth_len, unsigned int auth_offset)
2345 struct crypto_testsuite_params *ts_params = &testsuite_params;
2347 struct crypto_unittest_params *ut_params = &unittest_params;
2349 /* Generate Crypto op data structure */
2350 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2351 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2352 TEST_ASSERT_NOT_NULL(ut_params->op,
2353 "Failed to allocate pktmbuf offload");
2355 /* Set crypto operation data parameters */
2356 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2358 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2360 /* set crypto operation source mbuf */
2361 sym_op->m_src = ut_params->ibuf;
2364 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2367 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2368 ut_params->ibuf, auth_tag_len);
2370 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2371 "no room to append auth tag");
2372 ut_params->digest = sym_op->auth.digest.data;
2373 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2374 ut_params->ibuf, data_pad_len);
2375 if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2376 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2378 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2380 debug_hexdump(stdout, "digest:",
2381 sym_op->auth.digest.data,
2384 sym_op->auth.data.length = auth_len;
2385 sym_op->auth.data.offset = auth_offset;
2391 create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata,
2392 enum rte_crypto_auth_operation op)
2394 struct crypto_testsuite_params *ts_params = &testsuite_params;
2395 struct crypto_unittest_params *ut_params = &unittest_params;
2397 const uint8_t *auth_tag = tdata->digest.data;
2398 const unsigned int auth_tag_len = tdata->digest.len;
2399 unsigned int plaintext_len = ceil_byte_length(tdata->plaintext.len);
2400 unsigned int data_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2402 const uint8_t *cipher_iv = tdata->cipher_iv.data;
2403 const uint8_t cipher_iv_len = tdata->cipher_iv.len;
2404 const uint8_t *auth_iv = tdata->auth_iv.data;
2405 const uint8_t auth_iv_len = tdata->auth_iv.len;
2406 const unsigned int cipher_len = tdata->validCipherLenInBits.len;
2407 const unsigned int auth_len = tdata->validAuthLenInBits.len;
2409 /* Generate Crypto op data structure */
2410 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2411 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2412 TEST_ASSERT_NOT_NULL(ut_params->op,
2413 "Failed to allocate pktmbuf offload");
2414 /* Set crypto operation data parameters */
2415 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2417 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2419 /* set crypto operation source mbuf */
2420 sym_op->m_src = ut_params->ibuf;
2423 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2424 ut_params->ibuf, auth_tag_len);
2426 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2427 "no room to append auth tag");
2428 ut_params->digest = sym_op->auth.digest.data;
2429 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2430 ut_params->ibuf, data_pad_len);
2431 if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2432 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2434 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2436 debug_hexdump(stdout, "digest:",
2437 sym_op->auth.digest.data,
2440 /* Copy cipher and auth IVs at the end of the crypto operation */
2441 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2443 rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2444 iv_ptr += cipher_iv_len;
2445 rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2447 sym_op->cipher.data.length = cipher_len;
2448 sym_op->cipher.data.offset = 0;
2449 sym_op->auth.data.length = auth_len;
2450 sym_op->auth.data.offset = 0;
2456 create_zuc_cipher_hash_generate_operation(
2457 const struct wireless_test_data *tdata)
2459 return create_wireless_cipher_hash_operation(tdata,
2460 RTE_CRYPTO_AUTH_OP_GENERATE);
2464 create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
2465 const unsigned auth_tag_len,
2466 const uint8_t *auth_iv, uint8_t auth_iv_len,
2467 unsigned data_pad_len,
2468 enum rte_crypto_auth_operation op,
2469 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2470 const unsigned cipher_len, const unsigned cipher_offset,
2471 const unsigned auth_len, const unsigned auth_offset)
2473 struct crypto_testsuite_params *ts_params = &testsuite_params;
2474 struct crypto_unittest_params *ut_params = &unittest_params;
2476 enum rte_crypto_cipher_algorithm cipher_algo =
2477 ut_params->cipher_xform.cipher.algo;
2478 enum rte_crypto_auth_algorithm auth_algo =
2479 ut_params->auth_xform.auth.algo;
2481 /* Generate Crypto op data structure */
2482 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2483 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2484 TEST_ASSERT_NOT_NULL(ut_params->op,
2485 "Failed to allocate pktmbuf offload");
2486 /* Set crypto operation data parameters */
2487 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2489 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2491 /* set crypto operation source mbuf */
2492 sym_op->m_src = ut_params->ibuf;
2495 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2496 ut_params->ibuf, auth_tag_len);
2498 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2499 "no room to append auth tag");
2500 ut_params->digest = sym_op->auth.digest.data;
2502 if (rte_pktmbuf_is_contiguous(ut_params->ibuf)) {
2503 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2504 ut_params->ibuf, data_pad_len);
2506 struct rte_mbuf *m = ut_params->ibuf;
2507 unsigned int offset = data_pad_len;
2509 while (offset > m->data_len && m->next != NULL) {
2510 offset -= m->data_len;
2513 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2517 if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2518 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2520 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2522 debug_hexdump(stdout, "digest:",
2523 sym_op->auth.digest.data,
2526 /* Copy cipher and auth IVs at the end of the crypto operation */
2527 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2529 rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2530 iv_ptr += cipher_iv_len;
2531 rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2533 if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
2534 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
2535 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
2536 sym_op->cipher.data.length = cipher_len;
2537 sym_op->cipher.data.offset = cipher_offset;
2539 sym_op->cipher.data.length = cipher_len >> 3;
2540 sym_op->cipher.data.offset = cipher_offset >> 3;
2543 if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
2544 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
2545 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
2546 sym_op->auth.data.length = auth_len;
2547 sym_op->auth.data.offset = auth_offset;
2549 sym_op->auth.data.length = auth_len >> 3;
2550 sym_op->auth.data.offset = auth_offset >> 3;
2557 create_wireless_algo_auth_cipher_operation(
2558 const uint8_t *auth_tag, unsigned int auth_tag_len,
2559 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2560 const uint8_t *auth_iv, uint8_t auth_iv_len,
2561 unsigned int data_pad_len,
2562 unsigned int cipher_len, unsigned int cipher_offset,
2563 unsigned int auth_len, unsigned int auth_offset,
2564 uint8_t op_mode, uint8_t do_sgl, uint8_t verify)
2566 struct crypto_testsuite_params *ts_params = &testsuite_params;
2567 struct crypto_unittest_params *ut_params = &unittest_params;
2569 enum rte_crypto_cipher_algorithm cipher_algo =
2570 ut_params->cipher_xform.cipher.algo;
2571 enum rte_crypto_auth_algorithm auth_algo =
2572 ut_params->auth_xform.auth.algo;
2574 /* Generate Crypto op data structure */
2575 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2576 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2577 TEST_ASSERT_NOT_NULL(ut_params->op,
2578 "Failed to allocate pktmbuf offload");
2580 /* Set crypto operation data parameters */
2581 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2583 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2585 /* set crypto operation mbufs */
2586 sym_op->m_src = ut_params->ibuf;
2587 if (op_mode == OUT_OF_PLACE)
2588 sym_op->m_dst = ut_params->obuf;
2592 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(
2593 (op_mode == IN_PLACE ?
2594 ut_params->ibuf : ut_params->obuf),
2595 uint8_t *, data_pad_len);
2596 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2597 (op_mode == IN_PLACE ?
2598 ut_params->ibuf : ut_params->obuf),
2600 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2602 uint16_t remaining_off = (auth_offset >> 3) + (auth_len >> 3);
2603 struct rte_mbuf *sgl_buf = (op_mode == IN_PLACE ?
2604 sym_op->m_src : sym_op->m_dst);
2605 while (remaining_off >= rte_pktmbuf_data_len(sgl_buf)) {
2606 remaining_off -= rte_pktmbuf_data_len(sgl_buf);
2607 sgl_buf = sgl_buf->next;
2609 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(sgl_buf,
2610 uint8_t *, remaining_off);
2611 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(sgl_buf,
2613 memset(sym_op->auth.digest.data, 0, remaining_off);
2614 while (sgl_buf->next != NULL) {
2615 memset(rte_pktmbuf_mtod(sgl_buf, uint8_t *),
2616 0, rte_pktmbuf_data_len(sgl_buf));
2617 sgl_buf = sgl_buf->next;
2621 /* Copy digest for the verification */
2623 memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2625 /* Copy cipher and auth IVs at the end of the crypto operation */
2626 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(
2627 ut_params->op, uint8_t *, IV_OFFSET);
2629 rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2630 iv_ptr += cipher_iv_len;
2631 rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2633 if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
2634 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
2635 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
2636 sym_op->cipher.data.length = cipher_len;
2637 sym_op->cipher.data.offset = cipher_offset;
2639 sym_op->cipher.data.length = cipher_len >> 3;
2640 sym_op->cipher.data.offset = cipher_offset >> 3;
2643 if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
2644 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
2645 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
2646 sym_op->auth.data.length = auth_len;
2647 sym_op->auth.data.offset = auth_offset;
2649 sym_op->auth.data.length = auth_len >> 3;
2650 sym_op->auth.data.offset = auth_offset >> 3;
2657 test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
2659 struct crypto_testsuite_params *ts_params = &testsuite_params;
2660 struct crypto_unittest_params *ut_params = &unittest_params;
2663 unsigned plaintext_pad_len;
2664 unsigned plaintext_len;
2666 struct rte_cryptodev_info dev_info;
2668 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
2669 uint64_t feat_flags = dev_info.feature_flags;
2671 if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
2672 ((tdata->validAuthLenInBits.len % 8) != 0)) {
2673 printf("Device doesn't support NON-Byte Aligned Data.\n");
2677 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
2678 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
2679 printf("Device doesn't support RAW data-path APIs.\n");
2683 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2686 /* Verify the capabilities */
2687 struct rte_cryptodev_sym_capability_idx cap_idx;
2688 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2689 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
2690 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2694 /* Create SNOW 3G session */
2695 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2696 tdata->key.data, tdata->key.len,
2697 tdata->auth_iv.len, tdata->digest.len,
2698 RTE_CRYPTO_AUTH_OP_GENERATE,
2699 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
2703 /* alloc mbuf and set payload */
2704 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2706 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2707 rte_pktmbuf_tailroom(ut_params->ibuf));
2709 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2710 /* Append data which is padded to a multiple of */
2711 /* the algorithms block size */
2712 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2713 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2715 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2717 /* Create SNOW 3G operation */
2718 retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
2719 tdata->auth_iv.data, tdata->auth_iv.len,
2720 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
2721 tdata->validAuthLenInBits.len,
2726 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
2727 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
2728 ut_params->op, 0, 1, 1, 0);
2730 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2732 ut_params->obuf = ut_params->op->sym->m_src;
2733 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2734 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2735 + plaintext_pad_len;
2738 TEST_ASSERT_BUFFERS_ARE_EQUAL(
2741 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
2742 "SNOW 3G Generated auth tag not as expected");
2748 test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
2750 struct crypto_testsuite_params *ts_params = &testsuite_params;
2751 struct crypto_unittest_params *ut_params = &unittest_params;
2754 unsigned plaintext_pad_len;
2755 unsigned plaintext_len;
2757 struct rte_cryptodev_info dev_info;
2759 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
2760 uint64_t feat_flags = dev_info.feature_flags;
2762 if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
2763 ((tdata->validAuthLenInBits.len % 8) != 0)) {
2764 printf("Device doesn't support NON-Byte Aligned Data.\n");
2768 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
2769 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
2770 printf("Device doesn't support RAW data-path APIs.\n");
2774 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2777 /* Verify the capabilities */
2778 struct rte_cryptodev_sym_capability_idx cap_idx;
2779 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2780 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
2781 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2785 /* Create SNOW 3G session */
2786 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2787 tdata->key.data, tdata->key.len,
2788 tdata->auth_iv.len, tdata->digest.len,
2789 RTE_CRYPTO_AUTH_OP_VERIFY,
2790 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
2793 /* alloc mbuf and set payload */
2794 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2796 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2797 rte_pktmbuf_tailroom(ut_params->ibuf));
2799 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2800 /* Append data which is padded to a multiple of */
2801 /* the algorithms block size */
2802 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2803 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2805 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2807 /* Create SNOW 3G operation */
2808 retval = create_wireless_algo_hash_operation(tdata->digest.data,
2810 tdata->auth_iv.data, tdata->auth_iv.len,
2812 RTE_CRYPTO_AUTH_OP_VERIFY,
2813 tdata->validAuthLenInBits.len,
2818 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
2819 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
2820 ut_params->op, 0, 1, 1, 0);
2822 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2824 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2825 ut_params->obuf = ut_params->op->sym->m_src;
2826 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2827 + plaintext_pad_len;
2830 if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
2839 test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
2841 struct crypto_testsuite_params *ts_params = &testsuite_params;
2842 struct crypto_unittest_params *ut_params = &unittest_params;
2845 unsigned plaintext_pad_len;
2846 unsigned plaintext_len;
2848 struct rte_cryptodev_info dev_info;
2850 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
2851 uint64_t feat_flags = dev_info.feature_flags;
2853 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
2854 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
2855 printf("Device doesn't support RAW data-path APIs.\n");
2859 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2862 /* Verify the capabilities */
2863 struct rte_cryptodev_sym_capability_idx cap_idx;
2864 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2865 cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
2866 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2870 /* Create KASUMI session */
2871 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2872 tdata->key.data, tdata->key.len,
2873 0, tdata->digest.len,
2874 RTE_CRYPTO_AUTH_OP_GENERATE,
2875 RTE_CRYPTO_AUTH_KASUMI_F9);
2879 /* alloc mbuf and set payload */
2880 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2882 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2883 rte_pktmbuf_tailroom(ut_params->ibuf));
2885 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2886 /* Append data which is padded to a multiple of */
2887 /* the algorithms block size */
2888 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2889 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2891 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2893 /* Create KASUMI operation */
2894 retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
2896 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
2897 tdata->plaintext.len,
2902 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2903 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
2905 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
2906 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
2907 ut_params->op, 0, 1, 1, 0);
2909 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2912 ut_params->obuf = ut_params->op->sym->m_src;
2913 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2914 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2915 + plaintext_pad_len;
2918 TEST_ASSERT_BUFFERS_ARE_EQUAL(
2921 DIGEST_BYTE_LENGTH_KASUMI_F9,
2922 "KASUMI Generated auth tag not as expected");
2928 test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
2930 struct crypto_testsuite_params *ts_params = &testsuite_params;
2931 struct crypto_unittest_params *ut_params = &unittest_params;
2934 unsigned plaintext_pad_len;
2935 unsigned plaintext_len;
2937 struct rte_cryptodev_info dev_info;
2939 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
2940 uint64_t feat_flags = dev_info.feature_flags;
2942 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
2943 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
2944 printf("Device doesn't support RAW data-path APIs.\n");
2948 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2951 /* Verify the capabilities */
2952 struct rte_cryptodev_sym_capability_idx cap_idx;
2953 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2954 cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
2955 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2959 /* Create KASUMI session */
2960 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2961 tdata->key.data, tdata->key.len,
2962 0, tdata->digest.len,
2963 RTE_CRYPTO_AUTH_OP_VERIFY,
2964 RTE_CRYPTO_AUTH_KASUMI_F9);
2967 /* alloc mbuf and set payload */
2968 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2970 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2971 rte_pktmbuf_tailroom(ut_params->ibuf));
2973 plaintext_len = ceil_byte_length(tdata->plaintext.len);
2974 /* Append data which is padded to a multiple */
2975 /* of the algorithms block size */
2976 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2977 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2979 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2981 /* Create KASUMI operation */
2982 retval = create_wireless_algo_hash_operation(tdata->digest.data,
2986 RTE_CRYPTO_AUTH_OP_VERIFY,
2987 tdata->plaintext.len,
2992 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
2993 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
2994 ut_params->op, 0, 1, 1, 0);
2996 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2998 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2999 ut_params->obuf = ut_params->op->sym->m_src;
3000 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3001 + plaintext_pad_len;
3004 if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
3013 test_snow3g_hash_generate_test_case_1(void)
3015 return test_snow3g_authentication(&snow3g_hash_test_case_1);
3019 test_snow3g_hash_generate_test_case_2(void)
3021 return test_snow3g_authentication(&snow3g_hash_test_case_2);
3025 test_snow3g_hash_generate_test_case_3(void)
3027 return test_snow3g_authentication(&snow3g_hash_test_case_3);
3031 test_snow3g_hash_generate_test_case_4(void)
3033 return test_snow3g_authentication(&snow3g_hash_test_case_4);
3037 test_snow3g_hash_generate_test_case_5(void)
3039 return test_snow3g_authentication(&snow3g_hash_test_case_5);
3043 test_snow3g_hash_generate_test_case_6(void)
3045 return test_snow3g_authentication(&snow3g_hash_test_case_6);
3049 test_snow3g_hash_verify_test_case_1(void)
3051 return test_snow3g_authentication_verify(&snow3g_hash_test_case_1);
3056 test_snow3g_hash_verify_test_case_2(void)
3058 return test_snow3g_authentication_verify(&snow3g_hash_test_case_2);
3062 test_snow3g_hash_verify_test_case_3(void)
3064 return test_snow3g_authentication_verify(&snow3g_hash_test_case_3);
3068 test_snow3g_hash_verify_test_case_4(void)
3070 return test_snow3g_authentication_verify(&snow3g_hash_test_case_4);
3074 test_snow3g_hash_verify_test_case_5(void)
3076 return test_snow3g_authentication_verify(&snow3g_hash_test_case_5);
3080 test_snow3g_hash_verify_test_case_6(void)
3082 return test_snow3g_authentication_verify(&snow3g_hash_test_case_6);
3086 test_kasumi_hash_generate_test_case_1(void)
3088 return test_kasumi_authentication(&kasumi_hash_test_case_1);
3092 test_kasumi_hash_generate_test_case_2(void)
3094 return test_kasumi_authentication(&kasumi_hash_test_case_2);
3098 test_kasumi_hash_generate_test_case_3(void)
3100 return test_kasumi_authentication(&kasumi_hash_test_case_3);
3104 test_kasumi_hash_generate_test_case_4(void)
3106 return test_kasumi_authentication(&kasumi_hash_test_case_4);
3110 test_kasumi_hash_generate_test_case_5(void)
3112 return test_kasumi_authentication(&kasumi_hash_test_case_5);
3116 test_kasumi_hash_generate_test_case_6(void)
3118 return test_kasumi_authentication(&kasumi_hash_test_case_6);
3122 test_kasumi_hash_verify_test_case_1(void)
3124 return test_kasumi_authentication_verify(&kasumi_hash_test_case_1);
3128 test_kasumi_hash_verify_test_case_2(void)
3130 return test_kasumi_authentication_verify(&kasumi_hash_test_case_2);
3134 test_kasumi_hash_verify_test_case_3(void)
3136 return test_kasumi_authentication_verify(&kasumi_hash_test_case_3);
3140 test_kasumi_hash_verify_test_case_4(void)
3142 return test_kasumi_authentication_verify(&kasumi_hash_test_case_4);
3146 test_kasumi_hash_verify_test_case_5(void)
3148 return test_kasumi_authentication_verify(&kasumi_hash_test_case_5);
3152 test_kasumi_encryption(const struct kasumi_test_data *tdata)
3154 struct crypto_testsuite_params *ts_params = &testsuite_params;
3155 struct crypto_unittest_params *ut_params = &unittest_params;
3158 uint8_t *plaintext, *ciphertext;
3159 unsigned plaintext_pad_len;
3160 unsigned plaintext_len;
3161 struct rte_cryptodev_info dev_info;
3163 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3164 uint64_t feat_flags = dev_info.feature_flags;
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");
3172 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3175 /* Verify the capabilities */
3176 struct rte_cryptodev_sym_capability_idx cap_idx;
3177 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3178 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3179 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3183 /* Create KASUMI session */
3184 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3185 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3186 RTE_CRYPTO_CIPHER_KASUMI_F8,
3187 tdata->key.data, tdata->key.len,
3188 tdata->cipher_iv.len);
3192 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3194 /* Clear mbuf payload */
3195 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3196 rte_pktmbuf_tailroom(ut_params->ibuf));
3198 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3199 /* Append data which is padded to a multiple */
3200 /* of the algorithms block size */
3201 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3202 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3204 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3206 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3208 /* Create KASUMI operation */
3209 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3210 tdata->cipher_iv.len,
3211 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3212 tdata->validCipherOffsetInBits.len);
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, 1, 0, 1, tdata->cipher_iv.len);
3220 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3222 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3224 ut_params->obuf = ut_params->op->sym->m_dst;
3225 if (ut_params->obuf)
3226 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3228 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3230 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3232 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3233 (tdata->validCipherOffsetInBits.len >> 3);
3235 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3237 reference_ciphertext,
3238 tdata->validCipherLenInBits.len,
3239 "KASUMI Ciphertext data not as expected");
3244 test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
3246 struct crypto_testsuite_params *ts_params = &testsuite_params;
3247 struct crypto_unittest_params *ut_params = &unittest_params;
3251 unsigned int plaintext_pad_len;
3252 unsigned int plaintext_len;
3254 uint8_t buffer[10000];
3255 const uint8_t *ciphertext;
3257 struct rte_cryptodev_info dev_info;
3259 /* Verify the capabilities */
3260 struct rte_cryptodev_sym_capability_idx cap_idx;
3261 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3262 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3263 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3267 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3269 uint64_t feat_flags = dev_info.feature_flags;
3271 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
3272 printf("Device doesn't support in-place scatter-gather. "
3277 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3278 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3279 printf("Device doesn't support RAW data-path APIs.\n");
3283 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3286 /* Create KASUMI session */
3287 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3288 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3289 RTE_CRYPTO_CIPHER_KASUMI_F8,
3290 tdata->key.data, tdata->key.len,
3291 tdata->cipher_iv.len);
3295 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3298 /* Append data which is padded to a multiple */
3299 /* of the algorithms block size */
3300 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3302 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3303 plaintext_pad_len, 10, 0);
3305 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3307 /* Create KASUMI operation */
3308 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3309 tdata->cipher_iv.len,
3310 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3311 tdata->validCipherOffsetInBits.len);
3315 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3316 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3317 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
3319 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3321 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3323 ut_params->obuf = ut_params->op->sym->m_dst;
3325 if (ut_params->obuf)
3326 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3327 plaintext_len, buffer);
3329 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3330 tdata->validCipherOffsetInBits.len >> 3,
3331 plaintext_len, buffer);
3334 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3336 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3337 (tdata->validCipherOffsetInBits.len >> 3);
3339 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3341 reference_ciphertext,
3342 tdata->validCipherLenInBits.len,
3343 "KASUMI Ciphertext data not as expected");
3348 test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
3350 struct crypto_testsuite_params *ts_params = &testsuite_params;
3351 struct crypto_unittest_params *ut_params = &unittest_params;
3354 uint8_t *plaintext, *ciphertext;
3355 unsigned plaintext_pad_len;
3356 unsigned plaintext_len;
3358 /* Verify the capabilities */
3359 struct rte_cryptodev_sym_capability_idx cap_idx;
3360 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3361 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3362 /* Data-path service does not support OOP */
3363 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3367 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3370 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3373 /* Create KASUMI session */
3374 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3375 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3376 RTE_CRYPTO_CIPHER_KASUMI_F8,
3377 tdata->key.data, tdata->key.len,
3378 tdata->cipher_iv.len);
3382 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3383 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3385 /* Clear mbuf payload */
3386 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3387 rte_pktmbuf_tailroom(ut_params->ibuf));
3389 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3390 /* Append data which is padded to a multiple */
3391 /* of the algorithms block size */
3392 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3393 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3395 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3396 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3398 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3400 /* Create KASUMI operation */
3401 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3402 tdata->cipher_iv.len,
3403 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3404 tdata->validCipherOffsetInBits.len);
3408 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3410 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3412 ut_params->obuf = ut_params->op->sym->m_dst;
3413 if (ut_params->obuf)
3414 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3416 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3418 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3420 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3421 (tdata->validCipherOffsetInBits.len >> 3);
3423 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3425 reference_ciphertext,
3426 tdata->validCipherLenInBits.len,
3427 "KASUMI Ciphertext data not as expected");
3432 test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
3434 struct crypto_testsuite_params *ts_params = &testsuite_params;
3435 struct crypto_unittest_params *ut_params = &unittest_params;
3438 unsigned int plaintext_pad_len;
3439 unsigned int plaintext_len;
3441 const uint8_t *ciphertext;
3442 uint8_t buffer[2048];
3444 struct rte_cryptodev_info dev_info;
3446 /* Verify the capabilities */
3447 struct rte_cryptodev_sym_capability_idx cap_idx;
3448 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3449 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3450 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3454 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3457 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3460 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3462 uint64_t feat_flags = dev_info.feature_flags;
3463 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
3464 printf("Device doesn't support out-of-place scatter-gather "
3465 "in both input and output mbufs. "
3470 /* Create KASUMI session */
3471 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3472 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3473 RTE_CRYPTO_CIPHER_KASUMI_F8,
3474 tdata->key.data, tdata->key.len,
3475 tdata->cipher_iv.len);
3479 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3480 /* Append data which is padded to a multiple */
3481 /* of the algorithms block size */
3482 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3484 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3485 plaintext_pad_len, 10, 0);
3486 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
3487 plaintext_pad_len, 3, 0);
3489 /* Append data which is padded to a multiple */
3490 /* of the algorithms block size */
3491 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3493 /* Create KASUMI operation */
3494 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3495 tdata->cipher_iv.len,
3496 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3497 tdata->validCipherOffsetInBits.len);
3501 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3503 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3505 ut_params->obuf = ut_params->op->sym->m_dst;
3506 if (ut_params->obuf)
3507 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3508 plaintext_pad_len, buffer);
3510 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3511 tdata->validCipherOffsetInBits.len >> 3,
3512 plaintext_pad_len, buffer);
3514 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3515 (tdata->validCipherOffsetInBits.len >> 3);
3517 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3519 reference_ciphertext,
3520 tdata->validCipherLenInBits.len,
3521 "KASUMI Ciphertext data not as expected");
3527 test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
3529 struct crypto_testsuite_params *ts_params = &testsuite_params;
3530 struct crypto_unittest_params *ut_params = &unittest_params;
3533 uint8_t *ciphertext, *plaintext;
3534 unsigned ciphertext_pad_len;
3535 unsigned ciphertext_len;
3537 /* Verify the capabilities */
3538 struct rte_cryptodev_sym_capability_idx cap_idx;
3539 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3540 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3541 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3545 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3548 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3551 /* Create KASUMI session */
3552 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3553 RTE_CRYPTO_CIPHER_OP_DECRYPT,
3554 RTE_CRYPTO_CIPHER_KASUMI_F8,
3555 tdata->key.data, tdata->key.len,
3556 tdata->cipher_iv.len);
3560 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3561 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3563 /* Clear mbuf payload */
3564 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3565 rte_pktmbuf_tailroom(ut_params->ibuf));
3567 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3568 /* Append data which is padded to a multiple */
3569 /* of the algorithms block size */
3570 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
3571 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3572 ciphertext_pad_len);
3573 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
3574 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3576 debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
3578 /* Create KASUMI operation */
3579 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3580 tdata->cipher_iv.len,
3581 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3582 tdata->validCipherOffsetInBits.len);
3586 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3588 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3590 ut_params->obuf = ut_params->op->sym->m_dst;
3591 if (ut_params->obuf)
3592 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3594 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
3596 debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
3598 const uint8_t *reference_plaintext = tdata->plaintext.data +
3599 (tdata->validCipherOffsetInBits.len >> 3);
3601 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3603 reference_plaintext,
3604 tdata->validCipherLenInBits.len,
3605 "KASUMI Plaintext data not as expected");
3610 test_kasumi_decryption(const struct kasumi_test_data *tdata)
3612 struct crypto_testsuite_params *ts_params = &testsuite_params;
3613 struct crypto_unittest_params *ut_params = &unittest_params;
3616 uint8_t *ciphertext, *plaintext;
3617 unsigned ciphertext_pad_len;
3618 unsigned ciphertext_len;
3619 struct rte_cryptodev_info dev_info;
3621 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3622 uint64_t feat_flags = dev_info.feature_flags;
3624 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3625 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3626 printf("Device doesn't support RAW data-path APIs.\n");
3630 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3633 /* Verify the capabilities */
3634 struct rte_cryptodev_sym_capability_idx cap_idx;
3635 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3636 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3637 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3641 /* Create KASUMI session */
3642 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3643 RTE_CRYPTO_CIPHER_OP_DECRYPT,
3644 RTE_CRYPTO_CIPHER_KASUMI_F8,
3645 tdata->key.data, tdata->key.len,
3646 tdata->cipher_iv.len);
3650 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3652 /* Clear mbuf payload */
3653 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3654 rte_pktmbuf_tailroom(ut_params->ibuf));
3656 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3657 /* Append data which is padded to a multiple */
3658 /* of the algorithms block size */
3659 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
3660 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3661 ciphertext_pad_len);
3662 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3664 debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
3666 /* Create KASUMI operation */
3667 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3668 tdata->cipher_iv.len,
3669 tdata->ciphertext.len,
3670 tdata->validCipherOffsetInBits.len);
3674 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3675 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3676 ut_params->op, 1, 0, 1, 0);
3678 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3680 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3682 ut_params->obuf = ut_params->op->sym->m_dst;
3683 if (ut_params->obuf)
3684 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3686 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
3688 debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
3690 const uint8_t *reference_plaintext = tdata->plaintext.data +
3691 (tdata->validCipherOffsetInBits.len >> 3);
3693 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3695 reference_plaintext,
3696 tdata->validCipherLenInBits.len,
3697 "KASUMI Plaintext data not as expected");
3702 test_snow3g_encryption(const struct snow3g_test_data *tdata)
3704 struct crypto_testsuite_params *ts_params = &testsuite_params;
3705 struct crypto_unittest_params *ut_params = &unittest_params;
3708 uint8_t *plaintext, *ciphertext;
3709 unsigned plaintext_pad_len;
3710 unsigned plaintext_len;
3711 struct rte_cryptodev_info dev_info;
3713 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3714 uint64_t feat_flags = dev_info.feature_flags;
3716 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3717 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3718 printf("Device doesn't support RAW data-path APIs.\n");
3722 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3725 /* Verify the capabilities */
3726 struct rte_cryptodev_sym_capability_idx cap_idx;
3727 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3728 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
3729 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3733 /* Create SNOW 3G session */
3734 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3735 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3736 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3737 tdata->key.data, tdata->key.len,
3738 tdata->cipher_iv.len);
3742 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3744 /* Clear mbuf payload */
3745 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3746 rte_pktmbuf_tailroom(ut_params->ibuf));
3748 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3749 /* Append data which is padded to a multiple of */
3750 /* the algorithms block size */
3751 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3752 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3754 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3756 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3758 /* Create SNOW 3G operation */
3759 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3760 tdata->cipher_iv.len,
3761 tdata->validCipherLenInBits.len,
3766 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3767 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3768 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
3770 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3772 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3774 ut_params->obuf = ut_params->op->sym->m_dst;
3775 if (ut_params->obuf)
3776 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3778 ciphertext = plaintext;
3780 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3783 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3785 tdata->ciphertext.data,
3786 tdata->validDataLenInBits.len,
3787 "SNOW 3G Ciphertext data not as expected");
3793 test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
3795 struct crypto_testsuite_params *ts_params = &testsuite_params;
3796 struct crypto_unittest_params *ut_params = &unittest_params;
3797 uint8_t *plaintext, *ciphertext;
3800 unsigned plaintext_pad_len;
3801 unsigned plaintext_len;
3803 /* Verify the capabilities */
3804 struct rte_cryptodev_sym_capability_idx cap_idx;
3805 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3806 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
3807 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3811 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3814 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3817 /* Create SNOW 3G session */
3818 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3819 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3820 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3821 tdata->key.data, tdata->key.len,
3822 tdata->cipher_iv.len);
3826 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3827 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3829 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3830 "Failed to allocate input buffer in mempool");
3831 TEST_ASSERT_NOT_NULL(ut_params->obuf,
3832 "Failed to allocate output buffer in mempool");
3834 /* Clear mbuf payload */
3835 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3836 rte_pktmbuf_tailroom(ut_params->ibuf));
3838 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3839 /* Append data which is padded to a multiple of */
3840 /* the algorithms block size */
3841 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3842 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3844 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3845 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3847 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3849 /* Create SNOW 3G operation */
3850 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3851 tdata->cipher_iv.len,
3852 tdata->validCipherLenInBits.len,
3857 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3859 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3861 ut_params->obuf = ut_params->op->sym->m_dst;
3862 if (ut_params->obuf)
3863 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3865 ciphertext = plaintext;
3867 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3870 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3872 tdata->ciphertext.data,
3873 tdata->validDataLenInBits.len,
3874 "SNOW 3G Ciphertext data not as expected");
3879 test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
3881 struct crypto_testsuite_params *ts_params = &testsuite_params;
3882 struct crypto_unittest_params *ut_params = &unittest_params;
3885 unsigned int plaintext_pad_len;
3886 unsigned int plaintext_len;
3887 uint8_t buffer[10000];
3888 const uint8_t *ciphertext;
3890 struct rte_cryptodev_info dev_info;
3892 /* Verify the capabilities */
3893 struct rte_cryptodev_sym_capability_idx cap_idx;
3894 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3895 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
3896 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3900 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3903 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3906 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3908 uint64_t feat_flags = dev_info.feature_flags;
3910 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
3911 printf("Device doesn't support out-of-place scatter-gather "
3912 "in both input and output mbufs. "
3917 /* Create SNOW 3G session */
3918 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3919 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3920 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3921 tdata->key.data, tdata->key.len,
3922 tdata->cipher_iv.len);
3926 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3927 /* Append data which is padded to a multiple of */
3928 /* the algorithms block size */
3929 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3931 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3932 plaintext_pad_len, 10, 0);
3933 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
3934 plaintext_pad_len, 3, 0);
3936 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3937 "Failed to allocate input buffer in mempool");
3938 TEST_ASSERT_NOT_NULL(ut_params->obuf,
3939 "Failed to allocate output buffer in mempool");
3941 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3943 /* Create SNOW 3G operation */
3944 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3945 tdata->cipher_iv.len,
3946 tdata->validCipherLenInBits.len,
3951 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3953 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3955 ut_params->obuf = ut_params->op->sym->m_dst;
3956 if (ut_params->obuf)
3957 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3958 plaintext_len, buffer);
3960 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
3961 plaintext_len, buffer);
3963 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3966 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3968 tdata->ciphertext.data,
3969 tdata->validDataLenInBits.len,
3970 "SNOW 3G Ciphertext data not as expected");
3975 /* Shift right a buffer by "offset" bits, "offset" < 8 */
3977 buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset)
3979 uint8_t curr_byte, prev_byte;
3980 uint32_t length_in_bytes = ceil_byte_length(length + offset);
3981 uint8_t lower_byte_mask = (1 << offset) - 1;
3984 prev_byte = buffer[0];
3985 buffer[0] >>= offset;
3987 for (i = 1; i < length_in_bytes; i++) {
3988 curr_byte = buffer[i];
3989 buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) |
3990 (curr_byte >> offset);
3991 prev_byte = curr_byte;
3996 test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
3998 struct crypto_testsuite_params *ts_params = &testsuite_params;
3999 struct crypto_unittest_params *ut_params = &unittest_params;
4000 uint8_t *plaintext, *ciphertext;
4002 uint32_t plaintext_len;
4003 uint32_t plaintext_pad_len;
4004 uint8_t extra_offset = 4;
4005 uint8_t *expected_ciphertext_shifted;
4006 struct rte_cryptodev_info dev_info;
4008 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4009 uint64_t feat_flags = dev_info.feature_flags;
4011 if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
4012 ((tdata->validDataLenInBits.len % 8) != 0)) {
4013 printf("Device doesn't support NON-Byte Aligned Data.\n");
4017 /* Verify the capabilities */
4018 struct rte_cryptodev_sym_capability_idx cap_idx;
4019 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4020 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4021 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4025 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4028 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4031 /* Create SNOW 3G session */
4032 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4033 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4034 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4035 tdata->key.data, tdata->key.len,
4036 tdata->cipher_iv.len);
4040 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4041 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4043 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4044 "Failed to allocate input buffer in mempool");
4045 TEST_ASSERT_NOT_NULL(ut_params->obuf,
4046 "Failed to allocate output buffer in mempool");
4048 /* Clear mbuf payload */
4049 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4050 rte_pktmbuf_tailroom(ut_params->ibuf));
4052 plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset);
4054 * Append data which is padded to a
4055 * multiple of the algorithms block size
4057 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4059 plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf,
4062 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4064 memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3));
4065 buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset);
4067 #ifdef RTE_APP_TEST_DEBUG
4068 rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
4070 /* Create SNOW 3G operation */
4071 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4072 tdata->cipher_iv.len,
4073 tdata->validCipherLenInBits.len,
4078 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4080 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4082 ut_params->obuf = ut_params->op->sym->m_dst;
4083 if (ut_params->obuf)
4084 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4086 ciphertext = plaintext;
4088 #ifdef RTE_APP_TEST_DEBUG
4089 rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4092 expected_ciphertext_shifted = rte_malloc(NULL, plaintext_len, 8);
4094 TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted,
4095 "failed to reserve memory for ciphertext shifted\n");
4097 memcpy(expected_ciphertext_shifted, tdata->ciphertext.data,
4098 ceil_byte_length(tdata->ciphertext.len));
4099 buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len,
4102 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
4104 expected_ciphertext_shifted,
4105 tdata->validDataLenInBits.len,
4107 "SNOW 3G Ciphertext data not as expected");
4111 static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
4113 struct crypto_testsuite_params *ts_params = &testsuite_params;
4114 struct crypto_unittest_params *ut_params = &unittest_params;
4118 uint8_t *plaintext, *ciphertext;
4119 unsigned ciphertext_pad_len;
4120 unsigned ciphertext_len;
4121 struct rte_cryptodev_info dev_info;
4123 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4124 uint64_t feat_flags = dev_info.feature_flags;
4126 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4127 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4128 printf("Device doesn't support RAW data-path APIs.\n");
4132 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4135 /* Verify the capabilities */
4136 struct rte_cryptodev_sym_capability_idx cap_idx;
4137 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4138 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4139 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4143 /* Create SNOW 3G session */
4144 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4145 RTE_CRYPTO_CIPHER_OP_DECRYPT,
4146 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4147 tdata->key.data, tdata->key.len,
4148 tdata->cipher_iv.len);
4152 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4154 /* Clear mbuf payload */
4155 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4156 rte_pktmbuf_tailroom(ut_params->ibuf));
4158 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4159 /* Append data which is padded to a multiple of */
4160 /* the algorithms block size */
4161 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4162 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4163 ciphertext_pad_len);
4164 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4166 debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4168 /* Create SNOW 3G operation */
4169 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4170 tdata->cipher_iv.len,
4171 tdata->validCipherLenInBits.len,
4172 tdata->cipher.offset_bits);
4176 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4177 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4178 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4180 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4182 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4183 ut_params->obuf = ut_params->op->sym->m_dst;
4184 if (ut_params->obuf)
4185 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4187 plaintext = ciphertext;
4189 debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4192 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4193 tdata->plaintext.data,
4194 tdata->validDataLenInBits.len,
4195 "SNOW 3G Plaintext data not as expected");
4199 static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
4201 struct crypto_testsuite_params *ts_params = &testsuite_params;
4202 struct crypto_unittest_params *ut_params = &unittest_params;
4206 uint8_t *plaintext, *ciphertext;
4207 unsigned ciphertext_pad_len;
4208 unsigned ciphertext_len;
4210 /* Verify the capabilities */
4211 struct rte_cryptodev_sym_capability_idx cap_idx;
4212 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4213 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4214 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4218 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4221 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4224 /* Create SNOW 3G session */
4225 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4226 RTE_CRYPTO_CIPHER_OP_DECRYPT,
4227 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4228 tdata->key.data, tdata->key.len,
4229 tdata->cipher_iv.len);
4233 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4234 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4236 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4237 "Failed to allocate input buffer");
4238 TEST_ASSERT_NOT_NULL(ut_params->obuf,
4239 "Failed to allocate output buffer");
4241 /* Clear mbuf payload */
4242 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4243 rte_pktmbuf_tailroom(ut_params->ibuf));
4245 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
4246 rte_pktmbuf_tailroom(ut_params->obuf));
4248 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4249 /* Append data which is padded to a multiple of */
4250 /* the algorithms block size */
4251 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4252 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4253 ciphertext_pad_len);
4254 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4255 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4257 debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4259 /* Create SNOW 3G operation */
4260 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4261 tdata->cipher_iv.len,
4262 tdata->validCipherLenInBits.len,
4267 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4269 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4270 ut_params->obuf = ut_params->op->sym->m_dst;
4271 if (ut_params->obuf)
4272 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4274 plaintext = ciphertext;
4276 debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4279 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4280 tdata->plaintext.data,
4281 tdata->validDataLenInBits.len,
4282 "SNOW 3G Plaintext data not as expected");
4287 test_zuc_cipher_auth(const struct wireless_test_data *tdata)
4289 struct crypto_testsuite_params *ts_params = &testsuite_params;
4290 struct crypto_unittest_params *ut_params = &unittest_params;
4294 uint8_t *plaintext, *ciphertext;
4295 unsigned int plaintext_pad_len;
4296 unsigned int plaintext_len;
4298 struct rte_cryptodev_info dev_info;
4299 struct rte_cryptodev_sym_capability_idx cap_idx;
4301 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4302 uint64_t feat_flags = dev_info.feature_flags;
4304 if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
4305 ((tdata->validAuthLenInBits.len % 8 != 0) ||
4306 (tdata->validDataLenInBits.len % 8 != 0))) {
4307 printf("Device doesn't support NON-Byte Aligned Data.\n");
4311 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4312 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4313 printf("Device doesn't support RAW data-path APIs.\n");
4317 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4320 /* Check if device supports ZUC EEA3 */
4321 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4322 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
4324 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4328 /* Check if device supports ZUC EIA3 */
4329 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4330 cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
4332 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4336 /* Create ZUC session */
4337 retval = create_zuc_cipher_auth_encrypt_generate_session(
4338 ts_params->valid_devs[0],
4342 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4344 /* clear mbuf payload */
4345 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4346 rte_pktmbuf_tailroom(ut_params->ibuf));
4348 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4349 /* Append data which is padded to a multiple of */
4350 /* the algorithms block size */
4351 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4352 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4354 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4356 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4358 /* Create ZUC operation */
4359 retval = create_zuc_cipher_hash_generate_operation(tdata);
4363 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4364 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4365 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4367 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4369 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4370 ut_params->obuf = ut_params->op->sym->m_src;
4371 if (ut_params->obuf)
4372 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4374 ciphertext = plaintext;
4376 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4378 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4380 tdata->ciphertext.data,
4381 tdata->validDataLenInBits.len,
4382 "ZUC Ciphertext data not as expected");
4384 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4385 + plaintext_pad_len;
4388 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4392 "ZUC Generated auth tag not as expected");
4397 test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
4399 struct crypto_testsuite_params *ts_params = &testsuite_params;
4400 struct crypto_unittest_params *ut_params = &unittest_params;
4404 uint8_t *plaintext, *ciphertext;
4405 unsigned plaintext_pad_len;
4406 unsigned plaintext_len;
4407 struct rte_cryptodev_info dev_info;
4409 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4410 uint64_t feat_flags = dev_info.feature_flags;
4412 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4413 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4414 printf("Device doesn't support RAW data-path APIs.\n");
4418 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4421 /* Verify the capabilities */
4422 struct rte_cryptodev_sym_capability_idx cap_idx;
4423 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4424 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
4425 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4428 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4429 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4430 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4434 /* Create SNOW 3G session */
4435 retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0],
4436 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4437 RTE_CRYPTO_AUTH_OP_GENERATE,
4438 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4439 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4440 tdata->key.data, tdata->key.len,
4441 tdata->auth_iv.len, tdata->digest.len,
4442 tdata->cipher_iv.len);
4445 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4447 /* clear mbuf payload */
4448 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4449 rte_pktmbuf_tailroom(ut_params->ibuf));
4451 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4452 /* Append data which is padded to a multiple of */
4453 /* the algorithms block size */
4454 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4455 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4457 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4459 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4461 /* Create SNOW 3G operation */
4462 retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
4463 tdata->digest.len, tdata->auth_iv.data,
4465 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
4466 tdata->cipher_iv.data, tdata->cipher_iv.len,
4467 tdata->validCipherLenInBits.len,
4469 tdata->validAuthLenInBits.len,
4475 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4476 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4477 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4479 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4481 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4482 ut_params->obuf = ut_params->op->sym->m_src;
4483 if (ut_params->obuf)
4484 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4486 ciphertext = plaintext;
4488 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4490 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4492 tdata->ciphertext.data,
4493 tdata->validDataLenInBits.len,
4494 "SNOW 3G Ciphertext data not as expected");
4496 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4497 + plaintext_pad_len;
4500 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4503 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4504 "SNOW 3G Generated auth tag not as expected");
4509 test_snow3g_auth_cipher(const struct snow3g_test_data *tdata,
4510 uint8_t op_mode, uint8_t verify)
4512 struct crypto_testsuite_params *ts_params = &testsuite_params;
4513 struct crypto_unittest_params *ut_params = &unittest_params;
4517 uint8_t *plaintext = NULL, *ciphertext = NULL;
4518 unsigned int plaintext_pad_len;
4519 unsigned int plaintext_len;
4520 unsigned int ciphertext_pad_len;
4521 unsigned int ciphertext_len;
4523 struct rte_cryptodev_info dev_info;
4525 /* Verify the capabilities */
4526 struct rte_cryptodev_sym_capability_idx cap_idx;
4527 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4528 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
4529 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4532 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4533 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4534 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4538 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4541 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4543 uint64_t feat_flags = dev_info.feature_flags;
4545 if (op_mode == OUT_OF_PLACE) {
4546 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
4547 printf("Device doesn't support digest encrypted.\n");
4550 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4554 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4555 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4556 printf("Device doesn't support RAW data-path APIs.\n");
4560 /* Create SNOW 3G session */
4561 retval = create_wireless_algo_auth_cipher_session(
4562 ts_params->valid_devs[0],
4563 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
4564 : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
4565 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
4566 : RTE_CRYPTO_AUTH_OP_GENERATE),
4567 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4568 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4569 tdata->key.data, tdata->key.len,
4570 tdata->auth_iv.len, tdata->digest.len,
4571 tdata->cipher_iv.len);
4576 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4577 if (op_mode == OUT_OF_PLACE)
4578 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4580 /* clear mbuf payload */
4581 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4582 rte_pktmbuf_tailroom(ut_params->ibuf));
4583 if (op_mode == OUT_OF_PLACE)
4584 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
4585 rte_pktmbuf_tailroom(ut_params->obuf));
4587 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4588 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4589 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4590 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4593 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4594 ciphertext_pad_len);
4595 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4596 if (op_mode == OUT_OF_PLACE)
4597 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4598 debug_hexdump(stdout, "ciphertext:", ciphertext,
4601 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4603 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4604 if (op_mode == OUT_OF_PLACE)
4605 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4606 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4609 /* Create SNOW 3G operation */
4610 retval = create_wireless_algo_auth_cipher_operation(
4611 tdata->digest.data, tdata->digest.len,
4612 tdata->cipher_iv.data, tdata->cipher_iv.len,
4613 tdata->auth_iv.data, tdata->auth_iv.len,
4614 (tdata->digest.offset_bytes == 0 ?
4615 (verify ? ciphertext_pad_len : plaintext_pad_len)
4616 : tdata->digest.offset_bytes),
4617 tdata->validCipherLenInBits.len,
4618 tdata->cipher.offset_bits,
4619 tdata->validAuthLenInBits.len,
4620 tdata->auth.offset_bits,
4621 op_mode, 0, verify);
4626 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4627 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4628 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4630 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4633 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4635 ut_params->obuf = (op_mode == IN_PLACE ?
4636 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
4639 if (ut_params->obuf)
4640 plaintext = rte_pktmbuf_mtod(ut_params->obuf,
4643 plaintext = ciphertext +
4644 (tdata->cipher.offset_bits >> 3);
4646 debug_hexdump(stdout, "plaintext:", plaintext,
4647 (tdata->plaintext.len >> 3) - tdata->digest.len);
4648 debug_hexdump(stdout, "plaintext expected:",
4649 tdata->plaintext.data,
4650 (tdata->plaintext.len >> 3) - tdata->digest.len);
4652 if (ut_params->obuf)
4653 ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
4656 ciphertext = plaintext;
4658 debug_hexdump(stdout, "ciphertext:", ciphertext,
4660 debug_hexdump(stdout, "ciphertext expected:",
4661 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
4663 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4664 + (tdata->digest.offset_bytes == 0 ?
4665 plaintext_pad_len : tdata->digest.offset_bytes);
4667 debug_hexdump(stdout, "digest:", ut_params->digest,
4669 debug_hexdump(stdout, "digest expected:", tdata->digest.data,
4675 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4677 tdata->plaintext.data,
4678 tdata->plaintext.len >> 3,
4679 "SNOW 3G Plaintext data not as expected");
4681 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4683 tdata->ciphertext.data,
4684 tdata->validDataLenInBits.len,
4685 "SNOW 3G Ciphertext data not as expected");
4687 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4690 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4691 "SNOW 3G Generated auth tag not as expected");
4697 test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata,
4698 uint8_t op_mode, uint8_t verify)
4700 struct crypto_testsuite_params *ts_params = &testsuite_params;
4701 struct crypto_unittest_params *ut_params = &unittest_params;
4705 const uint8_t *plaintext = NULL;
4706 const uint8_t *ciphertext = NULL;
4707 const uint8_t *digest = NULL;
4708 unsigned int plaintext_pad_len;
4709 unsigned int plaintext_len;
4710 unsigned int ciphertext_pad_len;
4711 unsigned int ciphertext_len;
4712 uint8_t buffer[10000];
4713 uint8_t digest_buffer[10000];
4715 struct rte_cryptodev_info dev_info;
4717 /* Verify the capabilities */
4718 struct rte_cryptodev_sym_capability_idx cap_idx;
4719 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4720 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
4721 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4724 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4725 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4726 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4730 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4733 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4735 uint64_t feat_flags = dev_info.feature_flags;
4737 if (op_mode == IN_PLACE) {
4738 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
4739 printf("Device doesn't support in-place scatter-gather "
4740 "in both input and output mbufs.\n");
4743 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4744 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4745 printf("Device doesn't support RAW data-path APIs.\n");
4749 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4751 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
4752 printf("Device doesn't support out-of-place scatter-gather "
4753 "in both input and output mbufs.\n");
4756 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
4757 printf("Device doesn't support digest encrypted.\n");
4762 /* Create SNOW 3G session */
4763 retval = create_wireless_algo_auth_cipher_session(
4764 ts_params->valid_devs[0],
4765 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
4766 : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
4767 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
4768 : RTE_CRYPTO_AUTH_OP_GENERATE),
4769 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4770 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4771 tdata->key.data, tdata->key.len,
4772 tdata->auth_iv.len, tdata->digest.len,
4773 tdata->cipher_iv.len);
4778 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4779 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4780 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4781 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4783 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
4784 plaintext_pad_len, 15, 0);
4785 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4786 "Failed to allocate input buffer in mempool");
4788 if (op_mode == OUT_OF_PLACE) {
4789 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
4790 plaintext_pad_len, 15, 0);
4791 TEST_ASSERT_NOT_NULL(ut_params->obuf,
4792 "Failed to allocate output buffer in mempool");
4796 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
4797 tdata->ciphertext.data);
4798 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
4799 ciphertext_len, buffer);
4800 debug_hexdump(stdout, "ciphertext:", ciphertext,
4803 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
4804 tdata->plaintext.data);
4805 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
4806 plaintext_len, buffer);
4807 debug_hexdump(stdout, "plaintext:", plaintext,
4810 memset(buffer, 0, sizeof(buffer));
4812 /* Create SNOW 3G operation */
4813 retval = create_wireless_algo_auth_cipher_operation(
4814 tdata->digest.data, tdata->digest.len,
4815 tdata->cipher_iv.data, tdata->cipher_iv.len,
4816 tdata->auth_iv.data, tdata->auth_iv.len,
4817 (tdata->digest.offset_bytes == 0 ?
4818 (verify ? ciphertext_pad_len : plaintext_pad_len)
4819 : tdata->digest.offset_bytes),
4820 tdata->validCipherLenInBits.len,
4821 tdata->cipher.offset_bits,
4822 tdata->validAuthLenInBits.len,
4823 tdata->auth.offset_bits,
4824 op_mode, 1, verify);
4829 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4830 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4831 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4833 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4836 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4838 ut_params->obuf = (op_mode == IN_PLACE ?
4839 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
4842 if (ut_params->obuf)
4843 plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
4844 plaintext_len, buffer);
4846 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
4847 plaintext_len, buffer);
4849 debug_hexdump(stdout, "plaintext:", plaintext,
4850 (tdata->plaintext.len >> 3) - tdata->digest.len);
4851 debug_hexdump(stdout, "plaintext expected:",
4852 tdata->plaintext.data,
4853 (tdata->plaintext.len >> 3) - tdata->digest.len);
4855 if (ut_params->obuf)
4856 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
4857 ciphertext_len, buffer);
4859 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
4860 ciphertext_len, buffer);
4862 debug_hexdump(stdout, "ciphertext:", ciphertext,
4864 debug_hexdump(stdout, "ciphertext expected:",
4865 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
4867 if (ut_params->obuf)
4868 digest = rte_pktmbuf_read(ut_params->obuf,
4869 (tdata->digest.offset_bytes == 0 ?
4870 plaintext_pad_len : tdata->digest.offset_bytes),
4871 tdata->digest.len, digest_buffer);
4873 digest = rte_pktmbuf_read(ut_params->ibuf,
4874 (tdata->digest.offset_bytes == 0 ?
4875 plaintext_pad_len : tdata->digest.offset_bytes),
4876 tdata->digest.len, digest_buffer);
4878 debug_hexdump(stdout, "digest:", digest,
4880 debug_hexdump(stdout, "digest expected:",
4881 tdata->digest.data, tdata->digest.len);
4886 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4888 tdata->plaintext.data,
4889 tdata->plaintext.len >> 3,
4890 "SNOW 3G Plaintext data not as expected");
4892 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4894 tdata->ciphertext.data,
4895 tdata->validDataLenInBits.len,
4896 "SNOW 3G Ciphertext data not as expected");
4898 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4901 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4902 "SNOW 3G Generated auth tag not as expected");
4908 test_kasumi_auth_cipher(const struct kasumi_test_data *tdata,
4909 uint8_t op_mode, uint8_t verify)
4911 struct crypto_testsuite_params *ts_params = &testsuite_params;
4912 struct crypto_unittest_params *ut_params = &unittest_params;
4916 uint8_t *plaintext = NULL, *ciphertext = NULL;
4917 unsigned int plaintext_pad_len;
4918 unsigned int plaintext_len;
4919 unsigned int ciphertext_pad_len;
4920 unsigned int ciphertext_len;
4922 struct rte_cryptodev_info dev_info;
4924 /* Verify the capabilities */
4925 struct rte_cryptodev_sym_capability_idx cap_idx;
4926 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4927 cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
4928 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4931 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4932 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
4933 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4937 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4939 uint64_t feat_flags = dev_info.feature_flags;
4941 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4942 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4943 printf("Device doesn't support RAW data-path APIs.\n");
4947 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4950 if (op_mode == OUT_OF_PLACE) {
4951 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4953 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
4954 printf("Device doesn't support digest encrypted.\n");
4959 /* Create KASUMI session */
4960 retval = create_wireless_algo_auth_cipher_session(
4961 ts_params->valid_devs[0],
4962 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
4963 : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
4964 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
4965 : RTE_CRYPTO_AUTH_OP_GENERATE),
4966 RTE_CRYPTO_AUTH_KASUMI_F9,
4967 RTE_CRYPTO_CIPHER_KASUMI_F8,
4968 tdata->key.data, tdata->key.len,
4969 0, tdata->digest.len,
4970 tdata->cipher_iv.len);
4975 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4976 if (op_mode == OUT_OF_PLACE)
4977 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4979 /* clear mbuf payload */
4980 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4981 rte_pktmbuf_tailroom(ut_params->ibuf));
4982 if (op_mode == OUT_OF_PLACE)
4983 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
4984 rte_pktmbuf_tailroom(ut_params->obuf));
4986 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4987 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4988 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4989 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4992 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4993 ciphertext_pad_len);
4994 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4995 if (op_mode == OUT_OF_PLACE)
4996 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4997 debug_hexdump(stdout, "ciphertext:", ciphertext,
5000 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5002 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5003 if (op_mode == OUT_OF_PLACE)
5004 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
5005 debug_hexdump(stdout, "plaintext:", plaintext,
5009 /* Create KASUMI operation */
5010 retval = create_wireless_algo_auth_cipher_operation(
5011 tdata->digest.data, tdata->digest.len,
5012 tdata->cipher_iv.data, tdata->cipher_iv.len,
5014 (tdata->digest.offset_bytes == 0 ?
5015 (verify ? ciphertext_pad_len : plaintext_pad_len)
5016 : tdata->digest.offset_bytes),
5017 tdata->validCipherLenInBits.len,
5018 tdata->validCipherOffsetInBits.len,
5019 tdata->validAuthLenInBits.len,
5021 op_mode, 0, verify);
5026 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5027 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5028 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5030 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5033 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5035 ut_params->obuf = (op_mode == IN_PLACE ?
5036 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5040 if (ut_params->obuf)
5041 plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5044 plaintext = ciphertext;
5046 debug_hexdump(stdout, "plaintext:", plaintext,
5047 (tdata->plaintext.len >> 3) - tdata->digest.len);
5048 debug_hexdump(stdout, "plaintext expected:",
5049 tdata->plaintext.data,
5050 (tdata->plaintext.len >> 3) - tdata->digest.len);
5052 if (ut_params->obuf)
5053 ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5056 ciphertext = plaintext;
5058 debug_hexdump(stdout, "ciphertext:", ciphertext,
5060 debug_hexdump(stdout, "ciphertext expected:",
5061 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5063 ut_params->digest = rte_pktmbuf_mtod(
5064 ut_params->obuf, uint8_t *) +
5065 (tdata->digest.offset_bytes == 0 ?
5066 plaintext_pad_len : tdata->digest.offset_bytes);
5068 debug_hexdump(stdout, "digest:", ut_params->digest,
5070 debug_hexdump(stdout, "digest expected:",
5071 tdata->digest.data, tdata->digest.len);
5076 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5078 tdata->plaintext.data,
5079 tdata->plaintext.len >> 3,
5080 "KASUMI Plaintext data not as expected");
5082 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5084 tdata->ciphertext.data,
5085 tdata->ciphertext.len >> 3,
5086 "KASUMI Ciphertext data not as expected");
5088 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5091 DIGEST_BYTE_LENGTH_KASUMI_F9,
5092 "KASUMI Generated auth tag not as expected");
5098 test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata,
5099 uint8_t op_mode, uint8_t verify)
5101 struct crypto_testsuite_params *ts_params = &testsuite_params;
5102 struct crypto_unittest_params *ut_params = &unittest_params;
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];
5116 struct rte_cryptodev_info dev_info;
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_KASUMI_F9;
5122 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5125 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5126 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5127 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5131 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5134 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5136 uint64_t feat_flags = dev_info.feature_flags;
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");
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");
5150 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
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");
5157 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5158 printf("Device doesn't support digest encrypted.\n");
5163 /* Create KASUMI 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_KASUMI_F9,
5171 RTE_CRYPTO_CIPHER_KASUMI_F8,
5172 tdata->key.data, tdata->key.len,
5173 0, tdata->digest.len,
5174 tdata->cipher_iv.len);
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);
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");
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");
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,
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,
5211 memset(buffer, 0, sizeof(buffer));
5213 /* Create KASUMI 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,
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->validCipherOffsetInBits.len,
5223 tdata->validAuthLenInBits.len,
5225 op_mode, 1, verify);
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);
5234 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5237 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5239 ut_params->obuf = (op_mode == IN_PLACE ?
5240 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5243 if (ut_params->obuf)
5244 plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
5245 plaintext_len, buffer);
5247 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5248 plaintext_len, buffer);
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);
5256 if (ut_params->obuf)
5257 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
5258 ciphertext_len, buffer);
5260 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5261 ciphertext_len, buffer);
5263 debug_hexdump(stdout, "ciphertext:", ciphertext,
5265 debug_hexdump(stdout, "ciphertext expected:",
5266 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
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);
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);
5279 debug_hexdump(stdout, "digest:", digest,
5281 debug_hexdump(stdout, "digest expected:",
5282 tdata->digest.data, tdata->digest.len);
5287 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5289 tdata->plaintext.data,
5290 tdata->plaintext.len >> 3,
5291 "KASUMI Plaintext data not as expected");
5293 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5295 tdata->ciphertext.data,
5296 tdata->validDataLenInBits.len,
5297 "KASUMI Ciphertext data not as expected");
5299 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5302 DIGEST_BYTE_LENGTH_KASUMI_F9,
5303 "KASUMI Generated auth tag not as expected");
5309 test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
5311 struct crypto_testsuite_params *ts_params = &testsuite_params;
5312 struct crypto_unittest_params *ut_params = &unittest_params;
5316 uint8_t *plaintext, *ciphertext;
5317 unsigned plaintext_pad_len;
5318 unsigned plaintext_len;
5319 struct rte_cryptodev_info dev_info;
5321 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5322 uint64_t feat_flags = dev_info.feature_flags;
5324 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5325 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5326 printf("Device doesn't support RAW data-path APIs.\n");
5330 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5333 /* Verify the capabilities */
5334 struct rte_cryptodev_sym_capability_idx cap_idx;
5335 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5336 cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5337 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5340 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5341 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5342 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5346 /* Create KASUMI session */
5347 retval = create_wireless_algo_cipher_auth_session(
5348 ts_params->valid_devs[0],
5349 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5350 RTE_CRYPTO_AUTH_OP_GENERATE,
5351 RTE_CRYPTO_AUTH_KASUMI_F9,
5352 RTE_CRYPTO_CIPHER_KASUMI_F8,
5353 tdata->key.data, tdata->key.len,
5354 0, tdata->digest.len,
5355 tdata->cipher_iv.len);
5359 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5361 /* clear mbuf payload */
5362 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5363 rte_pktmbuf_tailroom(ut_params->ibuf));
5365 plaintext_len = ceil_byte_length(tdata->plaintext.len);
5366 /* Append data which is padded to a multiple of */
5367 /* the algorithms block size */
5368 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5369 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5371 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5373 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5375 /* Create KASUMI operation */
5376 retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
5377 tdata->digest.len, NULL, 0,
5378 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
5379 tdata->cipher_iv.data, tdata->cipher_iv.len,
5380 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
5381 tdata->validCipherOffsetInBits.len,
5382 tdata->validAuthLenInBits.len,
5388 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5389 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5390 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5392 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5394 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5396 if (ut_params->op->sym->m_dst)
5397 ut_params->obuf = ut_params->op->sym->m_dst;
5399 ut_params->obuf = ut_params->op->sym->m_src;
5401 ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
5402 tdata->validCipherOffsetInBits.len >> 3);
5404 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5405 + plaintext_pad_len;
5407 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
5408 (tdata->validCipherOffsetInBits.len >> 3);
5410 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5412 reference_ciphertext,
5413 tdata->validCipherLenInBits.len,
5414 "KASUMI Ciphertext data not as expected");
5417 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5420 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5421 "KASUMI Generated auth tag not as expected");
5426 test_zuc_encryption(const struct wireless_test_data *tdata)
5428 struct crypto_testsuite_params *ts_params = &testsuite_params;
5429 struct crypto_unittest_params *ut_params = &unittest_params;
5432 uint8_t *plaintext, *ciphertext;
5433 unsigned plaintext_pad_len;
5434 unsigned plaintext_len;
5435 struct rte_cryptodev_info dev_info;
5437 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5438 uint64_t feat_flags = dev_info.feature_flags;
5440 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5441 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5442 printf("Device doesn't support RAW data-path APIs.\n");
5446 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5449 struct rte_cryptodev_sym_capability_idx cap_idx;
5451 /* Check if device supports ZUC EEA3 */
5452 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5453 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
5455 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5459 /* Create ZUC session */
5460 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
5461 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5462 RTE_CRYPTO_CIPHER_ZUC_EEA3,
5463 tdata->key.data, tdata->key.len,
5464 tdata->cipher_iv.len);
5468 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5470 /* Clear mbuf payload */
5471 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5472 rte_pktmbuf_tailroom(ut_params->ibuf));
5474 plaintext_len = ceil_byte_length(tdata->plaintext.len);
5475 /* Append data which is padded to a multiple */
5476 /* of the algorithms block size */
5477 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
5478 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5480 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5482 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5484 /* Create ZUC operation */
5485 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
5486 tdata->cipher_iv.len,
5487 tdata->plaintext.len,
5492 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5493 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5494 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
5496 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5498 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5500 ut_params->obuf = ut_params->op->sym->m_dst;
5501 if (ut_params->obuf)
5502 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
5504 ciphertext = plaintext;
5506 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
5509 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5511 tdata->ciphertext.data,
5512 tdata->validCipherLenInBits.len,
5513 "ZUC Ciphertext data not as expected");
5518 test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
5520 struct crypto_testsuite_params *ts_params = &testsuite_params;
5521 struct crypto_unittest_params *ut_params = &unittest_params;
5525 unsigned int plaintext_pad_len;
5526 unsigned int plaintext_len;
5527 const uint8_t *ciphertext;
5528 uint8_t ciphertext_buffer[2048];
5529 struct rte_cryptodev_info dev_info;
5531 struct rte_cryptodev_sym_capability_idx cap_idx;
5533 /* Check if device supports ZUC EEA3 */
5534 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5535 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
5537 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5541 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5544 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5546 uint64_t feat_flags = dev_info.feature_flags;
5548 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5549 printf("Device doesn't support in-place scatter-gather. "
5554 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5555 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5556 printf("Device doesn't support RAW data-path APIs.\n");
5560 plaintext_len = ceil_byte_length(tdata->plaintext.len);
5562 /* Append data which is padded to a multiple */
5563 /* of the algorithms block size */
5564 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
5566 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5567 plaintext_pad_len, 10, 0);
5569 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5570 tdata->plaintext.data);
5572 /* Create ZUC session */
5573 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
5574 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5575 RTE_CRYPTO_CIPHER_ZUC_EEA3,
5576 tdata->key.data, tdata->key.len,
5577 tdata->cipher_iv.len);
5581 /* Clear mbuf payload */
5583 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
5585 /* Create ZUC operation */
5586 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
5587 tdata->cipher_iv.len, tdata->plaintext.len,
5592 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5593 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5594 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
5596 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5598 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5600 ut_params->obuf = ut_params->op->sym->m_dst;
5601 if (ut_params->obuf)
5602 ciphertext = rte_pktmbuf_read(ut_params->obuf,
5603 0, plaintext_len, ciphertext_buffer);
5605 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
5606 0, plaintext_len, ciphertext_buffer);
5609 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
5612 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5614 tdata->ciphertext.data,
5615 tdata->validCipherLenInBits.len,
5616 "ZUC Ciphertext data not as expected");
5622 test_zuc_authentication(const struct wireless_test_data *tdata)
5624 struct crypto_testsuite_params *ts_params = &testsuite_params;
5625 struct crypto_unittest_params *ut_params = &unittest_params;
5628 unsigned plaintext_pad_len;
5629 unsigned plaintext_len;
5632 struct rte_cryptodev_sym_capability_idx cap_idx;
5633 struct rte_cryptodev_info dev_info;
5635 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5636 uint64_t feat_flags = dev_info.feature_flags;
5638 if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
5639 (tdata->validAuthLenInBits.len % 8 != 0)) {
5640 printf("Device doesn't support NON-Byte Aligned Data.\n");
5644 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5645 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5646 printf("Device doesn't support RAW data-path APIs.\n");
5650 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5653 /* Check if device supports ZUC EIA3 */
5654 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5655 cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
5657 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5661 /* Create ZUC session */
5662 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
5663 tdata->key.data, tdata->key.len,
5664 tdata->auth_iv.len, tdata->digest.len,
5665 RTE_CRYPTO_AUTH_OP_GENERATE,
5666 RTE_CRYPTO_AUTH_ZUC_EIA3);
5670 /* alloc mbuf and set payload */
5671 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5673 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5674 rte_pktmbuf_tailroom(ut_params->ibuf));
5676 plaintext_len = ceil_byte_length(tdata->plaintext.len);
5677 /* Append data which is padded to a multiple of */
5678 /* the algorithms block size */
5679 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
5680 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5682 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5684 /* Create ZUC operation */
5685 retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
5686 tdata->auth_iv.data, tdata->auth_iv.len,
5687 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
5688 tdata->validAuthLenInBits.len,
5693 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5694 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5695 ut_params->op, 0, 1, 1, 0);
5697 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5699 ut_params->obuf = ut_params->op->sym->m_src;
5700 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5701 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5702 + plaintext_pad_len;
5705 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5709 "ZUC Generated auth tag not as expected");
5715 test_zuc_auth_cipher(const struct wireless_test_data *tdata,
5716 uint8_t op_mode, uint8_t verify)
5718 struct crypto_testsuite_params *ts_params = &testsuite_params;
5719 struct crypto_unittest_params *ut_params = &unittest_params;
5723 uint8_t *plaintext = NULL, *ciphertext = NULL;
5724 unsigned int plaintext_pad_len;
5725 unsigned int plaintext_len;
5726 unsigned int ciphertext_pad_len;
5727 unsigned int ciphertext_len;
5729 struct rte_cryptodev_info dev_info;
5730 struct rte_cryptodev_sym_capability_idx cap_idx;
5732 /* Check if device supports ZUC EIA3 */
5733 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5734 cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
5736 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5740 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5742 uint64_t feat_flags = dev_info.feature_flags;
5744 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5745 printf("Device doesn't support digest encrypted.\n");
5748 if (op_mode == IN_PLACE) {
5749 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5750 printf("Device doesn't support in-place scatter-gather "
5751 "in both input and output mbufs.\n");
5755 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5756 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5757 printf("Device doesn't support RAW data-path APIs.\n");
5761 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5763 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5764 printf("Device doesn't support out-of-place scatter-gather "
5765 "in both input and output mbufs.\n");
5770 /* Create ZUC session */
5771 retval = create_wireless_algo_auth_cipher_session(
5772 ts_params->valid_devs[0],
5773 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5774 : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5775 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5776 : RTE_CRYPTO_AUTH_OP_GENERATE),
5777 RTE_CRYPTO_AUTH_ZUC_EIA3,
5778 RTE_CRYPTO_CIPHER_ZUC_EEA3,
5779 tdata->key.data, tdata->key.len,
5780 tdata->auth_iv.len, tdata->digest.len,
5781 tdata->cipher_iv.len);
5786 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5787 if (op_mode == OUT_OF_PLACE)
5788 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5790 /* clear mbuf payload */
5791 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5792 rte_pktmbuf_tailroom(ut_params->ibuf));
5793 if (op_mode == OUT_OF_PLACE)
5794 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5795 rte_pktmbuf_tailroom(ut_params->obuf));
5797 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5798 plaintext_len = ceil_byte_length(tdata->plaintext.len);
5799 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5800 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5803 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5804 ciphertext_pad_len);
5805 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
5806 if (op_mode == OUT_OF_PLACE)
5807 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
5808 debug_hexdump(stdout, "ciphertext:", ciphertext,
5811 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5813 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5814 if (op_mode == OUT_OF_PLACE)
5815 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
5816 debug_hexdump(stdout, "plaintext:", plaintext,
5820 /* Create ZUC operation */
5821 retval = create_wireless_algo_auth_cipher_operation(
5822 tdata->digest.data, tdata->digest.len,
5823 tdata->cipher_iv.data, tdata->cipher_iv.len,
5824 tdata->auth_iv.data, tdata->auth_iv.len,
5825 (tdata->digest.offset_bytes == 0 ?
5826 (verify ? ciphertext_pad_len : plaintext_pad_len)
5827 : tdata->digest.offset_bytes),
5828 tdata->validCipherLenInBits.len,
5829 tdata->validCipherOffsetInBits.len,
5830 tdata->validAuthLenInBits.len,
5832 op_mode, 0, verify);
5837 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5838 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5839 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5841 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5844 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5846 ut_params->obuf = (op_mode == IN_PLACE ?
5847 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5851 if (ut_params->obuf)
5852 plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5855 plaintext = ciphertext;
5857 debug_hexdump(stdout, "plaintext:", plaintext,
5858 (tdata->plaintext.len >> 3) - tdata->digest.len);
5859 debug_hexdump(stdout, "plaintext expected:",
5860 tdata->plaintext.data,
5861 (tdata->plaintext.len >> 3) - tdata->digest.len);
5863 if (ut_params->obuf)
5864 ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5867 ciphertext = plaintext;
5869 debug_hexdump(stdout, "ciphertext:", ciphertext,
5871 debug_hexdump(stdout, "ciphertext expected:",
5872 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5874 ut_params->digest = rte_pktmbuf_mtod(
5875 ut_params->obuf, uint8_t *) +
5876 (tdata->digest.offset_bytes == 0 ?
5877 plaintext_pad_len : tdata->digest.offset_bytes);
5879 debug_hexdump(stdout, "digest:", ut_params->digest,
5881 debug_hexdump(stdout, "digest expected:",
5882 tdata->digest.data, tdata->digest.len);
5887 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5889 tdata->plaintext.data,
5890 tdata->plaintext.len >> 3,
5891 "ZUC Plaintext data not as expected");
5893 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5895 tdata->ciphertext.data,
5896 tdata->ciphertext.len >> 3,
5897 "ZUC Ciphertext data not as expected");
5899 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5902 DIGEST_BYTE_LENGTH_KASUMI_F9,
5903 "ZUC Generated auth tag not as expected");
5909 test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata,
5910 uint8_t op_mode, uint8_t verify)
5912 struct crypto_testsuite_params *ts_params = &testsuite_params;
5913 struct crypto_unittest_params *ut_params = &unittest_params;
5917 const uint8_t *plaintext = NULL;
5918 const uint8_t *ciphertext = NULL;
5919 const uint8_t *digest = NULL;
5920 unsigned int plaintext_pad_len;
5921 unsigned int plaintext_len;
5922 unsigned int ciphertext_pad_len;
5923 unsigned int ciphertext_len;
5924 uint8_t buffer[10000];
5925 uint8_t digest_buffer[10000];
5927 struct rte_cryptodev_info dev_info;
5928 struct rte_cryptodev_sym_capability_idx cap_idx;
5930 /* Check if device supports ZUC EIA3 */
5931 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5932 cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
5934 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5938 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5940 uint64_t feat_flags = dev_info.feature_flags;
5942 if (op_mode == IN_PLACE) {
5943 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5944 printf("Device doesn't support in-place scatter-gather "
5945 "in both input and output mbufs.\n");
5949 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5950 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5951 printf("Device doesn't support RAW data-path APIs.\n");
5955 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5957 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5958 printf("Device doesn't support out-of-place scatter-gather "
5959 "in both input and output mbufs.\n");
5962 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5963 printf("Device doesn't support digest encrypted.\n");
5968 /* Create ZUC session */
5969 retval = create_wireless_algo_auth_cipher_session(
5970 ts_params->valid_devs[0],
5971 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5972 : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5973 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5974 : RTE_CRYPTO_AUTH_OP_GENERATE),
5975 RTE_CRYPTO_AUTH_ZUC_EIA3,
5976 RTE_CRYPTO_CIPHER_ZUC_EEA3,
5977 tdata->key.data, tdata->key.len,
5978 tdata->auth_iv.len, tdata->digest.len,
5979 tdata->cipher_iv.len);
5984 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5985 plaintext_len = ceil_byte_length(tdata->plaintext.len);
5986 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5987 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5989 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5990 plaintext_pad_len, 15, 0);
5991 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5992 "Failed to allocate input buffer in mempool");
5994 if (op_mode == OUT_OF_PLACE) {
5995 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5996 plaintext_pad_len, 15, 0);
5997 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5998 "Failed to allocate output buffer in mempool");
6002 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
6003 tdata->ciphertext.data);
6004 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6005 ciphertext_len, buffer);
6006 debug_hexdump(stdout, "ciphertext:", ciphertext,
6009 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
6010 tdata->plaintext.data);
6011 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6012 plaintext_len, buffer);
6013 debug_hexdump(stdout, "plaintext:", plaintext,
6016 memset(buffer, 0, sizeof(buffer));
6018 /* Create ZUC operation */
6019 retval = create_wireless_algo_auth_cipher_operation(
6020 tdata->digest.data, tdata->digest.len,
6021 tdata->cipher_iv.data, tdata->cipher_iv.len,
6023 (tdata->digest.offset_bytes == 0 ?
6024 (verify ? ciphertext_pad_len : plaintext_pad_len)
6025 : tdata->digest.offset_bytes),
6026 tdata->validCipherLenInBits.len,
6027 tdata->validCipherOffsetInBits.len,
6028 tdata->validAuthLenInBits.len,
6030 op_mode, 1, verify);
6035 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6036 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6037 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
6039 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6042 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6044 ut_params->obuf = (op_mode == IN_PLACE ?
6045 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6048 if (ut_params->obuf)
6049 plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
6050 plaintext_len, buffer);
6052 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6053 plaintext_len, buffer);
6055 debug_hexdump(stdout, "plaintext:", plaintext,
6056 (tdata->plaintext.len >> 3) - tdata->digest.len);
6057 debug_hexdump(stdout, "plaintext expected:",
6058 tdata->plaintext.data,
6059 (tdata->plaintext.len >> 3) - tdata->digest.len);
6061 if (ut_params->obuf)
6062 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
6063 ciphertext_len, buffer);
6065 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6066 ciphertext_len, buffer);
6068 debug_hexdump(stdout, "ciphertext:", ciphertext,
6070 debug_hexdump(stdout, "ciphertext expected:",
6071 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
6073 if (ut_params->obuf)
6074 digest = rte_pktmbuf_read(ut_params->obuf,
6075 (tdata->digest.offset_bytes == 0 ?
6076 plaintext_pad_len : tdata->digest.offset_bytes),
6077 tdata->digest.len, digest_buffer);
6079 digest = rte_pktmbuf_read(ut_params->ibuf,
6080 (tdata->digest.offset_bytes == 0 ?
6081 plaintext_pad_len : tdata->digest.offset_bytes),
6082 tdata->digest.len, digest_buffer);
6084 debug_hexdump(stdout, "digest:", digest,
6086 debug_hexdump(stdout, "digest expected:",
6087 tdata->digest.data, tdata->digest.len);
6092 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6094 tdata->plaintext.data,
6095 tdata->plaintext.len >> 3,
6096 "ZUC Plaintext data not as expected");
6098 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6100 tdata->ciphertext.data,
6101 tdata->validDataLenInBits.len,
6102 "ZUC Ciphertext data not as expected");
6104 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6107 DIGEST_BYTE_LENGTH_KASUMI_F9,
6108 "ZUC Generated auth tag not as expected");
6114 test_kasumi_encryption_test_case_1(void)
6116 return test_kasumi_encryption(&kasumi_test_case_1);
6120 test_kasumi_encryption_test_case_1_sgl(void)
6122 return test_kasumi_encryption_sgl(&kasumi_test_case_1);
6126 test_kasumi_encryption_test_case_1_oop(void)
6128 return test_kasumi_encryption_oop(&kasumi_test_case_1);
6132 test_kasumi_encryption_test_case_1_oop_sgl(void)
6134 return test_kasumi_encryption_oop_sgl(&kasumi_test_case_1);
6138 test_kasumi_encryption_test_case_2(void)
6140 return test_kasumi_encryption(&kasumi_test_case_2);
6144 test_kasumi_encryption_test_case_3(void)
6146 return test_kasumi_encryption(&kasumi_test_case_3);
6150 test_kasumi_encryption_test_case_4(void)
6152 return test_kasumi_encryption(&kasumi_test_case_4);
6156 test_kasumi_encryption_test_case_5(void)
6158 return test_kasumi_encryption(&kasumi_test_case_5);
6162 test_kasumi_decryption_test_case_1(void)
6164 return test_kasumi_decryption(&kasumi_test_case_1);
6168 test_kasumi_decryption_test_case_1_oop(void)
6170 return test_kasumi_decryption_oop(&kasumi_test_case_1);
6174 test_kasumi_decryption_test_case_2(void)
6176 return test_kasumi_decryption(&kasumi_test_case_2);
6180 test_kasumi_decryption_test_case_3(void)
6182 /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6183 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6185 return test_kasumi_decryption(&kasumi_test_case_3);
6189 test_kasumi_decryption_test_case_4(void)
6191 return test_kasumi_decryption(&kasumi_test_case_4);
6195 test_kasumi_decryption_test_case_5(void)
6197 return test_kasumi_decryption(&kasumi_test_case_5);
6200 test_snow3g_encryption_test_case_1(void)
6202 return test_snow3g_encryption(&snow3g_test_case_1);
6206 test_snow3g_encryption_test_case_1_oop(void)
6208 return test_snow3g_encryption_oop(&snow3g_test_case_1);
6212 test_snow3g_encryption_test_case_1_oop_sgl(void)
6214 return test_snow3g_encryption_oop_sgl(&snow3g_test_case_1);
6219 test_snow3g_encryption_test_case_1_offset_oop(void)
6221 return test_snow3g_encryption_offset_oop(&snow3g_test_case_1);
6225 test_snow3g_encryption_test_case_2(void)
6227 return test_snow3g_encryption(&snow3g_test_case_2);
6231 test_snow3g_encryption_test_case_3(void)
6233 return test_snow3g_encryption(&snow3g_test_case_3);
6237 test_snow3g_encryption_test_case_4(void)
6239 return test_snow3g_encryption(&snow3g_test_case_4);
6243 test_snow3g_encryption_test_case_5(void)
6245 return test_snow3g_encryption(&snow3g_test_case_5);
6249 test_snow3g_decryption_test_case_1(void)
6251 return test_snow3g_decryption(&snow3g_test_case_1);
6255 test_snow3g_decryption_test_case_1_oop(void)
6257 return test_snow3g_decryption_oop(&snow3g_test_case_1);
6261 test_snow3g_decryption_test_case_2(void)
6263 return test_snow3g_decryption(&snow3g_test_case_2);
6267 test_snow3g_decryption_test_case_3(void)
6269 return test_snow3g_decryption(&snow3g_test_case_3);
6273 test_snow3g_decryption_test_case_4(void)
6275 return test_snow3g_decryption(&snow3g_test_case_4);
6279 test_snow3g_decryption_test_case_5(void)
6281 return test_snow3g_decryption(&snow3g_test_case_5);
6285 * Function prepares snow3g_hash_test_data from snow3g_test_data.
6286 * Pattern digest from snow3g_test_data must be allocated as
6287 * 4 last bytes in plaintext.
6290 snow3g_hash_test_vector_setup(const struct snow3g_test_data *pattern,
6291 struct snow3g_hash_test_data *output)
6293 if ((pattern != NULL) && (output != NULL)) {
6294 output->key.len = pattern->key.len;
6296 memcpy(output->key.data,
6297 pattern->key.data, pattern->key.len);
6299 output->auth_iv.len = pattern->auth_iv.len;
6301 memcpy(output->auth_iv.data,
6302 pattern->auth_iv.data, pattern->auth_iv.len);
6304 output->plaintext.len = pattern->plaintext.len;
6306 memcpy(output->plaintext.data,
6307 pattern->plaintext.data, pattern->plaintext.len >> 3);
6309 output->digest.len = pattern->digest.len;
6311 memcpy(output->digest.data,
6312 &pattern->plaintext.data[pattern->digest.offset_bytes],
6313 pattern->digest.len);
6315 output->validAuthLenInBits.len =
6316 pattern->validAuthLenInBits.len;
6321 * Test case verify computed cipher and digest from snow3g_test_case_7 data.
6324 test_snow3g_decryption_with_digest_test_case_1(void)
6326 struct snow3g_hash_test_data snow3g_hash_data;
6329 * Function prepare data for hash veryfication test case.
6330 * Digest is allocated in 4 last bytes in plaintext, pattern.
6332 snow3g_hash_test_vector_setup(&snow3g_test_case_7, &snow3g_hash_data);
6334 return test_snow3g_decryption(&snow3g_test_case_7) &
6335 test_snow3g_authentication_verify(&snow3g_hash_data);
6339 test_snow3g_cipher_auth_test_case_1(void)
6341 return test_snow3g_cipher_auth(&snow3g_test_case_3);
6345 test_snow3g_auth_cipher_test_case_1(void)
6347 return test_snow3g_auth_cipher(
6348 &snow3g_auth_cipher_test_case_1, IN_PLACE, 0);
6352 test_snow3g_auth_cipher_test_case_2(void)
6354 return test_snow3g_auth_cipher(
6355 &snow3g_auth_cipher_test_case_2, IN_PLACE, 0);
6359 test_snow3g_auth_cipher_test_case_2_oop(void)
6361 return test_snow3g_auth_cipher(
6362 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
6366 test_snow3g_auth_cipher_part_digest_enc(void)
6368 return test_snow3g_auth_cipher(
6369 &snow3g_auth_cipher_partial_digest_encryption,
6374 test_snow3g_auth_cipher_part_digest_enc_oop(void)
6376 return test_snow3g_auth_cipher(
6377 &snow3g_auth_cipher_partial_digest_encryption,
6382 test_snow3g_auth_cipher_test_case_3_sgl(void)
6384 /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6385 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6387 return test_snow3g_auth_cipher_sgl(
6388 &snow3g_auth_cipher_test_case_3, IN_PLACE, 0);
6392 test_snow3g_auth_cipher_test_case_3_oop_sgl(void)
6394 return test_snow3g_auth_cipher_sgl(
6395 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 0);
6399 test_snow3g_auth_cipher_part_digest_enc_sgl(void)
6401 /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6402 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6404 return test_snow3g_auth_cipher_sgl(
6405 &snow3g_auth_cipher_partial_digest_encryption,
6410 test_snow3g_auth_cipher_part_digest_enc_oop_sgl(void)
6412 return test_snow3g_auth_cipher_sgl(
6413 &snow3g_auth_cipher_partial_digest_encryption,
6418 test_snow3g_auth_cipher_verify_test_case_1(void)
6420 return test_snow3g_auth_cipher(
6421 &snow3g_auth_cipher_test_case_1, IN_PLACE, 1);
6425 test_snow3g_auth_cipher_verify_test_case_2(void)
6427 return test_snow3g_auth_cipher(
6428 &snow3g_auth_cipher_test_case_2, IN_PLACE, 1);
6432 test_snow3g_auth_cipher_verify_test_case_2_oop(void)
6434 return test_snow3g_auth_cipher(
6435 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
6439 test_snow3g_auth_cipher_verify_part_digest_enc(void)
6441 return test_snow3g_auth_cipher(
6442 &snow3g_auth_cipher_partial_digest_encryption,
6447 test_snow3g_auth_cipher_verify_part_digest_enc_oop(void)
6449 return test_snow3g_auth_cipher(
6450 &snow3g_auth_cipher_partial_digest_encryption,
6455 test_snow3g_auth_cipher_verify_test_case_3_sgl(void)
6457 return test_snow3g_auth_cipher_sgl(
6458 &snow3g_auth_cipher_test_case_3, IN_PLACE, 1);
6462 test_snow3g_auth_cipher_verify_test_case_3_oop_sgl(void)
6464 return test_snow3g_auth_cipher_sgl(
6465 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 1);
6469 test_snow3g_auth_cipher_verify_part_digest_enc_sgl(void)
6471 return test_snow3g_auth_cipher_sgl(
6472 &snow3g_auth_cipher_partial_digest_encryption,
6477 test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl(void)
6479 return test_snow3g_auth_cipher_sgl(
6480 &snow3g_auth_cipher_partial_digest_encryption,
6485 test_snow3g_auth_cipher_with_digest_test_case_1(void)
6487 return test_snow3g_auth_cipher(
6488 &snow3g_test_case_7, IN_PLACE, 0);
6492 test_kasumi_auth_cipher_test_case_1(void)
6494 return test_kasumi_auth_cipher(
6495 &kasumi_test_case_3, IN_PLACE, 0);
6499 test_kasumi_auth_cipher_test_case_2(void)
6501 return test_kasumi_auth_cipher(
6502 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
6506 test_kasumi_auth_cipher_test_case_2_oop(void)
6508 return test_kasumi_auth_cipher(
6509 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
6513 test_kasumi_auth_cipher_test_case_2_sgl(void)
6515 return test_kasumi_auth_cipher_sgl(
6516 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
6520 test_kasumi_auth_cipher_test_case_2_oop_sgl(void)
6522 return test_kasumi_auth_cipher_sgl(
6523 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
6527 test_kasumi_auth_cipher_verify_test_case_1(void)
6529 return test_kasumi_auth_cipher(
6530 &kasumi_test_case_3, IN_PLACE, 1);
6534 test_kasumi_auth_cipher_verify_test_case_2(void)
6536 return test_kasumi_auth_cipher(
6537 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
6541 test_kasumi_auth_cipher_verify_test_case_2_oop(void)
6543 return test_kasumi_auth_cipher(
6544 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
6548 test_kasumi_auth_cipher_verify_test_case_2_sgl(void)
6550 return test_kasumi_auth_cipher_sgl(
6551 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
6555 test_kasumi_auth_cipher_verify_test_case_2_oop_sgl(void)
6557 return test_kasumi_auth_cipher_sgl(
6558 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
6562 test_kasumi_cipher_auth_test_case_1(void)
6564 return test_kasumi_cipher_auth(&kasumi_test_case_6);
6568 test_zuc_encryption_test_case_1(void)
6570 return test_zuc_encryption(&zuc_test_case_cipher_193b);
6574 test_zuc_encryption_test_case_2(void)
6576 return test_zuc_encryption(&zuc_test_case_cipher_800b);
6580 test_zuc_encryption_test_case_3(void)
6582 return test_zuc_encryption(&zuc_test_case_cipher_1570b);
6586 test_zuc_encryption_test_case_4(void)
6588 return test_zuc_encryption(&zuc_test_case_cipher_2798b);
6592 test_zuc_encryption_test_case_5(void)
6594 return test_zuc_encryption(&zuc_test_case_cipher_4019b);
6598 test_zuc_encryption_test_case_6_sgl(void)
6600 return test_zuc_encryption_sgl(&zuc_test_case_cipher_193b);
6604 test_zuc_hash_generate_test_case_1(void)
6606 return test_zuc_authentication(&zuc_test_case_auth_1b);
6610 test_zuc_hash_generate_test_case_2(void)
6612 return test_zuc_authentication(&zuc_test_case_auth_90b);
6616 test_zuc_hash_generate_test_case_3(void)
6618 return test_zuc_authentication(&zuc_test_case_auth_577b);
6622 test_zuc_hash_generate_test_case_4(void)
6624 return test_zuc_authentication(&zuc_test_case_auth_2079b);
6628 test_zuc_hash_generate_test_case_5(void)
6630 return test_zuc_authentication(&zuc_test_auth_5670b);
6634 test_zuc_hash_generate_test_case_6(void)
6636 return test_zuc_authentication(&zuc_test_case_auth_128b);
6640 test_zuc_hash_generate_test_case_7(void)
6642 return test_zuc_authentication(&zuc_test_case_auth_2080b);
6646 test_zuc_hash_generate_test_case_8(void)
6648 return test_zuc_authentication(&zuc_test_case_auth_584b);
6652 test_zuc_cipher_auth_test_case_1(void)
6654 return test_zuc_cipher_auth(&zuc_test_case_cipher_200b_auth_200b);
6658 test_zuc_cipher_auth_test_case_2(void)
6660 return test_zuc_cipher_auth(&zuc_test_case_cipher_800b_auth_120b);
6664 test_zuc_auth_cipher_test_case_1(void)
6666 return test_zuc_auth_cipher(
6667 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
6671 test_zuc_auth_cipher_test_case_1_oop(void)
6673 return test_zuc_auth_cipher(
6674 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
6678 test_zuc_auth_cipher_test_case_1_sgl(void)
6680 return test_zuc_auth_cipher_sgl(
6681 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
6685 test_zuc_auth_cipher_test_case_1_oop_sgl(void)
6687 return test_zuc_auth_cipher_sgl(
6688 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
6692 test_zuc_auth_cipher_verify_test_case_1(void)
6694 return test_zuc_auth_cipher(
6695 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
6699 test_zuc_auth_cipher_verify_test_case_1_oop(void)
6701 return test_zuc_auth_cipher(
6702 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
6706 test_zuc_auth_cipher_verify_test_case_1_sgl(void)
6708 return test_zuc_auth_cipher_sgl(
6709 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
6713 test_zuc_auth_cipher_verify_test_case_1_oop_sgl(void)
6715 return test_zuc_auth_cipher_sgl(
6716 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
6720 test_mixed_check_if_unsupported(const struct mixed_cipher_auth_test_data *tdata)
6722 uint8_t dev_id = testsuite_params.valid_devs[0];
6724 struct rte_cryptodev_sym_capability_idx cap_idx;
6726 /* Check if device supports particular cipher algorithm */
6727 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
6728 cap_idx.algo.cipher = tdata->cipher_algo;
6729 if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
6732 /* Check if device supports particular hash algorithm */
6733 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6734 cap_idx.algo.auth = tdata->auth_algo;
6735 if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
6742 test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata,
6743 uint8_t op_mode, uint8_t verify)
6745 struct crypto_testsuite_params *ts_params = &testsuite_params;
6746 struct crypto_unittest_params *ut_params = &unittest_params;
6750 uint8_t *plaintext = NULL, *ciphertext = NULL;
6751 unsigned int plaintext_pad_len;
6752 unsigned int plaintext_len;
6753 unsigned int ciphertext_pad_len;
6754 unsigned int ciphertext_len;
6756 struct rte_cryptodev_info dev_info;
6757 struct rte_crypto_op *op;
6759 /* Check if device supports particular algorithms separately */
6760 if (test_mixed_check_if_unsupported(tdata))
6762 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6765 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6767 uint64_t feat_flags = dev_info.feature_flags;
6769 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6770 printf("Device doesn't support digest encrypted.\n");
6774 /* Create the session */
6776 retval = create_wireless_algo_cipher_auth_session(
6777 ts_params->valid_devs[0],
6778 RTE_CRYPTO_CIPHER_OP_DECRYPT,
6779 RTE_CRYPTO_AUTH_OP_VERIFY,
6782 tdata->auth_key.data, tdata->auth_key.len,
6783 tdata->auth_iv.len, tdata->digest_enc.len,
6784 tdata->cipher_iv.len);
6786 retval = create_wireless_algo_auth_cipher_session(
6787 ts_params->valid_devs[0],
6788 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
6789 RTE_CRYPTO_AUTH_OP_GENERATE,
6792 tdata->auth_key.data, tdata->auth_key.len,
6793 tdata->auth_iv.len, tdata->digest_enc.len,
6794 tdata->cipher_iv.len);
6798 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6799 if (op_mode == OUT_OF_PLACE)
6800 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6802 /* clear mbuf payload */
6803 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6804 rte_pktmbuf_tailroom(ut_params->ibuf));
6805 if (op_mode == OUT_OF_PLACE) {
6807 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
6808 rte_pktmbuf_tailroom(ut_params->obuf));
6811 ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
6812 plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
6813 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6814 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6817 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6818 ciphertext_pad_len);
6819 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
6820 if (op_mode == OUT_OF_PLACE)
6821 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
6822 debug_hexdump(stdout, "ciphertext:", ciphertext,
6825 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6827 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6828 if (op_mode == OUT_OF_PLACE)
6829 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
6830 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
6833 /* Create the operation */
6834 retval = create_wireless_algo_auth_cipher_operation(
6835 tdata->digest_enc.data, tdata->digest_enc.len,
6836 tdata->cipher_iv.data, tdata->cipher_iv.len,
6837 tdata->auth_iv.data, tdata->auth_iv.len,
6838 (tdata->digest_enc.offset == 0 ?
6840 : tdata->digest_enc.offset),
6841 tdata->validCipherLen.len_bits,
6842 tdata->cipher.offset_bits,
6843 tdata->validAuthLen.len_bits,
6844 tdata->auth.offset_bits,
6845 op_mode, 0, verify);
6850 op = process_crypto_request(ts_params->valid_devs[0], ut_params->op);
6852 /* Check if the op failed because the device doesn't */
6853 /* support this particular combination of algorithms */
6854 if (op == NULL && ut_params->op->status ==
6855 RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
6856 printf("Device doesn't support this mixed combination. "
6862 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6864 ut_params->obuf = (op_mode == IN_PLACE ?
6865 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6868 if (ut_params->obuf)
6869 plaintext = rte_pktmbuf_mtod(ut_params->obuf,
6872 plaintext = ciphertext +
6873 (tdata->cipher.offset_bits >> 3);
6875 debug_hexdump(stdout, "plaintext:", plaintext,
6876 tdata->plaintext.len_bits >> 3);
6877 debug_hexdump(stdout, "plaintext expected:",
6878 tdata->plaintext.data,
6879 tdata->plaintext.len_bits >> 3);
6881 if (ut_params->obuf)
6882 ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
6885 ciphertext = plaintext;
6887 debug_hexdump(stdout, "ciphertext:", ciphertext,
6889 debug_hexdump(stdout, "ciphertext expected:",
6890 tdata->ciphertext.data,
6891 tdata->ciphertext.len_bits >> 3);
6893 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
6894 + (tdata->digest_enc.offset == 0 ?
6895 plaintext_pad_len : tdata->digest_enc.offset);
6897 debug_hexdump(stdout, "digest:", ut_params->digest,
6898 tdata->digest_enc.len);
6899 debug_hexdump(stdout, "digest expected:",
6900 tdata->digest_enc.data,
6901 tdata->digest_enc.len);
6906 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6908 tdata->plaintext.data,
6909 tdata->plaintext.len_bits >> 3,
6910 "Plaintext data not as expected");
6912 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6914 tdata->ciphertext.data,
6915 tdata->validDataLen.len_bits,
6916 "Ciphertext data not as expected");
6918 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6920 tdata->digest_enc.data,
6921 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
6922 "Generated auth tag not as expected");
6925 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6926 "crypto op processing failed");
6932 test_mixed_auth_cipher_sgl(const struct mixed_cipher_auth_test_data *tdata,
6933 uint8_t op_mode, uint8_t verify)
6935 struct crypto_testsuite_params *ts_params = &testsuite_params;
6936 struct crypto_unittest_params *ut_params = &unittest_params;
6940 const uint8_t *plaintext = NULL;
6941 const uint8_t *ciphertext = NULL;
6942 const uint8_t *digest = NULL;
6943 unsigned int plaintext_pad_len;
6944 unsigned int plaintext_len;
6945 unsigned int ciphertext_pad_len;
6946 unsigned int ciphertext_len;
6947 uint8_t buffer[10000];
6948 uint8_t digest_buffer[10000];
6950 struct rte_cryptodev_info dev_info;
6951 struct rte_crypto_op *op;
6953 /* Check if device supports particular algorithms */
6954 if (test_mixed_check_if_unsupported(tdata))
6956 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6959 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6961 uint64_t feat_flags = dev_info.feature_flags;
6963 if (op_mode == IN_PLACE) {
6964 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6965 printf("Device doesn't support in-place scatter-gather "
6966 "in both input and output mbufs.\n");
6970 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
6971 printf("Device doesn't support out-of-place scatter-gather "
6972 "in both input and output mbufs.\n");
6975 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6976 printf("Device doesn't support digest encrypted.\n");
6981 /* Create the session */
6983 retval = create_wireless_algo_cipher_auth_session(
6984 ts_params->valid_devs[0],
6985 RTE_CRYPTO_CIPHER_OP_DECRYPT,
6986 RTE_CRYPTO_AUTH_OP_VERIFY,
6989 tdata->auth_key.data, tdata->auth_key.len,
6990 tdata->auth_iv.len, tdata->digest_enc.len,
6991 tdata->cipher_iv.len);
6993 retval = create_wireless_algo_auth_cipher_session(
6994 ts_params->valid_devs[0],
6995 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
6996 RTE_CRYPTO_AUTH_OP_GENERATE,
6999 tdata->auth_key.data, tdata->auth_key.len,
7000 tdata->auth_iv.len, tdata->digest_enc.len,
7001 tdata->cipher_iv.len);
7005 ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
7006 plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
7007 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
7008 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
7010 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
7011 ciphertext_pad_len, 15, 0);
7012 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
7013 "Failed to allocate input buffer in mempool");
7015 if (op_mode == OUT_OF_PLACE) {
7016 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
7017 plaintext_pad_len, 15, 0);
7018 TEST_ASSERT_NOT_NULL(ut_params->obuf,
7019 "Failed to allocate output buffer in mempool");
7023 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
7024 tdata->ciphertext.data);
7025 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
7026 ciphertext_len, buffer);
7027 debug_hexdump(stdout, "ciphertext:", ciphertext,
7030 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
7031 tdata->plaintext.data);
7032 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
7033 plaintext_len, buffer);
7034 debug_hexdump(stdout, "plaintext:", plaintext,
7037 memset(buffer, 0, sizeof(buffer));
7039 /* Create the operation */
7040 retval = create_wireless_algo_auth_cipher_operation(
7041 tdata->digest_enc.data, tdata->digest_enc.len,
7042 tdata->cipher_iv.data, tdata->cipher_iv.len,
7043 tdata->auth_iv.data, tdata->auth_iv.len,
7044 (tdata->digest_enc.offset == 0 ?
7046 : tdata->digest_enc.offset),
7047 tdata->validCipherLen.len_bits,
7048 tdata->cipher.offset_bits,
7049 tdata->validAuthLen.len_bits,
7050 tdata->auth.offset_bits,
7051 op_mode, 1, verify);
7056 op = process_crypto_request(ts_params->valid_devs[0], ut_params->op);
7058 /* Check if the op failed because the device doesn't */
7059 /* support this particular combination of algorithms */
7060 if (op == NULL && ut_params->op->status ==
7061 RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
7062 printf("Device doesn't support this mixed combination. "
7068 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
7070 ut_params->obuf = (op_mode == IN_PLACE ?
7071 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
7074 if (ut_params->obuf)
7075 plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
7076 plaintext_len, buffer);
7078 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
7079 plaintext_len, buffer);
7081 debug_hexdump(stdout, "plaintext:", plaintext,
7082 (tdata->plaintext.len_bits >> 3) -
7083 tdata->digest_enc.len);
7084 debug_hexdump(stdout, "plaintext expected:",
7085 tdata->plaintext.data,
7086 (tdata->plaintext.len_bits >> 3) -
7087 tdata->digest_enc.len);
7089 if (ut_params->obuf)
7090 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
7091 ciphertext_len, buffer);
7093 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
7094 ciphertext_len, buffer);
7096 debug_hexdump(stdout, "ciphertext:", ciphertext,
7098 debug_hexdump(stdout, "ciphertext expected:",
7099 tdata->ciphertext.data,
7100 tdata->ciphertext.len_bits >> 3);
7102 if (ut_params->obuf)
7103 digest = rte_pktmbuf_read(ut_params->obuf,
7104 (tdata->digest_enc.offset == 0 ?
7106 tdata->digest_enc.offset),
7107 tdata->digest_enc.len, digest_buffer);
7109 digest = rte_pktmbuf_read(ut_params->ibuf,
7110 (tdata->digest_enc.offset == 0 ?
7112 tdata->digest_enc.offset),
7113 tdata->digest_enc.len, digest_buffer);
7115 debug_hexdump(stdout, "digest:", digest,
7116 tdata->digest_enc.len);
7117 debug_hexdump(stdout, "digest expected:",
7118 tdata->digest_enc.data, tdata->digest_enc.len);
7123 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7125 tdata->plaintext.data,
7126 tdata->plaintext.len_bits >> 3,
7127 "Plaintext data not as expected");
7129 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7131 tdata->ciphertext.data,
7132 tdata->validDataLen.len_bits,
7133 "Ciphertext data not as expected");
7134 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7136 tdata->digest_enc.data,
7137 tdata->digest_enc.len,
7138 "Generated auth tag not as expected");
7141 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7142 "crypto op processing failed");
7147 /** AUTH AES CMAC + CIPHER AES CTR */
7150 test_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7152 return test_mixed_auth_cipher(
7153 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7157 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7159 return test_mixed_auth_cipher(
7160 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7164 test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7166 return test_mixed_auth_cipher_sgl(
7167 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7171 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7173 return test_mixed_auth_cipher_sgl(
7174 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7178 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7180 return test_mixed_auth_cipher(
7181 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7185 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7187 return test_mixed_auth_cipher(
7188 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7192 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7194 return test_mixed_auth_cipher_sgl(
7195 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7199 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7201 return test_mixed_auth_cipher_sgl(
7202 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7205 /** MIXED AUTH + CIPHER */
7208 test_auth_zuc_cipher_snow_test_case_1(void)
7210 return test_mixed_auth_cipher(
7211 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7215 test_verify_auth_zuc_cipher_snow_test_case_1(void)
7217 return test_mixed_auth_cipher(
7218 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7222 test_auth_aes_cmac_cipher_snow_test_case_1(void)
7224 return test_mixed_auth_cipher(
7225 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7229 test_verify_auth_aes_cmac_cipher_snow_test_case_1(void)
7231 return test_mixed_auth_cipher(
7232 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7236 test_auth_zuc_cipher_aes_ctr_test_case_1(void)
7238 return test_mixed_auth_cipher(
7239 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7243 test_verify_auth_zuc_cipher_aes_ctr_test_case_1(void)
7245 return test_mixed_auth_cipher(
7246 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7250 test_auth_snow_cipher_aes_ctr_test_case_1(void)
7252 return test_mixed_auth_cipher(
7253 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7257 test_verify_auth_snow_cipher_aes_ctr_test_case_1(void)
7259 return test_mixed_auth_cipher(
7260 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7264 test_auth_snow_cipher_zuc_test_case_1(void)
7266 return test_mixed_auth_cipher(
7267 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7271 test_verify_auth_snow_cipher_zuc_test_case_1(void)
7273 return test_mixed_auth_cipher(
7274 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7278 test_auth_aes_cmac_cipher_zuc_test_case_1(void)
7280 return test_mixed_auth_cipher(
7281 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7285 test_verify_auth_aes_cmac_cipher_zuc_test_case_1(void)
7287 return test_mixed_auth_cipher(
7288 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7292 test_auth_null_cipher_snow_test_case_1(void)
7294 return test_mixed_auth_cipher(
7295 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7299 test_verify_auth_null_cipher_snow_test_case_1(void)
7301 return test_mixed_auth_cipher(
7302 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7306 test_auth_null_cipher_zuc_test_case_1(void)
7308 return test_mixed_auth_cipher(
7309 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7313 test_verify_auth_null_cipher_zuc_test_case_1(void)
7315 return test_mixed_auth_cipher(
7316 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7320 test_auth_snow_cipher_null_test_case_1(void)
7322 return test_mixed_auth_cipher(
7323 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7327 test_verify_auth_snow_cipher_null_test_case_1(void)
7329 return test_mixed_auth_cipher(
7330 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7334 test_auth_zuc_cipher_null_test_case_1(void)
7336 return test_mixed_auth_cipher(
7337 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7341 test_verify_auth_zuc_cipher_null_test_case_1(void)
7343 return test_mixed_auth_cipher(
7344 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7348 test_auth_null_cipher_aes_ctr_test_case_1(void)
7350 return test_mixed_auth_cipher(
7351 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7355 test_verify_auth_null_cipher_aes_ctr_test_case_1(void)
7357 return test_mixed_auth_cipher(
7358 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7362 test_auth_aes_cmac_cipher_null_test_case_1(void)
7364 return test_mixed_auth_cipher(
7365 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7369 test_verify_auth_aes_cmac_cipher_null_test_case_1(void)
7371 return test_mixed_auth_cipher(
7372 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7375 /* ***** AEAD algorithm Tests ***** */
7378 create_aead_session(uint8_t dev_id, enum rte_crypto_aead_algorithm algo,
7379 enum rte_crypto_aead_operation op,
7380 const uint8_t *key, const uint8_t key_len,
7381 const uint16_t aad_len, const uint8_t auth_len,
7384 uint8_t aead_key[key_len];
7386 struct crypto_testsuite_params *ts_params = &testsuite_params;
7387 struct crypto_unittest_params *ut_params = &unittest_params;
7389 memcpy(aead_key, key, key_len);
7391 /* Setup AEAD Parameters */
7392 ut_params->aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD;
7393 ut_params->aead_xform.next = NULL;
7394 ut_params->aead_xform.aead.algo = algo;
7395 ut_params->aead_xform.aead.op = op;
7396 ut_params->aead_xform.aead.key.data = aead_key;
7397 ut_params->aead_xform.aead.key.length = key_len;
7398 ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
7399 ut_params->aead_xform.aead.iv.length = iv_len;
7400 ut_params->aead_xform.aead.digest_length = auth_len;
7401 ut_params->aead_xform.aead.aad_length = aad_len;
7403 debug_hexdump(stdout, "key:", key, key_len);
7405 /* Create Crypto session*/
7406 ut_params->sess = rte_cryptodev_sym_session_create(
7407 ts_params->session_mpool);
7409 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
7410 &ut_params->aead_xform,
7411 ts_params->session_priv_mpool);
7413 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
7419 create_aead_xform(struct rte_crypto_op *op,
7420 enum rte_crypto_aead_algorithm algo,
7421 enum rte_crypto_aead_operation aead_op,
7422 uint8_t *key, const uint8_t key_len,
7423 const uint8_t aad_len, const uint8_t auth_len,
7426 TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 1),
7427 "failed to allocate space for crypto transform");
7429 struct rte_crypto_sym_op *sym_op = op->sym;
7431 /* Setup AEAD Parameters */
7432 sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_AEAD;
7433 sym_op->xform->next = NULL;
7434 sym_op->xform->aead.algo = algo;
7435 sym_op->xform->aead.op = aead_op;
7436 sym_op->xform->aead.key.data = key;
7437 sym_op->xform->aead.key.length = key_len;
7438 sym_op->xform->aead.iv.offset = IV_OFFSET;
7439 sym_op->xform->aead.iv.length = iv_len;
7440 sym_op->xform->aead.digest_length = auth_len;
7441 sym_op->xform->aead.aad_length = aad_len;
7443 debug_hexdump(stdout, "key:", key, key_len);
7449 create_aead_operation(enum rte_crypto_aead_operation op,
7450 const struct aead_test_data *tdata)
7452 struct crypto_testsuite_params *ts_params = &testsuite_params;
7453 struct crypto_unittest_params *ut_params = &unittest_params;
7455 uint8_t *plaintext, *ciphertext;
7456 unsigned int aad_pad_len, plaintext_pad_len;
7458 /* Generate Crypto op data structure */
7459 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7460 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7461 TEST_ASSERT_NOT_NULL(ut_params->op,
7462 "Failed to allocate symmetric crypto operation struct");
7464 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
7466 /* Append aad data */
7467 if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
7468 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len + 18, 16);
7469 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7471 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
7472 "no room to append aad");
7474 sym_op->aead.aad.phys_addr =
7475 rte_pktmbuf_iova(ut_params->ibuf);
7476 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
7477 memcpy(sym_op->aead.aad.data + 18, tdata->aad.data, tdata->aad.len);
7478 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
7481 /* Append IV at the end of the crypto operation*/
7482 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
7483 uint8_t *, IV_OFFSET);
7485 /* Copy IV 1 byte after the IV pointer, according to the API */
7486 rte_memcpy(iv_ptr + 1, tdata->iv.data, tdata->iv.len);
7487 debug_hexdump(stdout, "iv:", iv_ptr,
7490 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
7491 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7493 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
7494 "no room to append aad");
7496 sym_op->aead.aad.phys_addr =
7497 rte_pktmbuf_iova(ut_params->ibuf);
7498 memcpy(sym_op->aead.aad.data, tdata->aad.data, tdata->aad.len);
7499 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
7502 /* Append IV at the end of the crypto operation*/
7503 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
7504 uint8_t *, IV_OFFSET);
7506 if (tdata->iv.len == 0) {
7507 rte_memcpy(iv_ptr, tdata->iv.data, AES_GCM_J0_LENGTH);
7508 debug_hexdump(stdout, "iv:", iv_ptr,
7511 rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
7512 debug_hexdump(stdout, "iv:", iv_ptr,
7517 /* Append plaintext/ciphertext */
7518 if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
7519 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
7520 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7522 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
7524 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
7525 debug_hexdump(stdout, "plaintext:", plaintext,
7526 tdata->plaintext.len);
7528 if (ut_params->obuf) {
7529 ciphertext = (uint8_t *)rte_pktmbuf_append(
7531 plaintext_pad_len + aad_pad_len);
7532 TEST_ASSERT_NOT_NULL(ciphertext,
7533 "no room to append ciphertext");
7535 memset(ciphertext + aad_pad_len, 0,
7536 tdata->ciphertext.len);
7539 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16);
7540 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7542 TEST_ASSERT_NOT_NULL(ciphertext,
7543 "no room to append ciphertext");
7545 memcpy(ciphertext, tdata->ciphertext.data,
7546 tdata->ciphertext.len);
7547 debug_hexdump(stdout, "ciphertext:", ciphertext,
7548 tdata->ciphertext.len);
7550 if (ut_params->obuf) {
7551 plaintext = (uint8_t *)rte_pktmbuf_append(
7553 plaintext_pad_len + aad_pad_len);
7554 TEST_ASSERT_NOT_NULL(plaintext,
7555 "no room to append plaintext");
7557 memset(plaintext + aad_pad_len, 0,
7558 tdata->plaintext.len);
7562 /* Append digest data */
7563 if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
7564 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
7565 ut_params->obuf ? ut_params->obuf :
7567 tdata->auth_tag.len);
7568 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
7569 "no room to append digest");
7570 memset(sym_op->aead.digest.data, 0, tdata->auth_tag.len);
7571 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
7572 ut_params->obuf ? ut_params->obuf :
7577 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
7578 ut_params->ibuf, tdata->auth_tag.len);
7579 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
7580 "no room to append digest");
7581 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
7583 plaintext_pad_len + aad_pad_len);
7585 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
7586 tdata->auth_tag.len);
7587 debug_hexdump(stdout, "digest:",
7588 sym_op->aead.digest.data,
7589 tdata->auth_tag.len);
7592 sym_op->aead.data.length = tdata->plaintext.len;
7593 sym_op->aead.data.offset = aad_pad_len;
7599 test_authenticated_encryption(const struct aead_test_data *tdata)
7601 struct crypto_testsuite_params *ts_params = &testsuite_params;
7602 struct crypto_unittest_params *ut_params = &unittest_params;
7605 uint8_t *ciphertext, *auth_tag;
7606 uint16_t plaintext_pad_len;
7608 struct rte_cryptodev_info dev_info;
7610 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
7611 uint64_t feat_flags = dev_info.feature_flags;
7613 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
7614 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
7615 printf("Device doesn't support RAW data-path APIs.\n");
7619 /* Verify the capabilities */
7620 struct rte_cryptodev_sym_capability_idx cap_idx;
7621 const struct rte_cryptodev_symmetric_capability *capability;
7622 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
7623 cap_idx.algo.aead = tdata->algo;
7624 capability = rte_cryptodev_sym_capability_get(
7625 ts_params->valid_devs[0], &cap_idx);
7626 if (capability == NULL)
7628 if (rte_cryptodev_sym_capability_check_aead(
7629 capability, tdata->key.len, tdata->auth_tag.len,
7630 tdata->aad.len, tdata->iv.len))
7633 /* Create AEAD session */
7634 retval = create_aead_session(ts_params->valid_devs[0],
7636 RTE_CRYPTO_AEAD_OP_ENCRYPT,
7637 tdata->key.data, tdata->key.len,
7638 tdata->aad.len, tdata->auth_tag.len,
7643 if (tdata->aad.len > MBUF_SIZE) {
7644 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
7645 /* Populate full size of add data */
7646 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
7647 memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
7649 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7651 /* clear mbuf payload */
7652 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7653 rte_pktmbuf_tailroom(ut_params->ibuf));
7655 /* Create AEAD operation */
7656 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
7660 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
7662 ut_params->op->sym->m_src = ut_params->ibuf;
7664 /* Process crypto operation */
7665 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
7666 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
7667 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
7668 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
7669 ut_params->op, 0, 0, 0, 0);
7671 TEST_ASSERT_NOT_NULL(
7672 process_crypto_request(ts_params->valid_devs[0],
7673 ut_params->op), "failed to process sym crypto op");
7675 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7676 "crypto op processing failed");
7678 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
7680 if (ut_params->op->sym->m_dst) {
7681 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
7683 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
7684 uint8_t *, plaintext_pad_len);
7686 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
7688 ut_params->op->sym->cipher.data.offset);
7689 auth_tag = ciphertext + plaintext_pad_len;
7692 debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
7693 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
7696 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7698 tdata->ciphertext.data,
7699 tdata->ciphertext.len,
7700 "Ciphertext data not as expected");
7702 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7704 tdata->auth_tag.data,
7705 tdata->auth_tag.len,
7706 "Generated auth tag not as expected");
7712 #ifdef RTE_LIB_SECURITY
7714 security_proto_supported(enum rte_security_session_action_type action,
7715 enum rte_security_session_protocol proto)
7717 struct crypto_testsuite_params *ts_params = &testsuite_params;
7719 const struct rte_security_capability *capabilities;
7720 const struct rte_security_capability *capability;
7723 struct rte_security_ctx *ctx = (struct rte_security_ctx *)
7724 rte_cryptodev_get_sec_ctx(
7725 ts_params->valid_devs[0]);
7728 capabilities = rte_security_capabilities_get(ctx);
7730 if (capabilities == NULL)
7733 while ((capability = &capabilities[i++])->action !=
7734 RTE_SECURITY_ACTION_TYPE_NONE) {
7735 if (capability->action == action &&
7736 capability->protocol == proto)
7743 /* Basic algorithm run function for async inplace mode.
7744 * Creates a session from input parameters and runs one operation
7745 * on input_vec. Checks the output of the crypto operation against
7748 static int test_pdcp_proto(int i, int oop, enum rte_crypto_cipher_operation opc,
7749 enum rte_crypto_auth_operation opa,
7750 const uint8_t *input_vec, unsigned int input_vec_len,
7751 const uint8_t *output_vec,
7752 unsigned int output_vec_len,
7753 enum rte_crypto_cipher_algorithm cipher_alg,
7754 const uint8_t *cipher_key, uint32_t cipher_key_len,
7755 enum rte_crypto_auth_algorithm auth_alg,
7756 const uint8_t *auth_key, uint32_t auth_key_len,
7757 uint8_t bearer, enum rte_security_pdcp_domain domain,
7758 uint8_t packet_direction, uint8_t sn_size,
7759 uint32_t hfn, uint32_t hfn_threshold, uint8_t sdap)
7761 struct crypto_testsuite_params *ts_params = &testsuite_params;
7762 struct crypto_unittest_params *ut_params = &unittest_params;
7764 int ret = TEST_SUCCESS;
7765 struct rte_security_ctx *ctx = (struct rte_security_ctx *)
7766 rte_cryptodev_get_sec_ctx(
7767 ts_params->valid_devs[0]);
7769 /* Verify the capabilities */
7770 struct rte_security_capability_idx sec_cap_idx;
7772 sec_cap_idx.action = ut_params->type;
7773 sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
7774 sec_cap_idx.pdcp.domain = domain;
7775 if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
7778 /* Generate test mbuf data */
7779 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7781 /* clear mbuf payload */
7782 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7783 rte_pktmbuf_tailroom(ut_params->ibuf));
7785 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7787 memcpy(plaintext, input_vec, input_vec_len);
7789 /* Out of place support */
7792 * For out-op-place we need to alloc another mbuf
7794 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7795 rte_pktmbuf_append(ut_params->obuf, output_vec_len);
7798 /* Setup Cipher Parameters */
7799 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
7800 ut_params->cipher_xform.cipher.algo = cipher_alg;
7801 ut_params->cipher_xform.cipher.op = opc;
7802 ut_params->cipher_xform.cipher.key.data = cipher_key;
7803 ut_params->cipher_xform.cipher.key.length = cipher_key_len;
7804 ut_params->cipher_xform.cipher.iv.length =
7805 packet_direction ? 4 : 0;
7806 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
7808 /* Setup HMAC Parameters if ICV header is required */
7809 if (auth_alg != 0) {
7810 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
7811 ut_params->auth_xform.next = NULL;
7812 ut_params->auth_xform.auth.algo = auth_alg;
7813 ut_params->auth_xform.auth.op = opa;
7814 ut_params->auth_xform.auth.key.data = auth_key;
7815 ut_params->auth_xform.auth.key.length = auth_key_len;
7817 ut_params->cipher_xform.next = &ut_params->auth_xform;
7819 ut_params->cipher_xform.next = NULL;
7822 struct rte_security_session_conf sess_conf = {
7823 .action_type = ut_params->type,
7824 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
7828 .pkt_dir = packet_direction,
7830 .hfn = packet_direction ? 0 : hfn,
7832 * hfn can be set as pdcp_test_hfn[i]
7833 * if hfn_ovrd is not set. Here, PDCP
7834 * packet direction is just used to
7835 * run half of the cases with session
7836 * HFN and other half with per packet
7839 .hfn_threshold = hfn_threshold,
7840 .hfn_ovrd = packet_direction ? 1 : 0,
7841 .sdap_enabled = sdap,
7843 .crypto_xform = &ut_params->cipher_xform
7846 /* Create security session */
7847 ut_params->sec_session = rte_security_session_create(ctx,
7848 &sess_conf, ts_params->session_mpool,
7849 ts_params->session_priv_mpool);
7851 if (!ut_params->sec_session) {
7852 printf("TestCase %s()-%d line %d failed %s: ",
7853 __func__, i, __LINE__, "Failed to allocate session");
7858 /* Generate crypto op data structure */
7859 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7860 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7861 if (!ut_params->op) {
7862 printf("TestCase %s()-%d line %d failed %s: ",
7863 __func__, i, __LINE__,
7864 "Failed to allocate symmetric crypto operation struct");
7869 uint32_t *per_pkt_hfn = rte_crypto_op_ctod_offset(ut_params->op,
7870 uint32_t *, IV_OFFSET);
7871 *per_pkt_hfn = packet_direction ? hfn : 0;
7873 rte_security_attach_session(ut_params->op, ut_params->sec_session);
7875 /* set crypto operation source mbuf */
7876 ut_params->op->sym->m_src = ut_params->ibuf;
7878 ut_params->op->sym->m_dst = ut_params->obuf;
7880 /* Process crypto operation */
7881 if (process_crypto_request(ts_params->valid_devs[0], ut_params->op)
7883 printf("TestCase %s()-%d line %d failed %s: ",
7884 __func__, i, __LINE__,
7885 "failed to process sym crypto op");
7890 if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
7891 printf("TestCase %s()-%d line %d failed %s: ",
7892 __func__, i, __LINE__, "crypto op processing failed");
7898 uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
7901 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
7905 if (memcmp(ciphertext, output_vec, output_vec_len)) {
7906 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
7907 rte_hexdump(stdout, "encrypted", ciphertext, output_vec_len);
7908 rte_hexdump(stdout, "reference", output_vec, output_vec_len);
7914 rte_crypto_op_free(ut_params->op);
7915 ut_params->op = NULL;
7917 if (ut_params->sec_session)
7918 rte_security_session_destroy(ctx, ut_params->sec_session);
7919 ut_params->sec_session = NULL;
7921 rte_pktmbuf_free(ut_params->ibuf);
7922 ut_params->ibuf = NULL;
7924 rte_pktmbuf_free(ut_params->obuf);
7925 ut_params->obuf = NULL;
7932 test_pdcp_proto_SGL(int i, int oop,
7933 enum rte_crypto_cipher_operation opc,
7934 enum rte_crypto_auth_operation opa,
7936 unsigned int input_vec_len,
7937 uint8_t *output_vec,
7938 unsigned int output_vec_len,
7940 uint32_t fragsz_oop)
7942 struct crypto_testsuite_params *ts_params = &testsuite_params;
7943 struct crypto_unittest_params *ut_params = &unittest_params;
7945 struct rte_mbuf *buf, *buf_oop = NULL;
7946 int ret = TEST_SUCCESS;
7950 unsigned int trn_data = 0;
7951 struct rte_security_ctx *ctx = (struct rte_security_ctx *)
7952 rte_cryptodev_get_sec_ctx(
7953 ts_params->valid_devs[0]);
7955 /* Verify the capabilities */
7956 struct rte_security_capability_idx sec_cap_idx;
7958 sec_cap_idx.action = ut_params->type;
7959 sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
7960 sec_cap_idx.pdcp.domain = pdcp_test_params[i].domain;
7961 if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
7964 if (fragsz > input_vec_len)
7965 fragsz = input_vec_len;
7967 uint16_t plaintext_len = fragsz;
7968 uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
7970 if (fragsz_oop > output_vec_len)
7971 frag_size_oop = output_vec_len;
7974 if (input_vec_len % fragsz != 0) {
7975 if (input_vec_len / fragsz + 1 > 16)
7977 } else if (input_vec_len / fragsz > 16)
7980 /* Out of place support */
7983 * For out-op-place we need to alloc another mbuf
7985 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7986 rte_pktmbuf_append(ut_params->obuf, frag_size_oop);
7987 buf_oop = ut_params->obuf;
7990 /* Generate test mbuf data */
7991 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7993 /* clear mbuf payload */
7994 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7995 rte_pktmbuf_tailroom(ut_params->ibuf));
7997 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7999 memcpy(plaintext, input_vec, plaintext_len);
8000 trn_data += plaintext_len;
8002 buf = ut_params->ibuf;
8005 * Loop until no more fragments
8008 while (trn_data < input_vec_len) {
8010 to_trn = (input_vec_len - trn_data < fragsz) ?
8011 (input_vec_len - trn_data) : fragsz;
8013 to_trn_tbl[ecx++] = to_trn;
8015 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8018 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
8019 rte_pktmbuf_tailroom(buf));
8022 if (oop && !fragsz_oop) {
8024 rte_pktmbuf_alloc(ts_params->mbuf_pool);
8025 buf_oop = buf_oop->next;
8026 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8027 0, rte_pktmbuf_tailroom(buf_oop));
8028 rte_pktmbuf_append(buf_oop, to_trn);
8031 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
8034 memcpy(plaintext, input_vec + trn_data, to_trn);
8038 ut_params->ibuf->nb_segs = segs;
8041 if (fragsz_oop && oop) {
8045 trn_data = frag_size_oop;
8046 while (trn_data < output_vec_len) {
8049 (output_vec_len - trn_data <
8051 (output_vec_len - trn_data) :
8054 to_trn_tbl[ecx++] = to_trn;
8057 rte_pktmbuf_alloc(ts_params->mbuf_pool);
8058 buf_oop = buf_oop->next;
8059 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8060 0, rte_pktmbuf_tailroom(buf_oop));
8061 rte_pktmbuf_append(buf_oop, to_trn);
8065 ut_params->obuf->nb_segs = segs;
8068 /* Setup Cipher Parameters */
8069 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8070 ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg;
8071 ut_params->cipher_xform.cipher.op = opc;
8072 ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i];
8073 ut_params->cipher_xform.cipher.key.length =
8074 pdcp_test_params[i].cipher_key_len;
8075 ut_params->cipher_xform.cipher.iv.length = 0;
8077 /* Setup HMAC Parameters if ICV header is required */
8078 if (pdcp_test_params[i].auth_alg != 0) {
8079 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8080 ut_params->auth_xform.next = NULL;
8081 ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg;
8082 ut_params->auth_xform.auth.op = opa;
8083 ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i];
8084 ut_params->auth_xform.auth.key.length =
8085 pdcp_test_params[i].auth_key_len;
8087 ut_params->cipher_xform.next = &ut_params->auth_xform;
8089 ut_params->cipher_xform.next = NULL;
8092 struct rte_security_session_conf sess_conf = {
8093 .action_type = ut_params->type,
8094 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
8096 .bearer = pdcp_test_bearer[i],
8097 .domain = pdcp_test_params[i].domain,
8098 .pkt_dir = pdcp_test_packet_direction[i],
8099 .sn_size = pdcp_test_data_sn_size[i],
8100 .hfn = pdcp_test_hfn[i],
8101 .hfn_threshold = pdcp_test_hfn_threshold[i],
8104 .crypto_xform = &ut_params->cipher_xform
8107 /* Create security session */
8108 ut_params->sec_session = rte_security_session_create(ctx,
8109 &sess_conf, ts_params->session_mpool,
8110 ts_params->session_priv_mpool);
8112 if (!ut_params->sec_session) {
8113 printf("TestCase %s()-%d line %d failed %s: ",
8114 __func__, i, __LINE__, "Failed to allocate session");
8119 /* Generate crypto op data structure */
8120 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8121 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8122 if (!ut_params->op) {
8123 printf("TestCase %s()-%d line %d failed %s: ",
8124 __func__, i, __LINE__,
8125 "Failed to allocate symmetric crypto operation struct");
8130 rte_security_attach_session(ut_params->op, ut_params->sec_session);
8132 /* set crypto operation source mbuf */
8133 ut_params->op->sym->m_src = ut_params->ibuf;
8135 ut_params->op->sym->m_dst = ut_params->obuf;
8137 /* Process crypto operation */
8138 if (process_crypto_request(ts_params->valid_devs[0], ut_params->op)
8140 printf("TestCase %s()-%d line %d failed %s: ",
8141 __func__, i, __LINE__,
8142 "failed to process sym crypto op");
8147 if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8148 printf("TestCase %s()-%d line %d failed %s: ",
8149 __func__, i, __LINE__, "crypto op processing failed");
8155 uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
8158 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8162 fragsz = frag_size_oop;
8163 if (memcmp(ciphertext, output_vec, fragsz)) {
8164 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8165 rte_hexdump(stdout, "encrypted", ciphertext, fragsz);
8166 rte_hexdump(stdout, "reference", output_vec, fragsz);
8171 buf = ut_params->op->sym->m_src->next;
8173 buf = ut_params->op->sym->m_dst->next;
8175 unsigned int off = fragsz;
8179 ciphertext = rte_pktmbuf_mtod(buf,
8181 if (memcmp(ciphertext, output_vec + off, to_trn_tbl[ecx])) {
8182 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8183 rte_hexdump(stdout, "encrypted", ciphertext, to_trn_tbl[ecx]);
8184 rte_hexdump(stdout, "reference", output_vec + off,
8189 off += to_trn_tbl[ecx++];
8193 rte_crypto_op_free(ut_params->op);
8194 ut_params->op = NULL;
8196 if (ut_params->sec_session)
8197 rte_security_session_destroy(ctx, ut_params->sec_session);
8198 ut_params->sec_session = NULL;
8200 rte_pktmbuf_free(ut_params->ibuf);
8201 ut_params->ibuf = NULL;
8203 rte_pktmbuf_free(ut_params->obuf);
8204 ut_params->obuf = NULL;
8211 test_pdcp_proto_cplane_encap(int i)
8213 return test_pdcp_proto(
8214 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8215 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8216 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8217 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8218 pdcp_test_params[i].cipher_key_len,
8219 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8220 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8221 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8222 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8223 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8227 test_pdcp_proto_uplane_encap(int i)
8229 return test_pdcp_proto(
8230 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8231 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8232 pdcp_test_data_out[i], pdcp_test_data_in_len[i],
8233 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8234 pdcp_test_params[i].cipher_key_len,
8235 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8236 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8237 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8238 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8239 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8243 test_pdcp_proto_uplane_encap_with_int(int i)
8245 return test_pdcp_proto(
8246 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8247 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8248 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8249 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8250 pdcp_test_params[i].cipher_key_len,
8251 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8252 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8253 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8254 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8255 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8259 test_pdcp_proto_cplane_decap(int i)
8261 return test_pdcp_proto(
8262 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8263 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8264 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8265 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8266 pdcp_test_params[i].cipher_key_len,
8267 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8268 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8269 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8270 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8271 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8275 test_pdcp_proto_uplane_decap(int i)
8277 return test_pdcp_proto(
8278 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8279 pdcp_test_data_out[i], pdcp_test_data_in_len[i],
8280 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8281 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8282 pdcp_test_params[i].cipher_key_len,
8283 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8284 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8285 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8286 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8287 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8291 test_pdcp_proto_uplane_decap_with_int(int i)
8293 return test_pdcp_proto(
8294 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8295 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8296 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8297 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8298 pdcp_test_params[i].cipher_key_len,
8299 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8300 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8301 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8302 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8303 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8307 test_PDCP_PROTO_SGL_in_place_32B(void)
8309 /* i can be used for running any PDCP case
8310 * In this case it is uplane 12-bit AES-SNOW DL encap
8312 int i = PDCP_UPLANE_12BIT_OFFSET + AES_ENC + SNOW_AUTH + DOWNLINK;
8313 return test_pdcp_proto_SGL(i, IN_PLACE,
8314 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8315 RTE_CRYPTO_AUTH_OP_GENERATE,
8316 pdcp_test_data_in[i],
8317 pdcp_test_data_in_len[i],
8318 pdcp_test_data_out[i],
8319 pdcp_test_data_in_len[i]+4,
8323 test_PDCP_PROTO_SGL_oop_32B_128B(void)
8325 /* i can be used for running any PDCP case
8326 * In this case it is uplane 18-bit NULL-NULL DL encap
8328 int i = PDCP_UPLANE_18BIT_OFFSET + NULL_ENC + NULL_AUTH + DOWNLINK;
8329 return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8330 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8331 RTE_CRYPTO_AUTH_OP_GENERATE,
8332 pdcp_test_data_in[i],
8333 pdcp_test_data_in_len[i],
8334 pdcp_test_data_out[i],
8335 pdcp_test_data_in_len[i]+4,
8339 test_PDCP_PROTO_SGL_oop_32B_40B(void)
8341 /* i can be used for running any PDCP case
8342 * In this case it is uplane 18-bit AES DL encap
8344 int i = PDCP_UPLANE_OFFSET + AES_ENC + EIGHTEEN_BIT_SEQ_NUM_OFFSET
8346 return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8347 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8348 RTE_CRYPTO_AUTH_OP_GENERATE,
8349 pdcp_test_data_in[i],
8350 pdcp_test_data_in_len[i],
8351 pdcp_test_data_out[i],
8352 pdcp_test_data_in_len[i],
8356 test_PDCP_PROTO_SGL_oop_128B_32B(void)
8358 /* i can be used for running any PDCP case
8359 * In this case it is cplane 12-bit AES-ZUC DL encap
8361 int i = PDCP_CPLANE_LONG_SN_OFFSET + AES_ENC + ZUC_AUTH + DOWNLINK;
8362 return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8363 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8364 RTE_CRYPTO_AUTH_OP_GENERATE,
8365 pdcp_test_data_in[i],
8366 pdcp_test_data_in_len[i],
8367 pdcp_test_data_out[i],
8368 pdcp_test_data_in_len[i]+4,
8373 test_PDCP_SDAP_PROTO_encap_all(void)
8375 int i = 0, size = 0;
8376 int err, all_err = TEST_SUCCESS;
8377 const struct pdcp_sdap_test *cur_test;
8379 size = ARRAY_SIZE(list_pdcp_sdap_tests);
8381 for (i = 0; i < size; i++) {
8382 cur_test = &list_pdcp_sdap_tests[i];
8383 err = test_pdcp_proto(
8384 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8385 RTE_CRYPTO_AUTH_OP_GENERATE, cur_test->data_in,
8386 cur_test->in_len, cur_test->data_out,
8387 cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
8388 cur_test->param.cipher_alg, cur_test->cipher_key,
8389 cur_test->param.cipher_key_len,
8390 cur_test->param.auth_alg,
8391 cur_test->auth_key, cur_test->param.auth_key_len,
8392 cur_test->bearer, cur_test->param.domain,
8393 cur_test->packet_direction, cur_test->sn_size,
8395 cur_test->hfn_threshold, SDAP_ENABLED);
8397 printf("\t%d) %s: Encapsulation failed\n",
8399 cur_test->param.name);
8402 printf("\t%d) %s: Encap PASS\n", cur_test->test_idx,
8403 cur_test->param.name);
8409 printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
8411 return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
8415 test_PDCP_SDAP_PROTO_decap_all(void)
8417 int i = 0, size = 0;
8418 int err, all_err = TEST_SUCCESS;
8419 const struct pdcp_sdap_test *cur_test;
8421 size = ARRAY_SIZE(list_pdcp_sdap_tests);
8423 for (i = 0; i < size; i++) {
8424 cur_test = &list_pdcp_sdap_tests[i];
8425 err = test_pdcp_proto(
8426 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT,
8427 RTE_CRYPTO_AUTH_OP_VERIFY,
8429 cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
8430 cur_test->data_in, cur_test->in_len,
8431 cur_test->param.cipher_alg,
8432 cur_test->cipher_key, cur_test->param.cipher_key_len,
8433 cur_test->param.auth_alg, cur_test->auth_key,
8434 cur_test->param.auth_key_len, cur_test->bearer,
8435 cur_test->param.domain, cur_test->packet_direction,
8436 cur_test->sn_size, cur_test->hfn,
8437 cur_test->hfn_threshold, SDAP_ENABLED);
8439 printf("\t%d) %s: Decapsulation failed\n",
8441 cur_test->param.name);
8444 printf("\t%d) %s: Decap PASS\n", cur_test->test_idx,
8445 cur_test->param.name);
8451 printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
8453 return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
8457 test_PDCP_PROTO_all(void)
8459 struct crypto_testsuite_params *ts_params = &testsuite_params;
8460 struct crypto_unittest_params *ut_params = &unittest_params;
8461 struct rte_cryptodev_info dev_info;
8464 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8465 uint64_t feat_flags = dev_info.feature_flags;
8467 if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY))
8470 /* Set action type */
8471 ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
8472 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
8475 if (security_proto_supported(ut_params->type,
8476 RTE_SECURITY_PROTOCOL_PDCP) < 0)
8479 status = test_PDCP_PROTO_cplane_encap_all();
8480 status += test_PDCP_PROTO_cplane_decap_all();
8481 status += test_PDCP_PROTO_uplane_encap_all();
8482 status += test_PDCP_PROTO_uplane_decap_all();
8483 status += test_PDCP_PROTO_SGL_in_place_32B();
8484 status += test_PDCP_PROTO_SGL_oop_32B_128B();
8485 status += test_PDCP_PROTO_SGL_oop_32B_40B();
8486 status += test_PDCP_PROTO_SGL_oop_128B_32B();
8487 status += test_PDCP_SDAP_PROTO_encap_all();
8488 status += test_PDCP_SDAP_PROTO_decap_all();
8493 return TEST_SUCCESS;
8497 test_docsis_proto_uplink(int i, struct docsis_test_data *d_td)
8499 struct crypto_testsuite_params *ts_params = &testsuite_params;
8500 struct crypto_unittest_params *ut_params = &unittest_params;
8501 uint8_t *plaintext, *ciphertext;
8503 int32_t cipher_len, crc_len;
8504 uint32_t crc_data_len;
8505 int ret = TEST_SUCCESS;
8507 struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8508 rte_cryptodev_get_sec_ctx(
8509 ts_params->valid_devs[0]);
8511 /* Verify the capabilities */
8512 struct rte_security_capability_idx sec_cap_idx;
8513 const struct rte_security_capability *sec_cap;
8514 const struct rte_cryptodev_capabilities *crypto_cap;
8515 const struct rte_cryptodev_symmetric_capability *sym_cap;
8518 sec_cap_idx.action = ut_params->type;
8519 sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
8520 sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_UPLINK;
8522 sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
8523 if (sec_cap == NULL)
8526 while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
8527 RTE_CRYPTO_OP_TYPE_UNDEFINED) {
8528 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
8529 crypto_cap->sym.xform_type ==
8530 RTE_CRYPTO_SYM_XFORM_CIPHER &&
8531 crypto_cap->sym.cipher.algo ==
8532 RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
8533 sym_cap = &crypto_cap->sym;
8534 if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
8541 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
8544 /* Setup source mbuf payload */
8545 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8546 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8547 rte_pktmbuf_tailroom(ut_params->ibuf));
8549 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8550 d_td->ciphertext.len);
8552 memcpy(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len);
8554 /* Setup cipher session parameters */
8555 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8556 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
8557 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
8558 ut_params->cipher_xform.cipher.key.data = d_td->key.data;
8559 ut_params->cipher_xform.cipher.key.length = d_td->key.len;
8560 ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
8561 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
8562 ut_params->cipher_xform.next = NULL;
8564 /* Setup DOCSIS session parameters */
8565 ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_UPLINK;
8567 struct rte_security_session_conf sess_conf = {
8568 .action_type = ut_params->type,
8569 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
8570 .docsis = ut_params->docsis_xform,
8571 .crypto_xform = &ut_params->cipher_xform,
8574 /* Create security session */
8575 ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
8576 ts_params->session_mpool,
8577 ts_params->session_priv_mpool);
8579 if (!ut_params->sec_session) {
8580 printf("TestCase %s(%d) line %d: %s\n",
8581 __func__, i, __LINE__, "failed to allocate session");
8586 /* Generate crypto op data structure */
8587 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8588 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8589 if (!ut_params->op) {
8590 printf("TestCase %s(%d) line %d: %s\n",
8591 __func__, i, __LINE__,
8592 "failed to allocate symmetric crypto operation");
8597 /* Setup CRC operation parameters */
8598 crc_len = d_td->ciphertext.no_crc == false ?
8599 (d_td->ciphertext.len -
8600 d_td->ciphertext.crc_offset -
8601 RTE_ETHER_CRC_LEN) :
8603 crc_len = crc_len > 0 ? crc_len : 0;
8604 crc_data_len = crc_len == 0 ? 0 : RTE_ETHER_CRC_LEN;
8605 ut_params->op->sym->auth.data.length = crc_len;
8606 ut_params->op->sym->auth.data.offset = d_td->ciphertext.crc_offset;
8608 /* Setup cipher operation parameters */
8609 cipher_len = d_td->ciphertext.no_cipher == false ?
8610 (d_td->ciphertext.len -
8611 d_td->ciphertext.cipher_offset) :
8613 cipher_len = cipher_len > 0 ? cipher_len : 0;
8614 ut_params->op->sym->cipher.data.length = cipher_len;
8615 ut_params->op->sym->cipher.data.offset = d_td->ciphertext.cipher_offset;
8617 /* Setup cipher IV */
8618 iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
8619 rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
8621 /* Attach session to operation */
8622 rte_security_attach_session(ut_params->op, ut_params->sec_session);
8624 /* Set crypto operation mbufs */
8625 ut_params->op->sym->m_src = ut_params->ibuf;
8626 ut_params->op->sym->m_dst = NULL;
8628 /* Process crypto operation */
8629 if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
8631 printf("TestCase %s(%d) line %d: %s\n",
8632 __func__, i, __LINE__,
8633 "failed to process security crypto op");
8638 if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8639 printf("TestCase %s(%d) line %d: %s\n",
8640 __func__, i, __LINE__, "crypto op processing failed");
8645 /* Validate plaintext */
8646 plaintext = ciphertext;
8648 if (memcmp(plaintext, d_td->plaintext.data,
8649 d_td->plaintext.len - crc_data_len)) {
8650 printf("TestCase %s(%d) line %d: %s\n",
8651 __func__, i, __LINE__, "plaintext not as expected\n");
8652 rte_hexdump(stdout, "expected", d_td->plaintext.data,
8653 d_td->plaintext.len);
8654 rte_hexdump(stdout, "actual", plaintext, d_td->plaintext.len);
8660 rte_crypto_op_free(ut_params->op);
8661 ut_params->op = NULL;
8663 if (ut_params->sec_session)
8664 rte_security_session_destroy(ctx, ut_params->sec_session);
8665 ut_params->sec_session = NULL;
8667 rte_pktmbuf_free(ut_params->ibuf);
8668 ut_params->ibuf = NULL;
8674 test_docsis_proto_downlink(int i, struct docsis_test_data *d_td)
8676 struct crypto_testsuite_params *ts_params = &testsuite_params;
8677 struct crypto_unittest_params *ut_params = &unittest_params;
8678 uint8_t *plaintext, *ciphertext;
8680 int32_t cipher_len, crc_len;
8681 int ret = TEST_SUCCESS;
8683 struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8684 rte_cryptodev_get_sec_ctx(
8685 ts_params->valid_devs[0]);
8687 /* Verify the capabilities */
8688 struct rte_security_capability_idx sec_cap_idx;
8689 const struct rte_security_capability *sec_cap;
8690 const struct rte_cryptodev_capabilities *crypto_cap;
8691 const struct rte_cryptodev_symmetric_capability *sym_cap;
8694 sec_cap_idx.action = ut_params->type;
8695 sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
8696 sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
8698 sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
8699 if (sec_cap == NULL)
8702 while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
8703 RTE_CRYPTO_OP_TYPE_UNDEFINED) {
8704 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
8705 crypto_cap->sym.xform_type ==
8706 RTE_CRYPTO_SYM_XFORM_CIPHER &&
8707 crypto_cap->sym.cipher.algo ==
8708 RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
8709 sym_cap = &crypto_cap->sym;
8710 if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
8717 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
8720 /* Setup source mbuf payload */
8721 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8722 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8723 rte_pktmbuf_tailroom(ut_params->ibuf));
8725 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8726 d_td->plaintext.len);
8728 memcpy(plaintext, d_td->plaintext.data, d_td->plaintext.len);
8730 /* Setup cipher session parameters */
8731 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8732 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
8733 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
8734 ut_params->cipher_xform.cipher.key.data = d_td->key.data;
8735 ut_params->cipher_xform.cipher.key.length = d_td->key.len;
8736 ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
8737 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
8738 ut_params->cipher_xform.next = NULL;
8740 /* Setup DOCSIS session parameters */
8741 ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
8743 struct rte_security_session_conf sess_conf = {
8744 .action_type = ut_params->type,
8745 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
8746 .docsis = ut_params->docsis_xform,
8747 .crypto_xform = &ut_params->cipher_xform,
8750 /* Create security session */
8751 ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
8752 ts_params->session_mpool,
8753 ts_params->session_priv_mpool);
8755 if (!ut_params->sec_session) {
8756 printf("TestCase %s(%d) line %d: %s\n",
8757 __func__, i, __LINE__, "failed to allocate session");
8762 /* Generate crypto op data structure */
8763 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8764 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8765 if (!ut_params->op) {
8766 printf("TestCase %s(%d) line %d: %s\n",
8767 __func__, i, __LINE__,
8768 "failed to allocate security crypto operation");
8773 /* Setup CRC operation parameters */
8774 crc_len = d_td->plaintext.no_crc == false ?
8775 (d_td->plaintext.len -
8776 d_td->plaintext.crc_offset -
8777 RTE_ETHER_CRC_LEN) :
8779 crc_len = crc_len > 0 ? crc_len : 0;
8780 ut_params->op->sym->auth.data.length = crc_len;
8781 ut_params->op->sym->auth.data.offset = d_td->plaintext.crc_offset;
8783 /* Setup cipher operation parameters */
8784 cipher_len = d_td->plaintext.no_cipher == false ?
8785 (d_td->plaintext.len -
8786 d_td->plaintext.cipher_offset) :
8788 cipher_len = cipher_len > 0 ? cipher_len : 0;
8789 ut_params->op->sym->cipher.data.length = cipher_len;
8790 ut_params->op->sym->cipher.data.offset = d_td->plaintext.cipher_offset;
8792 /* Setup cipher IV */
8793 iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
8794 rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
8796 /* Attach session to operation */
8797 rte_security_attach_session(ut_params->op, ut_params->sec_session);
8799 /* Set crypto operation mbufs */
8800 ut_params->op->sym->m_src = ut_params->ibuf;
8801 ut_params->op->sym->m_dst = NULL;
8803 /* Process crypto operation */
8804 if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
8806 printf("TestCase %s(%d) line %d: %s\n",
8807 __func__, i, __LINE__,
8808 "failed to process security crypto op");
8813 if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8814 printf("TestCase %s(%d) line %d: %s\n",
8815 __func__, i, __LINE__, "crypto op processing failed");
8820 /* Validate ciphertext */
8821 ciphertext = plaintext;
8823 if (memcmp(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len)) {
8824 printf("TestCase %s(%d) line %d: %s\n",
8825 __func__, i, __LINE__, "ciphertext not as expected\n");
8826 rte_hexdump(stdout, "expected", d_td->ciphertext.data,
8827 d_td->ciphertext.len);
8828 rte_hexdump(stdout, "actual", ciphertext, d_td->ciphertext.len);
8834 rte_crypto_op_free(ut_params->op);
8835 ut_params->op = NULL;
8837 if (ut_params->sec_session)
8838 rte_security_session_destroy(ctx, ut_params->sec_session);
8839 ut_params->sec_session = NULL;
8841 rte_pktmbuf_free(ut_params->ibuf);
8842 ut_params->ibuf = NULL;
8847 #define TEST_DOCSIS_COUNT(func) do { \
8849 if (ret == TEST_SUCCESS) { \
8850 printf("\t%2d)", n++); \
8851 printf("+++++ PASSED:" #func"\n"); \
8853 } else if (ret == -ENOTSUP) { \
8854 printf("\t%2d)", n++); \
8855 printf("~~~~~ UNSUPP:" #func"\n"); \
8858 printf("\t%2d)", n++); \
8859 printf("----- FAILED:" #func"\n"); \
8865 test_DOCSIS_PROTO_uplink_all(void)
8867 int p = 0, u = 0, f = 0, n = 0;
8869 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(1, &docsis_test_case_1));
8870 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(2, &docsis_test_case_2));
8871 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(3, &docsis_test_case_3));
8872 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(4, &docsis_test_case_4));
8873 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(5, &docsis_test_case_5));
8874 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(6, &docsis_test_case_6));
8875 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(7, &docsis_test_case_7));
8876 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(8, &docsis_test_case_8));
8877 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(9, &docsis_test_case_9));
8878 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(10, &docsis_test_case_10));
8879 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(11, &docsis_test_case_11));
8880 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(12, &docsis_test_case_12));
8881 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(13, &docsis_test_case_13));
8882 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(14, &docsis_test_case_14));
8883 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(15, &docsis_test_case_15));
8884 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(16, &docsis_test_case_16));
8885 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(17, &docsis_test_case_17));
8886 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(18, &docsis_test_case_18));
8887 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(19, &docsis_test_case_19));
8888 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(20, &docsis_test_case_20));
8889 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(21, &docsis_test_case_21));
8890 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(22, &docsis_test_case_22));
8891 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(23, &docsis_test_case_23));
8892 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(24, &docsis_test_case_24));
8893 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(25, &docsis_test_case_25));
8894 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(26, &docsis_test_case_26));
8897 printf("## %s: %d passed out of %d (%d unsupported)\n",
8904 test_DOCSIS_PROTO_downlink_all(void)
8906 int p = 0, u = 0, f = 0, n = 0;
8908 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(1, &docsis_test_case_1));
8909 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(2, &docsis_test_case_2));
8910 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(3, &docsis_test_case_3));
8911 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(4, &docsis_test_case_4));
8912 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(5, &docsis_test_case_5));
8913 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(6, &docsis_test_case_6));
8914 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(7, &docsis_test_case_7));
8915 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(8, &docsis_test_case_8));
8916 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(9, &docsis_test_case_9));
8917 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(10, &docsis_test_case_10));
8918 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(11, &docsis_test_case_11));
8919 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(12, &docsis_test_case_12));
8920 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(13, &docsis_test_case_13));
8921 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(14, &docsis_test_case_14));
8922 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(15, &docsis_test_case_15));
8923 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(16, &docsis_test_case_16));
8924 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(17, &docsis_test_case_17));
8925 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(18, &docsis_test_case_18));
8926 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(19, &docsis_test_case_19));
8927 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(20, &docsis_test_case_20));
8928 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(21, &docsis_test_case_21));
8929 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(22, &docsis_test_case_22));
8930 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(23, &docsis_test_case_23));
8931 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(24, &docsis_test_case_24));
8932 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(25, &docsis_test_case_25));
8933 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(26, &docsis_test_case_26));
8936 printf("## %s: %d passed out of %d (%d unsupported)\n",
8943 test_DOCSIS_PROTO_all(void)
8945 struct crypto_testsuite_params *ts_params = &testsuite_params;
8946 struct crypto_unittest_params *ut_params = &unittest_params;
8947 struct rte_cryptodev_info dev_info;
8950 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8951 uint64_t feat_flags = dev_info.feature_flags;
8953 if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY))
8956 /* Set action type */
8957 ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
8958 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
8961 if (security_proto_supported(ut_params->type,
8962 RTE_SECURITY_PROTOCOL_DOCSIS) < 0)
8965 status = test_DOCSIS_PROTO_uplink_all();
8966 status += test_DOCSIS_PROTO_downlink_all();
8971 return TEST_SUCCESS;
8976 test_AES_GCM_authenticated_encryption_test_case_1(void)
8978 return test_authenticated_encryption(&gcm_test_case_1);
8982 test_AES_GCM_authenticated_encryption_test_case_2(void)
8984 return test_authenticated_encryption(&gcm_test_case_2);
8988 test_AES_GCM_authenticated_encryption_test_case_3(void)
8990 return test_authenticated_encryption(&gcm_test_case_3);
8994 test_AES_GCM_authenticated_encryption_test_case_4(void)
8996 return test_authenticated_encryption(&gcm_test_case_4);
9000 test_AES_GCM_authenticated_encryption_test_case_5(void)
9002 return test_authenticated_encryption(&gcm_test_case_5);
9006 test_AES_GCM_authenticated_encryption_test_case_6(void)
9008 return test_authenticated_encryption(&gcm_test_case_6);
9012 test_AES_GCM_authenticated_encryption_test_case_7(void)
9014 return test_authenticated_encryption(&gcm_test_case_7);
9018 test_AES_GCM_authenticated_encryption_test_case_8(void)
9020 return test_authenticated_encryption(&gcm_test_case_8);
9024 test_AES_GCM_J0_authenticated_encryption_test_case_1(void)
9026 return test_authenticated_encryption(&gcm_J0_test_case_1);
9030 test_AES_GCM_auth_encryption_test_case_192_1(void)
9032 return test_authenticated_encryption(&gcm_test_case_192_1);
9036 test_AES_GCM_auth_encryption_test_case_192_2(void)
9038 return test_authenticated_encryption(&gcm_test_case_192_2);
9042 test_AES_GCM_auth_encryption_test_case_192_3(void)
9044 return test_authenticated_encryption(&gcm_test_case_192_3);
9048 test_AES_GCM_auth_encryption_test_case_192_4(void)
9050 return test_authenticated_encryption(&gcm_test_case_192_4);
9054 test_AES_GCM_auth_encryption_test_case_192_5(void)
9056 return test_authenticated_encryption(&gcm_test_case_192_5);
9060 test_AES_GCM_auth_encryption_test_case_192_6(void)
9062 return test_authenticated_encryption(&gcm_test_case_192_6);
9066 test_AES_GCM_auth_encryption_test_case_192_7(void)
9068 return test_authenticated_encryption(&gcm_test_case_192_7);
9072 test_AES_GCM_auth_encryption_test_case_256_1(void)
9074 return test_authenticated_encryption(&gcm_test_case_256_1);
9078 test_AES_GCM_auth_encryption_test_case_256_2(void)
9080 return test_authenticated_encryption(&gcm_test_case_256_2);
9084 test_AES_GCM_auth_encryption_test_case_256_3(void)
9086 return test_authenticated_encryption(&gcm_test_case_256_3);
9090 test_AES_GCM_auth_encryption_test_case_256_4(void)
9092 return test_authenticated_encryption(&gcm_test_case_256_4);
9096 test_AES_GCM_auth_encryption_test_case_256_5(void)
9098 return test_authenticated_encryption(&gcm_test_case_256_5);
9102 test_AES_GCM_auth_encryption_test_case_256_6(void)
9104 return test_authenticated_encryption(&gcm_test_case_256_6);
9108 test_AES_GCM_auth_encryption_test_case_256_7(void)
9110 return test_authenticated_encryption(&gcm_test_case_256_7);
9114 test_AES_GCM_auth_encryption_test_case_aad_1(void)
9116 return test_authenticated_encryption(&gcm_test_case_aad_1);
9120 test_AES_GCM_auth_encryption_test_case_aad_2(void)
9122 return test_authenticated_encryption(&gcm_test_case_aad_2);
9126 test_AES_GCM_auth_encryption_fail_iv_corrupt(void)
9128 struct aead_test_data tdata;
9131 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9132 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9133 tdata.iv.data[0] += 1;
9134 res = test_authenticated_encryption(&tdata);
9135 if (res == -ENOTSUP)
9137 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9138 return TEST_SUCCESS;
9142 test_AES_GCM_auth_encryption_fail_in_data_corrupt(void)
9144 struct aead_test_data tdata;
9147 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9148 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9149 tdata.plaintext.data[0] += 1;
9150 res = test_authenticated_encryption(&tdata);
9151 if (res == -ENOTSUP)
9153 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9154 return TEST_SUCCESS;
9158 test_AES_GCM_auth_encryption_fail_out_data_corrupt(void)
9160 struct aead_test_data tdata;
9163 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9164 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9165 tdata.ciphertext.data[0] += 1;
9166 res = test_authenticated_encryption(&tdata);
9167 if (res == -ENOTSUP)
9169 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9170 return TEST_SUCCESS;
9174 test_AES_GCM_auth_encryption_fail_aad_len_corrupt(void)
9176 struct aead_test_data tdata;
9179 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9180 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9182 res = test_authenticated_encryption(&tdata);
9183 if (res == -ENOTSUP)
9185 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9186 return TEST_SUCCESS;
9190 test_AES_GCM_auth_encryption_fail_aad_corrupt(void)
9192 struct aead_test_data tdata;
9193 uint8_t aad[gcm_test_case_7.aad.len];
9196 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9197 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9198 memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
9200 tdata.aad.data = aad;
9201 res = test_authenticated_encryption(&tdata);
9202 if (res == -ENOTSUP)
9204 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9205 return TEST_SUCCESS;
9209 test_AES_GCM_auth_encryption_fail_tag_corrupt(void)
9211 struct aead_test_data tdata;
9214 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9215 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9216 tdata.auth_tag.data[0] += 1;
9217 res = test_authenticated_encryption(&tdata);
9218 if (res == -ENOTSUP)
9220 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9221 return TEST_SUCCESS;
9225 test_authenticated_decryption(const struct aead_test_data *tdata)
9227 struct crypto_testsuite_params *ts_params = &testsuite_params;
9228 struct crypto_unittest_params *ut_params = &unittest_params;
9233 struct rte_cryptodev_info dev_info;
9235 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
9236 uint64_t feat_flags = dev_info.feature_flags;
9238 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
9239 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
9240 printf("Device doesn't support RAW data-path APIs.\n");
9244 /* Verify the capabilities */
9245 struct rte_cryptodev_sym_capability_idx cap_idx;
9246 const struct rte_cryptodev_symmetric_capability *capability;
9247 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
9248 cap_idx.algo.aead = tdata->algo;
9249 capability = rte_cryptodev_sym_capability_get(
9250 ts_params->valid_devs[0], &cap_idx);
9251 if (capability == NULL)
9253 if (rte_cryptodev_sym_capability_check_aead(
9254 capability, tdata->key.len, tdata->auth_tag.len,
9255 tdata->aad.len, tdata->iv.len))
9258 /* Create AEAD session */
9259 retval = create_aead_session(ts_params->valid_devs[0],
9261 RTE_CRYPTO_AEAD_OP_DECRYPT,
9262 tdata->key.data, tdata->key.len,
9263 tdata->aad.len, tdata->auth_tag.len,
9268 /* alloc mbuf and set payload */
9269 if (tdata->aad.len > MBUF_SIZE) {
9270 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
9271 /* Populate full size of add data */
9272 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
9273 memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
9275 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9277 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9278 rte_pktmbuf_tailroom(ut_params->ibuf));
9280 /* Create AEAD operation */
9281 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
9285 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9287 ut_params->op->sym->m_src = ut_params->ibuf;
9289 /* Process crypto operation */
9290 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
9291 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
9292 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
9293 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
9294 ut_params->op, 0, 0, 0, 0);
9296 TEST_ASSERT_NOT_NULL(
9297 process_crypto_request(ts_params->valid_devs[0],
9298 ut_params->op), "failed to process sym crypto op");
9300 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9301 "crypto op processing failed");
9303 if (ut_params->op->sym->m_dst)
9304 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
9307 plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
9309 ut_params->op->sym->cipher.data.offset);
9311 debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
9314 TEST_ASSERT_BUFFERS_ARE_EQUAL(
9316 tdata->plaintext.data,
9317 tdata->plaintext.len,
9318 "Plaintext data not as expected");
9320 TEST_ASSERT_EQUAL(ut_params->op->status,
9321 RTE_CRYPTO_OP_STATUS_SUCCESS,
9322 "Authentication failed");
9328 test_AES_GCM_authenticated_decryption_test_case_1(void)
9330 return test_authenticated_decryption(&gcm_test_case_1);
9334 test_AES_GCM_authenticated_decryption_test_case_2(void)
9336 return test_authenticated_decryption(&gcm_test_case_2);
9340 test_AES_GCM_authenticated_decryption_test_case_3(void)
9342 return test_authenticated_decryption(&gcm_test_case_3);
9346 test_AES_GCM_authenticated_decryption_test_case_4(void)
9348 return test_authenticated_decryption(&gcm_test_case_4);
9352 test_AES_GCM_authenticated_decryption_test_case_5(void)
9354 return test_authenticated_decryption(&gcm_test_case_5);
9358 test_AES_GCM_authenticated_decryption_test_case_6(void)
9360 return test_authenticated_decryption(&gcm_test_case_6);
9364 test_AES_GCM_authenticated_decryption_test_case_7(void)
9366 return test_authenticated_decryption(&gcm_test_case_7);
9370 test_AES_GCM_authenticated_decryption_test_case_8(void)
9372 return test_authenticated_decryption(&gcm_test_case_8);
9376 test_AES_GCM_J0_authenticated_decryption_test_case_1(void)
9378 return test_authenticated_decryption(&gcm_J0_test_case_1);
9382 test_AES_GCM_auth_decryption_test_case_192_1(void)
9384 return test_authenticated_decryption(&gcm_test_case_192_1);
9388 test_AES_GCM_auth_decryption_test_case_192_2(void)
9390 return test_authenticated_decryption(&gcm_test_case_192_2);
9394 test_AES_GCM_auth_decryption_test_case_192_3(void)
9396 return test_authenticated_decryption(&gcm_test_case_192_3);
9400 test_AES_GCM_auth_decryption_test_case_192_4(void)
9402 return test_authenticated_decryption(&gcm_test_case_192_4);
9406 test_AES_GCM_auth_decryption_test_case_192_5(void)
9408 return test_authenticated_decryption(&gcm_test_case_192_5);
9412 test_AES_GCM_auth_decryption_test_case_192_6(void)
9414 return test_authenticated_decryption(&gcm_test_case_192_6);
9418 test_AES_GCM_auth_decryption_test_case_192_7(void)
9420 return test_authenticated_decryption(&gcm_test_case_192_7);
9424 test_AES_GCM_auth_decryption_test_case_256_1(void)
9426 return test_authenticated_decryption(&gcm_test_case_256_1);
9430 test_AES_GCM_auth_decryption_test_case_256_2(void)
9432 return test_authenticated_decryption(&gcm_test_case_256_2);
9436 test_AES_GCM_auth_decryption_test_case_256_3(void)
9438 return test_authenticated_decryption(&gcm_test_case_256_3);
9442 test_AES_GCM_auth_decryption_test_case_256_4(void)
9444 return test_authenticated_decryption(&gcm_test_case_256_4);
9448 test_AES_GCM_auth_decryption_test_case_256_5(void)
9450 return test_authenticated_decryption(&gcm_test_case_256_5);
9454 test_AES_GCM_auth_decryption_test_case_256_6(void)
9456 return test_authenticated_decryption(&gcm_test_case_256_6);
9460 test_AES_GCM_auth_decryption_test_case_256_7(void)
9462 return test_authenticated_decryption(&gcm_test_case_256_7);
9466 test_AES_GCM_auth_decryption_test_case_aad_1(void)
9468 return test_authenticated_decryption(&gcm_test_case_aad_1);
9472 test_AES_GCM_auth_decryption_test_case_aad_2(void)
9474 return test_authenticated_decryption(&gcm_test_case_aad_2);
9478 test_AES_GCM_auth_decryption_fail_iv_corrupt(void)
9480 struct aead_test_data tdata;
9483 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9484 tdata.iv.data[0] += 1;
9485 res = test_authenticated_decryption(&tdata);
9486 if (res == -ENOTSUP)
9488 TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
9489 return TEST_SUCCESS;
9493 test_AES_GCM_auth_decryption_fail_in_data_corrupt(void)
9495 struct aead_test_data tdata;
9498 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9499 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9500 tdata.plaintext.data[0] += 1;
9501 res = test_authenticated_decryption(&tdata);
9502 if (res == -ENOTSUP)
9504 TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
9505 return TEST_SUCCESS;
9509 test_AES_GCM_auth_decryption_fail_out_data_corrupt(void)
9511 struct aead_test_data tdata;
9514 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9515 tdata.ciphertext.data[0] += 1;
9516 res = test_authenticated_decryption(&tdata);
9517 if (res == -ENOTSUP)
9519 TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
9520 return TEST_SUCCESS;
9524 test_AES_GCM_auth_decryption_fail_aad_len_corrupt(void)
9526 struct aead_test_data tdata;
9529 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9531 res = test_authenticated_decryption(&tdata);
9532 if (res == -ENOTSUP)
9534 TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
9535 return TEST_SUCCESS;
9539 test_AES_GCM_auth_decryption_fail_aad_corrupt(void)
9541 struct aead_test_data tdata;
9542 uint8_t aad[gcm_test_case_7.aad.len];
9545 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9546 memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
9548 tdata.aad.data = aad;
9549 res = test_authenticated_decryption(&tdata);
9550 if (res == -ENOTSUP)
9552 TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
9553 return TEST_SUCCESS;
9557 test_AES_GCM_auth_decryption_fail_tag_corrupt(void)
9559 struct aead_test_data tdata;
9562 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9563 tdata.auth_tag.data[0] += 1;
9564 res = test_authenticated_decryption(&tdata);
9565 if (res == -ENOTSUP)
9567 TEST_ASSERT_EQUAL(res, TEST_FAILED, "authentication not failed");
9568 return TEST_SUCCESS;
9572 test_authenticated_encryption_oop(const struct aead_test_data *tdata)
9574 struct crypto_testsuite_params *ts_params = &testsuite_params;
9575 struct crypto_unittest_params *ut_params = &unittest_params;
9578 uint8_t *ciphertext, *auth_tag;
9579 uint16_t plaintext_pad_len;
9581 /* Verify the capabilities */
9582 struct rte_cryptodev_sym_capability_idx cap_idx;
9583 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
9584 cap_idx.algo.aead = tdata->algo;
9585 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9589 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
9592 /* not supported with CPU crypto */
9593 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
9596 /* Create AEAD session */
9597 retval = create_aead_session(ts_params->valid_devs[0],
9599 RTE_CRYPTO_AEAD_OP_ENCRYPT,
9600 tdata->key.data, tdata->key.len,
9601 tdata->aad.len, tdata->auth_tag.len,
9606 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9607 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9609 /* clear mbuf payload */
9610 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9611 rte_pktmbuf_tailroom(ut_params->ibuf));
9612 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
9613 rte_pktmbuf_tailroom(ut_params->obuf));
9615 /* Create AEAD operation */
9616 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
9620 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9622 ut_params->op->sym->m_src = ut_params->ibuf;
9623 ut_params->op->sym->m_dst = ut_params->obuf;
9625 /* Process crypto operation */
9626 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
9627 ut_params->op), "failed to process sym crypto op");
9629 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9630 "crypto op processing failed");
9632 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
9634 ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
9635 ut_params->op->sym->cipher.data.offset);
9636 auth_tag = ciphertext + plaintext_pad_len;
9638 debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
9639 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
9642 TEST_ASSERT_BUFFERS_ARE_EQUAL(
9644 tdata->ciphertext.data,
9645 tdata->ciphertext.len,
9646 "Ciphertext data not as expected");
9648 TEST_ASSERT_BUFFERS_ARE_EQUAL(
9650 tdata->auth_tag.data,
9651 tdata->auth_tag.len,
9652 "Generated auth tag not as expected");
9659 test_AES_GCM_authenticated_encryption_oop_test_case_1(void)
9661 return test_authenticated_encryption_oop(&gcm_test_case_5);
9665 test_authenticated_decryption_oop(const struct aead_test_data *tdata)
9667 struct crypto_testsuite_params *ts_params = &testsuite_params;
9668 struct crypto_unittest_params *ut_params = &unittest_params;
9673 /* Verify the capabilities */
9674 struct rte_cryptodev_sym_capability_idx cap_idx;
9675 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
9676 cap_idx.algo.aead = tdata->algo;
9677 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9681 /* not supported with CPU crypto and raw data-path APIs*/
9682 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO ||
9683 global_api_test_type == CRYPTODEV_RAW_API_TEST)
9686 /* Create AEAD session */
9687 retval = create_aead_session(ts_params->valid_devs[0],
9689 RTE_CRYPTO_AEAD_OP_DECRYPT,
9690 tdata->key.data, tdata->key.len,
9691 tdata->aad.len, tdata->auth_tag.len,
9696 /* alloc mbuf and set payload */
9697 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9698 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9700 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9701 rte_pktmbuf_tailroom(ut_params->ibuf));
9702 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
9703 rte_pktmbuf_tailroom(ut_params->obuf));
9705 /* Create AEAD operation */
9706 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
9710 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9712 ut_params->op->sym->m_src = ut_params->ibuf;
9713 ut_params->op->sym->m_dst = ut_params->obuf;
9715 /* Process crypto operation */
9716 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
9717 ut_params->op), "failed to process sym crypto op");
9719 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9720 "crypto op processing failed");
9722 plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
9723 ut_params->op->sym->cipher.data.offset);
9725 debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
9728 TEST_ASSERT_BUFFERS_ARE_EQUAL(
9730 tdata->plaintext.data,
9731 tdata->plaintext.len,
9732 "Plaintext data not as expected");
9734 TEST_ASSERT_EQUAL(ut_params->op->status,
9735 RTE_CRYPTO_OP_STATUS_SUCCESS,
9736 "Authentication failed");
9741 test_AES_GCM_authenticated_decryption_oop_test_case_1(void)
9743 return test_authenticated_decryption_oop(&gcm_test_case_5);
9747 test_authenticated_encryption_sessionless(
9748 const struct aead_test_data *tdata)
9750 struct crypto_testsuite_params *ts_params = &testsuite_params;
9751 struct crypto_unittest_params *ut_params = &unittest_params;
9754 uint8_t *ciphertext, *auth_tag;
9755 uint16_t plaintext_pad_len;
9756 uint8_t key[tdata->key.len + 1];
9757 struct rte_cryptodev_info dev_info;
9759 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
9760 uint64_t feat_flags = dev_info.feature_flags;
9762 if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
9763 printf("Device doesn't support Sessionless ops.\n");
9767 /* not supported with CPU crypto */
9768 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
9771 /* Verify the capabilities */
9772 struct rte_cryptodev_sym_capability_idx cap_idx;
9773 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
9774 cap_idx.algo.aead = tdata->algo;
9775 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9779 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9781 /* clear mbuf payload */
9782 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9783 rte_pktmbuf_tailroom(ut_params->ibuf));
9785 /* Create AEAD operation */
9786 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
9790 /* Create GCM xform */
9791 memcpy(key, tdata->key.data, tdata->key.len);
9792 retval = create_aead_xform(ut_params->op,
9794 RTE_CRYPTO_AEAD_OP_ENCRYPT,
9795 key, tdata->key.len,
9796 tdata->aad.len, tdata->auth_tag.len,
9801 ut_params->op->sym->m_src = ut_params->ibuf;
9803 TEST_ASSERT_EQUAL(ut_params->op->sess_type,
9804 RTE_CRYPTO_OP_SESSIONLESS,
9805 "crypto op session type not sessionless");
9807 /* Process crypto operation */
9808 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
9809 ut_params->op), "failed to process sym crypto op");
9811 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
9813 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9814 "crypto op status not success");
9816 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
9818 ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
9819 ut_params->op->sym->cipher.data.offset);
9820 auth_tag = ciphertext + plaintext_pad_len;
9822 debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
9823 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
9826 TEST_ASSERT_BUFFERS_ARE_EQUAL(
9828 tdata->ciphertext.data,
9829 tdata->ciphertext.len,
9830 "Ciphertext data not as expected");
9832 TEST_ASSERT_BUFFERS_ARE_EQUAL(
9834 tdata->auth_tag.data,
9835 tdata->auth_tag.len,
9836 "Generated auth tag not as expected");
9843 test_AES_GCM_authenticated_encryption_sessionless_test_case_1(void)
9845 return test_authenticated_encryption_sessionless(
9850 test_authenticated_decryption_sessionless(
9851 const struct aead_test_data *tdata)
9853 struct crypto_testsuite_params *ts_params = &testsuite_params;
9854 struct crypto_unittest_params *ut_params = &unittest_params;
9858 uint8_t key[tdata->key.len + 1];
9859 struct rte_cryptodev_info dev_info;
9861 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
9862 uint64_t feat_flags = dev_info.feature_flags;
9864 if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
9865 printf("Device doesn't support Sessionless ops.\n");
9869 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
9870 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
9871 printf("Device doesn't support RAW data-path APIs.\n");
9875 /* not supported with CPU crypto */
9876 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
9879 /* Verify the capabilities */
9880 struct rte_cryptodev_sym_capability_idx cap_idx;
9881 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
9882 cap_idx.algo.aead = tdata->algo;
9883 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9887 /* alloc mbuf and set payload */
9888 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9890 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9891 rte_pktmbuf_tailroom(ut_params->ibuf));
9893 /* Create AEAD operation */
9894 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
9898 /* Create AEAD xform */
9899 memcpy(key, tdata->key.data, tdata->key.len);
9900 retval = create_aead_xform(ut_params->op,
9902 RTE_CRYPTO_AEAD_OP_DECRYPT,
9903 key, tdata->key.len,
9904 tdata->aad.len, tdata->auth_tag.len,
9909 ut_params->op->sym->m_src = ut_params->ibuf;
9911 TEST_ASSERT_EQUAL(ut_params->op->sess_type,
9912 RTE_CRYPTO_OP_SESSIONLESS,
9913 "crypto op session type not sessionless");
9915 /* Process crypto operation */
9916 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
9917 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
9918 ut_params->op, 0, 0, 0, 0);
9920 TEST_ASSERT_NOT_NULL(process_crypto_request(
9921 ts_params->valid_devs[0], ut_params->op),
9922 "failed to process sym crypto op");
9924 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
9926 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9927 "crypto op status not success");
9929 plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
9930 ut_params->op->sym->cipher.data.offset);
9932 debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
9935 TEST_ASSERT_BUFFERS_ARE_EQUAL(
9937 tdata->plaintext.data,
9938 tdata->plaintext.len,
9939 "Plaintext data not as expected");
9941 TEST_ASSERT_EQUAL(ut_params->op->status,
9942 RTE_CRYPTO_OP_STATUS_SUCCESS,
9943 "Authentication failed");
9948 test_AES_GCM_authenticated_decryption_sessionless_test_case_1(void)
9950 return test_authenticated_decryption_sessionless(
9955 test_AES_CCM_authenticated_encryption_test_case_128_1(void)
9957 return test_authenticated_encryption(&ccm_test_case_128_1);
9961 test_AES_CCM_authenticated_encryption_test_case_128_2(void)
9963 return test_authenticated_encryption(&ccm_test_case_128_2);
9967 test_AES_CCM_authenticated_encryption_test_case_128_3(void)
9969 return test_authenticated_encryption(&ccm_test_case_128_3);
9973 test_AES_CCM_authenticated_decryption_test_case_128_1(void)
9975 return test_authenticated_decryption(&ccm_test_case_128_1);
9979 test_AES_CCM_authenticated_decryption_test_case_128_2(void)
9981 return test_authenticated_decryption(&ccm_test_case_128_2);
9985 test_AES_CCM_authenticated_decryption_test_case_128_3(void)
9987 return test_authenticated_decryption(&ccm_test_case_128_3);
9991 test_AES_CCM_authenticated_encryption_test_case_192_1(void)
9993 return test_authenticated_encryption(&ccm_test_case_192_1);
9997 test_AES_CCM_authenticated_encryption_test_case_192_2(void)
9999 return test_authenticated_encryption(&ccm_test_case_192_2);
10003 test_AES_CCM_authenticated_encryption_test_case_192_3(void)
10005 return test_authenticated_encryption(&ccm_test_case_192_3);
10009 test_AES_CCM_authenticated_decryption_test_case_192_1(void)
10011 return test_authenticated_decryption(&ccm_test_case_192_1);
10015 test_AES_CCM_authenticated_decryption_test_case_192_2(void)
10017 return test_authenticated_decryption(&ccm_test_case_192_2);
10021 test_AES_CCM_authenticated_decryption_test_case_192_3(void)
10023 return test_authenticated_decryption(&ccm_test_case_192_3);
10027 test_AES_CCM_authenticated_encryption_test_case_256_1(void)
10029 return test_authenticated_encryption(&ccm_test_case_256_1);
10033 test_AES_CCM_authenticated_encryption_test_case_256_2(void)
10035 return test_authenticated_encryption(&ccm_test_case_256_2);
10039 test_AES_CCM_authenticated_encryption_test_case_256_3(void)
10041 return test_authenticated_encryption(&ccm_test_case_256_3);
10045 test_AES_CCM_authenticated_decryption_test_case_256_1(void)
10047 return test_authenticated_decryption(&ccm_test_case_256_1);
10051 test_AES_CCM_authenticated_decryption_test_case_256_2(void)
10053 return test_authenticated_decryption(&ccm_test_case_256_2);
10057 test_AES_CCM_authenticated_decryption_test_case_256_3(void)
10059 return test_authenticated_decryption(&ccm_test_case_256_3);
10065 struct crypto_testsuite_params *ts_params = &testsuite_params;
10066 struct rte_cryptodev_stats stats;
10068 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10071 /* Verify the capabilities */
10072 struct rte_cryptodev_sym_capability_idx cap_idx;
10073 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10074 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
10075 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10078 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10079 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
10080 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10084 if (rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
10088 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
10089 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
10090 &stats) == -ENODEV),
10091 "rte_cryptodev_stats_get invalid dev failed");
10092 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
10093 "rte_cryptodev_stats_get invalid Param failed");
10095 /* Test expected values */
10096 test_AES_CBC_HMAC_SHA1_encrypt_digest();
10097 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
10099 "rte_cryptodev_stats_get failed");
10100 TEST_ASSERT((stats.enqueued_count == 1),
10101 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10102 TEST_ASSERT((stats.dequeued_count == 1),
10103 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10104 TEST_ASSERT((stats.enqueue_err_count == 0),
10105 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10106 TEST_ASSERT((stats.dequeue_err_count == 0),
10107 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10109 /* invalid device but should ignore and not reset device stats*/
10110 rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
10111 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
10113 "rte_cryptodev_stats_get failed");
10114 TEST_ASSERT((stats.enqueued_count == 1),
10115 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10117 /* check that a valid reset clears stats */
10118 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
10119 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
10121 "rte_cryptodev_stats_get failed");
10122 TEST_ASSERT((stats.enqueued_count == 0),
10123 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10124 TEST_ASSERT((stats.dequeued_count == 0),
10125 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10127 return TEST_SUCCESS;
10130 static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
10131 struct crypto_unittest_params *ut_params,
10132 enum rte_crypto_auth_operation op,
10133 const struct HMAC_MD5_vector *test_case)
10137 memcpy(key, test_case->key.data, test_case->key.len);
10139 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10140 ut_params->auth_xform.next = NULL;
10141 ut_params->auth_xform.auth.op = op;
10143 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC;
10145 ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN;
10146 ut_params->auth_xform.auth.key.length = test_case->key.len;
10147 ut_params->auth_xform.auth.key.data = key;
10149 ut_params->sess = rte_cryptodev_sym_session_create(
10150 ts_params->session_mpool);
10152 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10153 ut_params->sess, &ut_params->auth_xform,
10154 ts_params->session_priv_mpool);
10156 if (ut_params->sess == NULL)
10157 return TEST_FAILED;
10159 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10161 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10162 rte_pktmbuf_tailroom(ut_params->ibuf));
10167 static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
10168 const struct HMAC_MD5_vector *test_case,
10169 uint8_t **plaintext)
10171 uint16_t plaintext_pad_len;
10173 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
10175 plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
10178 *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
10179 plaintext_pad_len);
10180 memcpy(*plaintext, test_case->plaintext.data,
10181 test_case->plaintext.len);
10183 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
10184 ut_params->ibuf, MD5_DIGEST_LEN);
10185 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
10186 "no room to append digest");
10187 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
10188 ut_params->ibuf, plaintext_pad_len);
10190 if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
10191 rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data,
10192 test_case->auth_tag.len);
10195 sym_op->auth.data.offset = 0;
10196 sym_op->auth.data.length = test_case->plaintext.len;
10198 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10199 ut_params->op->sym->m_src = ut_params->ibuf;
10205 test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
10207 uint16_t plaintext_pad_len;
10208 uint8_t *plaintext, *auth_tag;
10210 struct crypto_testsuite_params *ts_params = &testsuite_params;
10211 struct crypto_unittest_params *ut_params = &unittest_params;
10212 struct rte_cryptodev_info dev_info;
10214 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10215 uint64_t feat_flags = dev_info.feature_flags;
10217 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10218 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10219 printf("Device doesn't support RAW data-path APIs.\n");
10223 /* Verify the capabilities */
10224 struct rte_cryptodev_sym_capability_idx cap_idx;
10225 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10226 cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
10227 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10231 if (MD5_HMAC_create_session(ts_params, ut_params,
10232 RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
10233 return TEST_FAILED;
10235 /* Generate Crypto op data structure */
10236 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10237 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10238 TEST_ASSERT_NOT_NULL(ut_params->op,
10239 "Failed to allocate symmetric crypto operation struct");
10241 plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
10244 if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
10245 return TEST_FAILED;
10247 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10248 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
10250 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10251 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10252 ut_params->op, 0, 1, 0, 0);
10254 TEST_ASSERT_NOT_NULL(
10255 process_crypto_request(ts_params->valid_devs[0],
10257 "failed to process sym crypto op");
10259 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10260 "crypto op processing failed");
10262 if (ut_params->op->sym->m_dst) {
10263 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
10264 uint8_t *, plaintext_pad_len);
10266 auth_tag = plaintext + plaintext_pad_len;
10269 TEST_ASSERT_BUFFERS_ARE_EQUAL(
10271 test_case->auth_tag.data,
10272 test_case->auth_tag.len,
10273 "HMAC_MD5 generated tag not as expected");
10275 return TEST_SUCCESS;
10279 test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
10281 uint8_t *plaintext;
10283 struct crypto_testsuite_params *ts_params = &testsuite_params;
10284 struct crypto_unittest_params *ut_params = &unittest_params;
10285 struct rte_cryptodev_info dev_info;
10287 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10288 uint64_t feat_flags = dev_info.feature_flags;
10290 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10291 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10292 printf("Device doesn't support RAW data-path APIs.\n");
10296 /* Verify the capabilities */
10297 struct rte_cryptodev_sym_capability_idx cap_idx;
10298 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10299 cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
10300 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10304 if (MD5_HMAC_create_session(ts_params, ut_params,
10305 RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
10306 return TEST_FAILED;
10309 /* Generate Crypto op data structure */
10310 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10311 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10312 TEST_ASSERT_NOT_NULL(ut_params->op,
10313 "Failed to allocate symmetric crypto operation struct");
10315 if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
10316 return TEST_FAILED;
10318 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10319 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
10321 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10322 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10323 ut_params->op, 0, 1, 0, 0);
10325 TEST_ASSERT_NOT_NULL(
10326 process_crypto_request(ts_params->valid_devs[0],
10328 "failed to process sym crypto op");
10330 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10331 "HMAC_MD5 crypto op processing failed");
10333 return TEST_SUCCESS;
10337 test_MD5_HMAC_generate_case_1(void)
10339 return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1);
10343 test_MD5_HMAC_verify_case_1(void)
10345 return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1);
10349 test_MD5_HMAC_generate_case_2(void)
10351 return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2);
10355 test_MD5_HMAC_verify_case_2(void)
10357 return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2);
10361 test_multi_session(void)
10363 struct crypto_testsuite_params *ts_params = &testsuite_params;
10364 struct crypto_unittest_params *ut_params = &unittest_params;
10366 struct rte_cryptodev_info dev_info;
10367 struct rte_cryptodev_sym_session **sessions;
10371 /* Verify the capabilities */
10372 struct rte_cryptodev_sym_capability_idx cap_idx;
10373 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10374 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
10375 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10378 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10379 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
10380 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10384 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
10385 aes_cbc_key, hmac_sha512_key);
10388 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10390 sessions = rte_malloc(NULL,
10391 (sizeof(struct rte_cryptodev_sym_session *) *
10392 MAX_NB_SESSIONS) + 1, 0);
10394 /* Create multiple crypto sessions*/
10395 for (i = 0; i < MAX_NB_SESSIONS; i++) {
10397 sessions[i] = rte_cryptodev_sym_session_create(
10398 ts_params->session_mpool);
10400 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10401 sessions[i], &ut_params->auth_xform,
10402 ts_params->session_priv_mpool);
10403 TEST_ASSERT_NOT_NULL(sessions[i],
10404 "Session creation failed at session number %u",
10407 /* Attempt to send a request on each session */
10408 TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform(
10412 catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
10413 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
10415 "Failed to perform decrypt on request number %u.", i);
10416 /* free crypto operation structure */
10418 rte_crypto_op_free(ut_params->op);
10421 * free mbuf - both obuf and ibuf are usually the same,
10422 * so check if they point at the same address is necessary,
10423 * to avoid freeing the mbuf twice.
10425 if (ut_params->obuf) {
10426 rte_pktmbuf_free(ut_params->obuf);
10427 if (ut_params->ibuf == ut_params->obuf)
10428 ut_params->ibuf = 0;
10429 ut_params->obuf = 0;
10431 if (ut_params->ibuf) {
10432 rte_pktmbuf_free(ut_params->ibuf);
10433 ut_params->ibuf = 0;
10437 /* Next session create should fail */
10438 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10439 sessions[i], &ut_params->auth_xform,
10440 ts_params->session_priv_mpool);
10441 TEST_ASSERT_NULL(sessions[i],
10442 "Session creation succeeded unexpectedly!");
10444 for (i = 0; i < MAX_NB_SESSIONS; i++) {
10445 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
10447 rte_cryptodev_sym_session_free(sessions[i]);
10450 rte_free(sessions);
10452 return TEST_SUCCESS;
10455 struct multi_session_params {
10456 struct crypto_unittest_params ut_params;
10457 uint8_t *cipher_key;
10459 const uint8_t *cipher;
10460 const uint8_t *digest;
10464 #define MB_SESSION_NUMBER 3
10467 test_multi_session_random_usage(void)
10469 struct crypto_testsuite_params *ts_params = &testsuite_params;
10470 struct rte_cryptodev_info dev_info;
10471 struct rte_cryptodev_sym_session **sessions;
10473 struct multi_session_params ut_paramz[] = {
10476 .cipher_key = ms_aes_cbc_key0,
10477 .hmac_key = ms_hmac_key0,
10478 .cipher = ms_aes_cbc_cipher0,
10479 .digest = ms_hmac_digest0,
10480 .iv = ms_aes_cbc_iv0
10483 .cipher_key = ms_aes_cbc_key1,
10484 .hmac_key = ms_hmac_key1,
10485 .cipher = ms_aes_cbc_cipher1,
10486 .digest = ms_hmac_digest1,
10487 .iv = ms_aes_cbc_iv1
10490 .cipher_key = ms_aes_cbc_key2,
10491 .hmac_key = ms_hmac_key2,
10492 .cipher = ms_aes_cbc_cipher2,
10493 .digest = ms_hmac_digest2,
10494 .iv = ms_aes_cbc_iv2
10499 /* Verify the capabilities */
10500 struct rte_cryptodev_sym_capability_idx cap_idx;
10501 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10502 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
10503 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10506 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10507 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
10508 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10512 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10514 sessions = rte_malloc(NULL,
10515 (sizeof(struct rte_cryptodev_sym_session *)
10516 * MAX_NB_SESSIONS) + 1, 0);
10518 for (i = 0; i < MB_SESSION_NUMBER; i++) {
10519 sessions[i] = rte_cryptodev_sym_session_create(
10520 ts_params->session_mpool);
10522 rte_memcpy(&ut_paramz[i].ut_params, &unittest_params,
10523 sizeof(struct crypto_unittest_params));
10525 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
10526 &ut_paramz[i].ut_params,
10527 ut_paramz[i].cipher_key, ut_paramz[i].hmac_key);
10529 /* Create multiple crypto sessions*/
10530 rte_cryptodev_sym_session_init(
10531 ts_params->valid_devs[0],
10533 &ut_paramz[i].ut_params.auth_xform,
10534 ts_params->session_priv_mpool);
10536 TEST_ASSERT_NOT_NULL(sessions[i],
10537 "Session creation failed at session number %u",
10543 for (i = 0; i < 40000; i++) {
10545 j = rand() % MB_SESSION_NUMBER;
10547 TEST_ASSERT_SUCCESS(
10548 test_AES_CBC_HMAC_SHA512_decrypt_perform(
10550 &ut_paramz[j].ut_params,
10551 ts_params, ut_paramz[j].cipher,
10552 ut_paramz[j].digest,
10554 "Failed to perform decrypt on request number %u.", i);
10556 if (ut_paramz[j].ut_params.op)
10557 rte_crypto_op_free(ut_paramz[j].ut_params.op);
10560 * free mbuf - both obuf and ibuf are usually the same,
10561 * so check if they point at the same address is necessary,
10562 * to avoid freeing the mbuf twice.
10564 if (ut_paramz[j].ut_params.obuf) {
10565 rte_pktmbuf_free(ut_paramz[j].ut_params.obuf);
10566 if (ut_paramz[j].ut_params.ibuf
10567 == ut_paramz[j].ut_params.obuf)
10568 ut_paramz[j].ut_params.ibuf = 0;
10569 ut_paramz[j].ut_params.obuf = 0;
10571 if (ut_paramz[j].ut_params.ibuf) {
10572 rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf);
10573 ut_paramz[j].ut_params.ibuf = 0;
10577 for (i = 0; i < MB_SESSION_NUMBER; i++) {
10578 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
10580 rte_cryptodev_sym_session_free(sessions[i]);
10583 rte_free(sessions);
10585 return TEST_SUCCESS;
10588 uint8_t orig_data[] = {0xab, 0xab, 0xab, 0xab,
10589 0xab, 0xab, 0xab, 0xab,
10590 0xab, 0xab, 0xab, 0xab,
10591 0xab, 0xab, 0xab, 0xab};
10594 test_null_invalid_operation(void)
10596 struct crypto_testsuite_params *ts_params = &testsuite_params;
10597 struct crypto_unittest_params *ut_params = &unittest_params;
10600 /* This test is for NULL PMD only */
10601 if (gbl_driver_id != rte_cryptodev_driver_id_get(
10602 RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
10605 /* Setup Cipher Parameters */
10606 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10607 ut_params->cipher_xform.next = NULL;
10609 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
10610 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
10612 ut_params->sess = rte_cryptodev_sym_session_create(
10613 ts_params->session_mpool);
10615 /* Create Crypto session*/
10616 ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10617 ut_params->sess, &ut_params->cipher_xform,
10618 ts_params->session_priv_mpool);
10619 TEST_ASSERT(ret < 0,
10620 "Session creation succeeded unexpectedly");
10623 /* Setup HMAC Parameters */
10624 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10625 ut_params->auth_xform.next = NULL;
10627 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
10628 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
10630 ut_params->sess = rte_cryptodev_sym_session_create(
10631 ts_params->session_mpool);
10633 /* Create Crypto session*/
10634 ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10635 ut_params->sess, &ut_params->auth_xform,
10636 ts_params->session_priv_mpool);
10637 TEST_ASSERT(ret < 0,
10638 "Session creation succeeded unexpectedly");
10640 return TEST_SUCCESS;
10644 #define NULL_BURST_LENGTH (32)
10647 test_null_burst_operation(void)
10649 struct crypto_testsuite_params *ts_params = &testsuite_params;
10650 struct crypto_unittest_params *ut_params = &unittest_params;
10652 unsigned i, burst_len = NULL_BURST_LENGTH;
10654 struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
10655 struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
10657 /* This test is for NULL PMD only */
10658 if (gbl_driver_id != rte_cryptodev_driver_id_get(
10659 RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
10662 /* Setup Cipher Parameters */
10663 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10664 ut_params->cipher_xform.next = &ut_params->auth_xform;
10666 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
10667 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
10669 /* Setup HMAC Parameters */
10670 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10671 ut_params->auth_xform.next = NULL;
10673 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
10674 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
10676 ut_params->sess = rte_cryptodev_sym_session_create(
10677 ts_params->session_mpool);
10679 /* Create Crypto session*/
10680 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10681 ut_params->sess, &ut_params->cipher_xform,
10682 ts_params->session_priv_mpool);
10683 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
10685 TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
10686 RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
10687 burst_len, "failed to generate burst of crypto ops");
10689 /* Generate an operation for each mbuf in burst */
10690 for (i = 0; i < burst_len; i++) {
10691 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10693 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
10695 unsigned *data = (unsigned *)rte_pktmbuf_append(m,
10699 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
10701 burst[i]->sym->m_src = m;
10704 /* Process crypto operation */
10705 TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
10706 0, burst, burst_len),
10708 "Error enqueuing burst");
10710 TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
10711 0, burst_dequeued, burst_len),
10713 "Error dequeuing burst");
10716 for (i = 0; i < burst_len; i++) {
10718 *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
10719 *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
10721 "data not as expected");
10723 rte_pktmbuf_free(burst[i]->sym->m_src);
10724 rte_crypto_op_free(burst[i]);
10727 return TEST_SUCCESS;
10731 generate_gmac_large_plaintext(uint8_t *data)
10735 for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32)
10736 memcpy(&data[i], &data[0], 32);
10740 create_gmac_operation(enum rte_crypto_auth_operation op,
10741 const struct gmac_test_data *tdata)
10743 struct crypto_testsuite_params *ts_params = &testsuite_params;
10744 struct crypto_unittest_params *ut_params = &unittest_params;
10745 struct rte_crypto_sym_op *sym_op;
10747 uint32_t plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
10749 /* Generate Crypto op data structure */
10750 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10751 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10752 TEST_ASSERT_NOT_NULL(ut_params->op,
10753 "Failed to allocate symmetric crypto operation struct");
10755 sym_op = ut_params->op->sym;
10757 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
10758 ut_params->ibuf, tdata->gmac_tag.len);
10759 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
10760 "no room to append digest");
10762 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
10763 ut_params->ibuf, plaintext_pad_len);
10765 if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
10766 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
10767 tdata->gmac_tag.len);
10768 debug_hexdump(stdout, "digest:",
10769 sym_op->auth.digest.data,
10770 tdata->gmac_tag.len);
10773 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
10774 uint8_t *, IV_OFFSET);
10776 rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
10778 debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
10780 sym_op->cipher.data.length = 0;
10781 sym_op->cipher.data.offset = 0;
10783 sym_op->auth.data.offset = 0;
10784 sym_op->auth.data.length = tdata->plaintext.len;
10790 create_gmac_operation_sgl(enum rte_crypto_auth_operation op,
10791 const struct gmac_test_data *tdata,
10792 void *digest_mem, uint64_t digest_phys)
10794 struct crypto_testsuite_params *ts_params = &testsuite_params;
10795 struct crypto_unittest_params *ut_params = &unittest_params;
10796 struct rte_crypto_sym_op *sym_op;
10798 /* Generate Crypto op data structure */
10799 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10800 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10801 TEST_ASSERT_NOT_NULL(ut_params->op,
10802 "Failed to allocate symmetric crypto operation struct");
10804 sym_op = ut_params->op->sym;
10806 sym_op->auth.digest.data = digest_mem;
10807 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
10808 "no room to append digest");
10810 sym_op->auth.digest.phys_addr = digest_phys;
10812 if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
10813 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
10814 tdata->gmac_tag.len);
10815 debug_hexdump(stdout, "digest:",
10816 sym_op->auth.digest.data,
10817 tdata->gmac_tag.len);
10820 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
10821 uint8_t *, IV_OFFSET);
10823 rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
10825 debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
10827 sym_op->cipher.data.length = 0;
10828 sym_op->cipher.data.offset = 0;
10830 sym_op->auth.data.offset = 0;
10831 sym_op->auth.data.length = tdata->plaintext.len;
10836 static int create_gmac_session(uint8_t dev_id,
10837 const struct gmac_test_data *tdata,
10838 enum rte_crypto_auth_operation auth_op)
10840 uint8_t auth_key[tdata->key.len];
10842 struct crypto_testsuite_params *ts_params = &testsuite_params;
10843 struct crypto_unittest_params *ut_params = &unittest_params;
10845 memcpy(auth_key, tdata->key.data, tdata->key.len);
10847 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10848 ut_params->auth_xform.next = NULL;
10850 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
10851 ut_params->auth_xform.auth.op = auth_op;
10852 ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
10853 ut_params->auth_xform.auth.key.length = tdata->key.len;
10854 ut_params->auth_xform.auth.key.data = auth_key;
10855 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
10856 ut_params->auth_xform.auth.iv.length = tdata->iv.len;
10859 ut_params->sess = rte_cryptodev_sym_session_create(
10860 ts_params->session_mpool);
10862 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
10863 &ut_params->auth_xform,
10864 ts_params->session_priv_mpool);
10866 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
10872 test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
10874 struct crypto_testsuite_params *ts_params = &testsuite_params;
10875 struct crypto_unittest_params *ut_params = &unittest_params;
10876 struct rte_cryptodev_info dev_info;
10878 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10879 uint64_t feat_flags = dev_info.feature_flags;
10881 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10882 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10883 printf("Device doesn't support RAW data-path APIs.\n");
10889 uint8_t *auth_tag, *plaintext;
10890 uint16_t plaintext_pad_len;
10892 TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
10893 "No GMAC length in the source data");
10895 /* Verify the capabilities */
10896 struct rte_cryptodev_sym_capability_idx cap_idx;
10897 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10898 cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
10899 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10903 retval = create_gmac_session(ts_params->valid_devs[0],
10904 tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
10909 if (tdata->plaintext.len > MBUF_SIZE)
10910 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
10912 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10913 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
10914 "Failed to allocate input buffer in mempool");
10916 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10917 rte_pktmbuf_tailroom(ut_params->ibuf));
10919 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
10921 * Runtime generate the large plain text instead of use hard code
10922 * plain text vector. It is done to avoid create huge source file
10923 * with the test vector.
10925 if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
10926 generate_gmac_large_plaintext(tdata->plaintext.data);
10928 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
10929 plaintext_pad_len);
10930 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
10932 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
10933 debug_hexdump(stdout, "plaintext:", plaintext,
10934 tdata->plaintext.len);
10936 retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
10942 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10944 ut_params->op->sym->m_src = ut_params->ibuf;
10946 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10947 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
10949 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10950 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10951 ut_params->op, 0, 1, 0, 0);
10953 TEST_ASSERT_NOT_NULL(
10954 process_crypto_request(ts_params->valid_devs[0],
10955 ut_params->op), "failed to process sym crypto op");
10957 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10958 "crypto op processing failed");
10960 if (ut_params->op->sym->m_dst) {
10961 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
10962 uint8_t *, plaintext_pad_len);
10964 auth_tag = plaintext + plaintext_pad_len;
10967 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
10969 TEST_ASSERT_BUFFERS_ARE_EQUAL(
10971 tdata->gmac_tag.data,
10972 tdata->gmac_tag.len,
10973 "GMAC Generated auth tag not as expected");
10979 test_AES_GMAC_authentication_test_case_1(void)
10981 return test_AES_GMAC_authentication(&gmac_test_case_1);
10985 test_AES_GMAC_authentication_test_case_2(void)
10987 return test_AES_GMAC_authentication(&gmac_test_case_2);
10991 test_AES_GMAC_authentication_test_case_3(void)
10993 return test_AES_GMAC_authentication(&gmac_test_case_3);
10997 test_AES_GMAC_authentication_test_case_4(void)
10999 return test_AES_GMAC_authentication(&gmac_test_case_4);
11003 test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
11005 struct crypto_testsuite_params *ts_params = &testsuite_params;
11006 struct crypto_unittest_params *ut_params = &unittest_params;
11008 uint32_t plaintext_pad_len;
11009 uint8_t *plaintext;
11010 struct rte_cryptodev_info dev_info;
11012 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11013 uint64_t feat_flags = dev_info.feature_flags;
11015 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11016 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11017 printf("Device doesn't support RAW data-path APIs.\n");
11021 TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
11022 "No GMAC length in the source data");
11024 /* Verify the capabilities */
11025 struct rte_cryptodev_sym_capability_idx cap_idx;
11026 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11027 cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
11028 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11032 retval = create_gmac_session(ts_params->valid_devs[0],
11033 tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
11038 if (tdata->plaintext.len > MBUF_SIZE)
11039 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
11041 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11042 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
11043 "Failed to allocate input buffer in mempool");
11045 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11046 rte_pktmbuf_tailroom(ut_params->ibuf));
11048 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
11051 * Runtime generate the large plain text instead of use hard code
11052 * plain text vector. It is done to avoid create huge source file
11053 * with the test vector.
11055 if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
11056 generate_gmac_large_plaintext(tdata->plaintext.data);
11058 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11059 plaintext_pad_len);
11060 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
11062 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
11063 debug_hexdump(stdout, "plaintext:", plaintext,
11064 tdata->plaintext.len);
11066 retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
11072 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11074 ut_params->op->sym->m_src = ut_params->ibuf;
11076 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11077 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11079 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11080 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11081 ut_params->op, 0, 1, 0, 0);
11083 TEST_ASSERT_NOT_NULL(
11084 process_crypto_request(ts_params->valid_devs[0],
11085 ut_params->op), "failed to process sym crypto op");
11087 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11088 "crypto op processing failed");
11095 test_AES_GMAC_authentication_verify_test_case_1(void)
11097 return test_AES_GMAC_authentication_verify(&gmac_test_case_1);
11101 test_AES_GMAC_authentication_verify_test_case_2(void)
11103 return test_AES_GMAC_authentication_verify(&gmac_test_case_2);
11107 test_AES_GMAC_authentication_verify_test_case_3(void)
11109 return test_AES_GMAC_authentication_verify(&gmac_test_case_3);
11113 test_AES_GMAC_authentication_verify_test_case_4(void)
11115 return test_AES_GMAC_authentication_verify(&gmac_test_case_4);
11119 test_AES_GMAC_authentication_SGL(const struct gmac_test_data *tdata,
11122 struct crypto_testsuite_params *ts_params = &testsuite_params;
11123 struct crypto_unittest_params *ut_params = &unittest_params;
11124 struct rte_cryptodev_info dev_info;
11125 uint64_t feature_flags;
11126 unsigned int trn_data = 0;
11127 void *digest_mem = NULL;
11129 unsigned int to_trn = 0;
11130 struct rte_mbuf *buf = NULL;
11131 uint8_t *auth_tag, *plaintext;
11134 TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
11135 "No GMAC length in the source data");
11137 /* Verify the capabilities */
11138 struct rte_cryptodev_sym_capability_idx cap_idx;
11139 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11140 cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
11141 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11145 /* Check for any input SGL support */
11146 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11147 feature_flags = dev_info.feature_flags;
11149 if ((!(feature_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) ||
11150 (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT)) ||
11151 (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)))
11154 if (fragsz > tdata->plaintext.len)
11155 fragsz = tdata->plaintext.len;
11157 uint16_t plaintext_len = fragsz;
11159 retval = create_gmac_session(ts_params->valid_devs[0],
11160 tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
11165 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11166 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
11167 "Failed to allocate input buffer in mempool");
11169 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11170 rte_pktmbuf_tailroom(ut_params->ibuf));
11172 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11174 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
11176 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
11178 trn_data += plaintext_len;
11180 buf = ut_params->ibuf;
11183 * Loop until no more fragments
11186 while (trn_data < tdata->plaintext.len) {
11188 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
11189 (tdata->plaintext.len - trn_data) : fragsz;
11191 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11194 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
11195 rte_pktmbuf_tailroom(buf));
11197 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
11200 memcpy(plaintext, tdata->plaintext.data + trn_data,
11202 trn_data += to_trn;
11203 if (trn_data == tdata->plaintext.len)
11204 digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
11205 tdata->gmac_tag.len);
11207 ut_params->ibuf->nb_segs = segs;
11210 * Place digest at the end of the last buffer
11212 uint64_t digest_phys = rte_pktmbuf_iova(buf) + to_trn;
11215 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11216 + tdata->gmac_tag.len);
11217 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
11218 tdata->plaintext.len);
11221 retval = create_gmac_operation_sgl(RTE_CRYPTO_AUTH_OP_GENERATE,
11222 tdata, digest_mem, digest_phys);
11227 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11229 ut_params->op->sym->m_src = ut_params->ibuf;
11231 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11234 TEST_ASSERT_NOT_NULL(
11235 process_crypto_request(ts_params->valid_devs[0],
11236 ut_params->op), "failed to process sym crypto op");
11238 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11239 "crypto op processing failed");
11241 auth_tag = digest_mem;
11242 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
11243 TEST_ASSERT_BUFFERS_ARE_EQUAL(
11245 tdata->gmac_tag.data,
11246 tdata->gmac_tag.len,
11247 "GMAC Generated auth tag not as expected");
11252 /* Segment size not multiple of block size (16B) */
11254 test_AES_GMAC_authentication_SGL_40B(void)
11256 return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 40);
11260 test_AES_GMAC_authentication_SGL_80B(void)
11262 return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 80);
11266 test_AES_GMAC_authentication_SGL_2048B(void)
11268 return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2048);
11271 /* Segment size not multiple of block size (16B) */
11273 test_AES_GMAC_authentication_SGL_2047B(void)
11275 return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2047);
11278 struct test_crypto_vector {
11279 enum rte_crypto_cipher_algorithm crypto_algo;
11280 unsigned int cipher_offset;
11281 unsigned int cipher_len;
11294 const uint8_t *data;
11299 const uint8_t *data;
11303 enum rte_crypto_auth_algorithm auth_algo;
11304 unsigned int auth_offset;
11312 const uint8_t *data;
11322 static const struct test_crypto_vector
11323 hmac_sha1_test_crypto_vector = {
11324 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
11326 .data = plaintext_hash,
11331 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
11332 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
11333 0xDE, 0xF4, 0xDE, 0xAD
11339 0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
11340 0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
11341 0x3F, 0x91, 0x64, 0x59
11347 static const struct test_crypto_vector
11348 aes128_gmac_test_vector = {
11349 .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
11351 .data = plaintext_hash,
11356 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
11357 0x08, 0x09, 0x0A, 0x0B
11363 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
11364 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
11370 0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56,
11371 0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A
11377 static const struct test_crypto_vector
11378 aes128cbc_hmac_sha1_test_vector = {
11379 .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
11380 .cipher_offset = 0,
11384 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
11385 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
11391 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
11392 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
11397 .data = plaintext_hash,
11401 .data = ciphertext512_aes128cbc,
11404 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
11408 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
11409 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
11410 0xDE, 0xF4, 0xDE, 0xAD
11416 0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
11417 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
11418 0x18, 0x8C, 0x1D, 0x32
11424 static const struct test_crypto_vector
11425 aes128cbc_hmac_sha1_aad_test_vector = {
11426 .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
11427 .cipher_offset = 8,
11431 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
11432 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
11438 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
11439 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
11444 .data = plaintext_hash,
11448 .data = ciphertext512_aes128cbc_aad,
11451 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
11455 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
11456 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
11457 0xDE, 0xF4, 0xDE, 0xAD
11463 0x6D, 0xF3, 0x50, 0x79, 0x7A, 0x2A, 0xAC, 0x7F,
11464 0xA6, 0xF0, 0xC6, 0x38, 0x1F, 0xA4, 0xDD, 0x9B,
11465 0x62, 0x0F, 0xFB, 0x10
11472 data_corruption(uint8_t *data)
11478 tag_corruption(uint8_t *data, unsigned int tag_offset)
11480 data[tag_offset] += 1;
11484 create_auth_session(struct crypto_unittest_params *ut_params,
11486 const struct test_crypto_vector *reference,
11487 enum rte_crypto_auth_operation auth_op)
11489 struct crypto_testsuite_params *ts_params = &testsuite_params;
11490 uint8_t auth_key[reference->auth_key.len + 1];
11492 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
11494 /* Setup Authentication Parameters */
11495 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11496 ut_params->auth_xform.auth.op = auth_op;
11497 ut_params->auth_xform.next = NULL;
11498 ut_params->auth_xform.auth.algo = reference->auth_algo;
11499 ut_params->auth_xform.auth.key.length = reference->auth_key.len;
11500 ut_params->auth_xform.auth.key.data = auth_key;
11501 ut_params->auth_xform.auth.digest_length = reference->digest.len;
11503 /* Create Crypto session*/
11504 ut_params->sess = rte_cryptodev_sym_session_create(
11505 ts_params->session_mpool);
11507 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
11508 &ut_params->auth_xform,
11509 ts_params->session_priv_mpool);
11511 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
11517 create_auth_cipher_session(struct crypto_unittest_params *ut_params,
11519 const struct test_crypto_vector *reference,
11520 enum rte_crypto_auth_operation auth_op,
11521 enum rte_crypto_cipher_operation cipher_op)
11523 struct crypto_testsuite_params *ts_params = &testsuite_params;
11524 uint8_t cipher_key[reference->cipher_key.len + 1];
11525 uint8_t auth_key[reference->auth_key.len + 1];
11527 memcpy(cipher_key, reference->cipher_key.data,
11528 reference->cipher_key.len);
11529 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
11531 /* Setup Authentication Parameters */
11532 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11533 ut_params->auth_xform.auth.op = auth_op;
11534 ut_params->auth_xform.auth.algo = reference->auth_algo;
11535 ut_params->auth_xform.auth.key.length = reference->auth_key.len;
11536 ut_params->auth_xform.auth.key.data = auth_key;
11537 ut_params->auth_xform.auth.digest_length = reference->digest.len;
11539 if (reference->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) {
11540 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
11541 ut_params->auth_xform.auth.iv.length = reference->iv.len;
11543 ut_params->auth_xform.next = &ut_params->cipher_xform;
11545 /* Setup Cipher Parameters */
11546 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11547 ut_params->cipher_xform.next = NULL;
11548 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
11549 ut_params->cipher_xform.cipher.op = cipher_op;
11550 ut_params->cipher_xform.cipher.key.data = cipher_key;
11551 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
11552 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
11553 ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
11556 /* Create Crypto session*/
11557 ut_params->sess = rte_cryptodev_sym_session_create(
11558 ts_params->session_mpool);
11560 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
11561 &ut_params->auth_xform,
11562 ts_params->session_priv_mpool);
11564 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
11570 create_auth_operation(struct crypto_testsuite_params *ts_params,
11571 struct crypto_unittest_params *ut_params,
11572 const struct test_crypto_vector *reference,
11573 unsigned int auth_generate)
11575 /* Generate Crypto op data structure */
11576 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11577 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11578 TEST_ASSERT_NOT_NULL(ut_params->op,
11579 "Failed to allocate pktmbuf offload");
11581 /* Set crypto operation data parameters */
11582 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11584 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
11586 /* set crypto operation source mbuf */
11587 sym_op->m_src = ut_params->ibuf;
11590 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
11591 ut_params->ibuf, reference->digest.len);
11593 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
11594 "no room to append auth tag");
11596 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
11597 ut_params->ibuf, reference->plaintext.len);
11600 memset(sym_op->auth.digest.data, 0, reference->digest.len);
11602 memcpy(sym_op->auth.digest.data,
11603 reference->digest.data,
11604 reference->digest.len);
11606 debug_hexdump(stdout, "digest:",
11607 sym_op->auth.digest.data,
11608 reference->digest.len);
11610 sym_op->auth.data.length = reference->plaintext.len;
11611 sym_op->auth.data.offset = 0;
11617 create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
11618 struct crypto_unittest_params *ut_params,
11619 const struct test_crypto_vector *reference,
11620 unsigned int auth_generate)
11622 /* Generate Crypto op data structure */
11623 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11624 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11625 TEST_ASSERT_NOT_NULL(ut_params->op,
11626 "Failed to allocate pktmbuf offload");
11628 /* Set crypto operation data parameters */
11629 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11631 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
11633 /* set crypto operation source mbuf */
11634 sym_op->m_src = ut_params->ibuf;
11637 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
11638 ut_params->ibuf, reference->digest.len);
11640 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
11641 "no room to append auth tag");
11643 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
11644 ut_params->ibuf, reference->ciphertext.len);
11647 memset(sym_op->auth.digest.data, 0, reference->digest.len);
11649 memcpy(sym_op->auth.digest.data,
11650 reference->digest.data,
11651 reference->digest.len);
11653 debug_hexdump(stdout, "digest:",
11654 sym_op->auth.digest.data,
11655 reference->digest.len);
11657 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
11658 reference->iv.data, reference->iv.len);
11660 sym_op->cipher.data.length = 0;
11661 sym_op->cipher.data.offset = 0;
11663 sym_op->auth.data.length = reference->plaintext.len;
11664 sym_op->auth.data.offset = 0;
11670 create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
11671 struct crypto_unittest_params *ut_params,
11672 const struct test_crypto_vector *reference,
11673 unsigned int auth_generate)
11675 /* Generate Crypto op data structure */
11676 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11677 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11678 TEST_ASSERT_NOT_NULL(ut_params->op,
11679 "Failed to allocate pktmbuf offload");
11681 /* Set crypto operation data parameters */
11682 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11684 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
11686 /* set crypto operation source mbuf */
11687 sym_op->m_src = ut_params->ibuf;
11690 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
11691 ut_params->ibuf, reference->digest.len);
11693 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
11694 "no room to append auth tag");
11696 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
11697 ut_params->ibuf, reference->ciphertext.len);
11700 memset(sym_op->auth.digest.data, 0, reference->digest.len);
11702 memcpy(sym_op->auth.digest.data,
11703 reference->digest.data,
11704 reference->digest.len);
11706 debug_hexdump(stdout, "digest:",
11707 sym_op->auth.digest.data,
11708 reference->digest.len);
11710 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
11711 reference->iv.data, reference->iv.len);
11713 sym_op->cipher.data.length = reference->cipher_len;
11714 sym_op->cipher.data.offset = reference->cipher_offset;
11716 sym_op->auth.data.length = reference->plaintext.len;
11717 sym_op->auth.data.offset = reference->auth_offset;
11723 create_auth_verify_operation(struct crypto_testsuite_params *ts_params,
11724 struct crypto_unittest_params *ut_params,
11725 const struct test_crypto_vector *reference)
11727 return create_auth_operation(ts_params, ut_params, reference, 0);
11731 create_auth_verify_GMAC_operation(
11732 struct crypto_testsuite_params *ts_params,
11733 struct crypto_unittest_params *ut_params,
11734 const struct test_crypto_vector *reference)
11736 return create_auth_GMAC_operation(ts_params, ut_params, reference, 0);
11740 create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params,
11741 struct crypto_unittest_params *ut_params,
11742 const struct test_crypto_vector *reference)
11744 return create_cipher_auth_operation(ts_params, ut_params, reference, 0);
11748 test_authentication_verify_fail_when_data_corruption(
11749 struct crypto_testsuite_params *ts_params,
11750 struct crypto_unittest_params *ut_params,
11751 const struct test_crypto_vector *reference,
11752 unsigned int data_corrupted)
11756 uint8_t *plaintext;
11757 struct rte_cryptodev_info dev_info;
11759 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11760 uint64_t feat_flags = dev_info.feature_flags;
11762 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11763 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11764 printf("Device doesn't support RAW data-path APIs.\n");
11768 /* Verify the capabilities */
11769 struct rte_cryptodev_sym_capability_idx cap_idx;
11770 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11771 cap_idx.algo.auth = reference->auth_algo;
11772 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11777 /* Create session */
11778 retval = create_auth_session(ut_params,
11779 ts_params->valid_devs[0],
11781 RTE_CRYPTO_AUTH_OP_VERIFY);
11785 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11786 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
11787 "Failed to allocate input buffer in mempool");
11789 /* clear mbuf payload */
11790 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11791 rte_pktmbuf_tailroom(ut_params->ibuf));
11793 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11794 reference->plaintext.len);
11795 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
11796 memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
11798 debug_hexdump(stdout, "plaintext:", plaintext,
11799 reference->plaintext.len);
11801 /* Create operation */
11802 retval = create_auth_verify_operation(ts_params, ut_params, reference);
11807 if (data_corrupted)
11808 data_corruption(plaintext);
11810 tag_corruption(plaintext, reference->plaintext.len);
11812 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
11813 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11815 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
11816 RTE_CRYPTO_OP_STATUS_SUCCESS,
11817 "authentication not failed");
11818 } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11819 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11820 ut_params->op, 0, 1, 0, 0);
11822 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
11824 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
11831 test_authentication_verify_GMAC_fail_when_corruption(
11832 struct crypto_testsuite_params *ts_params,
11833 struct crypto_unittest_params *ut_params,
11834 const struct test_crypto_vector *reference,
11835 unsigned int data_corrupted)
11838 uint8_t *plaintext;
11839 struct rte_cryptodev_info dev_info;
11841 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11842 uint64_t feat_flags = dev_info.feature_flags;
11844 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11845 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11846 printf("Device doesn't support RAW data-path APIs.\n");
11850 /* Verify the capabilities */
11851 struct rte_cryptodev_sym_capability_idx cap_idx;
11852 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11853 cap_idx.algo.auth = reference->auth_algo;
11854 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11858 /* Create session */
11859 retval = create_auth_cipher_session(ut_params,
11860 ts_params->valid_devs[0],
11862 RTE_CRYPTO_AUTH_OP_VERIFY,
11863 RTE_CRYPTO_CIPHER_OP_DECRYPT);
11867 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11868 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
11869 "Failed to allocate input buffer in mempool");
11871 /* clear mbuf payload */
11872 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11873 rte_pktmbuf_tailroom(ut_params->ibuf));
11875 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11876 reference->plaintext.len);
11877 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
11878 memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
11880 debug_hexdump(stdout, "plaintext:", plaintext,
11881 reference->plaintext.len);
11883 /* Create operation */
11884 retval = create_auth_verify_GMAC_operation(ts_params,
11891 if (data_corrupted)
11892 data_corruption(plaintext);
11894 tag_corruption(plaintext, reference->aad.len);
11896 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
11897 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11899 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
11900 RTE_CRYPTO_OP_STATUS_SUCCESS,
11901 "authentication not failed");
11902 } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11903 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11904 ut_params->op, 0, 1, 0, 0);
11906 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
11908 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
11915 test_authenticated_decryption_fail_when_corruption(
11916 struct crypto_testsuite_params *ts_params,
11917 struct crypto_unittest_params *ut_params,
11918 const struct test_crypto_vector *reference,
11919 unsigned int data_corrupted)
11923 uint8_t *ciphertext;
11924 struct rte_cryptodev_info dev_info;
11926 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11927 uint64_t feat_flags = dev_info.feature_flags;
11929 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11930 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11931 printf("Device doesn't support RAW data-path APIs.\n");
11935 /* Verify the capabilities */
11936 struct rte_cryptodev_sym_capability_idx cap_idx;
11937 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11938 cap_idx.algo.auth = reference->auth_algo;
11939 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11942 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11943 cap_idx.algo.cipher = reference->crypto_algo;
11944 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11948 /* Create session */
11949 retval = create_auth_cipher_session(ut_params,
11950 ts_params->valid_devs[0],
11952 RTE_CRYPTO_AUTH_OP_VERIFY,
11953 RTE_CRYPTO_CIPHER_OP_DECRYPT);
11957 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11958 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
11959 "Failed to allocate input buffer in mempool");
11961 /* clear mbuf payload */
11962 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11963 rte_pktmbuf_tailroom(ut_params->ibuf));
11965 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11966 reference->ciphertext.len);
11967 TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
11968 memcpy(ciphertext, reference->ciphertext.data,
11969 reference->ciphertext.len);
11971 /* Create operation */
11972 retval = create_cipher_auth_verify_operation(ts_params,
11979 if (data_corrupted)
11980 data_corruption(ciphertext);
11982 tag_corruption(ciphertext, reference->ciphertext.len);
11984 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
11985 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11987 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
11988 RTE_CRYPTO_OP_STATUS_SUCCESS,
11989 "authentication not failed");
11990 } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11991 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11992 ut_params->op, 1, 1, 0, 0);
11994 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
11996 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
12003 test_authenticated_encryt_with_esn(
12004 struct crypto_testsuite_params *ts_params,
12005 struct crypto_unittest_params *ut_params,
12006 const struct test_crypto_vector *reference)
12010 uint8_t *authciphertext, *plaintext, *auth_tag;
12011 uint16_t plaintext_pad_len;
12012 uint8_t cipher_key[reference->cipher_key.len + 1];
12013 uint8_t auth_key[reference->auth_key.len + 1];
12014 struct rte_cryptodev_info dev_info;
12016 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12017 uint64_t feat_flags = dev_info.feature_flags;
12019 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12020 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12021 printf("Device doesn't support RAW data-path APIs.\n");
12025 /* Verify the capabilities */
12026 struct rte_cryptodev_sym_capability_idx cap_idx;
12027 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12028 cap_idx.algo.auth = reference->auth_algo;
12029 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12032 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12033 cap_idx.algo.cipher = reference->crypto_algo;
12034 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12038 /* Create session */
12039 memcpy(cipher_key, reference->cipher_key.data,
12040 reference->cipher_key.len);
12041 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
12043 /* Setup Cipher Parameters */
12044 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12045 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
12046 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
12047 ut_params->cipher_xform.cipher.key.data = cipher_key;
12048 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
12049 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
12050 ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
12052 ut_params->cipher_xform.next = &ut_params->auth_xform;
12054 /* Setup Authentication Parameters */
12055 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12056 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
12057 ut_params->auth_xform.auth.algo = reference->auth_algo;
12058 ut_params->auth_xform.auth.key.length = reference->auth_key.len;
12059 ut_params->auth_xform.auth.key.data = auth_key;
12060 ut_params->auth_xform.auth.digest_length = reference->digest.len;
12061 ut_params->auth_xform.next = NULL;
12063 /* Create Crypto session*/
12064 ut_params->sess = rte_cryptodev_sym_session_create(
12065 ts_params->session_mpool);
12067 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
12069 &ut_params->cipher_xform,
12070 ts_params->session_priv_mpool);
12072 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12074 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12075 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12076 "Failed to allocate input buffer in mempool");
12078 /* clear mbuf payload */
12079 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12080 rte_pktmbuf_tailroom(ut_params->ibuf));
12082 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12083 reference->plaintext.len);
12084 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12085 memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
12087 /* Create operation */
12088 retval = create_cipher_auth_operation(ts_params,
12095 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12096 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12098 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12099 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12100 ut_params->op, 1, 1, 0, 0);
12102 ut_params->op = process_crypto_request(
12103 ts_params->valid_devs[0], ut_params->op);
12105 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
12107 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12108 "crypto op processing failed");
12110 plaintext_pad_len = RTE_ALIGN_CEIL(reference->plaintext.len, 16);
12112 authciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
12113 ut_params->op->sym->auth.data.offset);
12114 auth_tag = authciphertext + plaintext_pad_len;
12115 debug_hexdump(stdout, "ciphertext:", authciphertext,
12116 reference->ciphertext.len);
12117 debug_hexdump(stdout, "auth tag:", auth_tag, reference->digest.len);
12119 /* Validate obuf */
12120 TEST_ASSERT_BUFFERS_ARE_EQUAL(
12122 reference->ciphertext.data,
12123 reference->ciphertext.len,
12124 "Ciphertext data not as expected");
12126 TEST_ASSERT_BUFFERS_ARE_EQUAL(
12128 reference->digest.data,
12129 reference->digest.len,
12130 "Generated digest not as expected");
12132 return TEST_SUCCESS;
12137 test_authenticated_decrypt_with_esn(
12138 struct crypto_testsuite_params *ts_params,
12139 struct crypto_unittest_params *ut_params,
12140 const struct test_crypto_vector *reference)
12144 uint8_t *ciphertext;
12145 uint8_t cipher_key[reference->cipher_key.len + 1];
12146 uint8_t auth_key[reference->auth_key.len + 1];
12147 struct rte_cryptodev_info dev_info;
12149 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12150 uint64_t feat_flags = dev_info.feature_flags;
12152 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12153 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12154 printf("Device doesn't support RAW data-path APIs.\n");
12158 /* Verify the capabilities */
12159 struct rte_cryptodev_sym_capability_idx cap_idx;
12160 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12161 cap_idx.algo.auth = reference->auth_algo;
12162 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12165 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12166 cap_idx.algo.cipher = reference->crypto_algo;
12167 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12171 /* Create session */
12172 memcpy(cipher_key, reference->cipher_key.data,
12173 reference->cipher_key.len);
12174 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
12176 /* Setup Authentication Parameters */
12177 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12178 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
12179 ut_params->auth_xform.auth.algo = reference->auth_algo;
12180 ut_params->auth_xform.auth.key.length = reference->auth_key.len;
12181 ut_params->auth_xform.auth.key.data = auth_key;
12182 ut_params->auth_xform.auth.digest_length = reference->digest.len;
12183 ut_params->auth_xform.next = &ut_params->cipher_xform;
12185 /* Setup Cipher Parameters */
12186 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12187 ut_params->cipher_xform.next = NULL;
12188 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
12189 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
12190 ut_params->cipher_xform.cipher.key.data = cipher_key;
12191 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
12192 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
12193 ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
12195 /* Create Crypto session*/
12196 ut_params->sess = rte_cryptodev_sym_session_create(
12197 ts_params->session_mpool);
12199 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
12201 &ut_params->auth_xform,
12202 ts_params->session_priv_mpool);
12204 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12206 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12207 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12208 "Failed to allocate input buffer in mempool");
12210 /* clear mbuf payload */
12211 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12212 rte_pktmbuf_tailroom(ut_params->ibuf));
12214 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12215 reference->ciphertext.len);
12216 TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
12217 memcpy(ciphertext, reference->ciphertext.data,
12218 reference->ciphertext.len);
12220 /* Create operation */
12221 retval = create_cipher_auth_verify_operation(ts_params,
12228 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12229 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12231 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12232 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12233 ut_params->op, 1, 1, 0, 0);
12235 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
12238 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
12239 TEST_ASSERT_EQUAL(ut_params->op->status,
12240 RTE_CRYPTO_OP_STATUS_SUCCESS,
12241 "crypto op processing passed");
12243 ut_params->obuf = ut_params->op->sym->m_src;
12244 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
12250 create_aead_operation_SGL(enum rte_crypto_aead_operation op,
12251 const struct aead_test_data *tdata,
12252 void *digest_mem, uint64_t digest_phys)
12254 struct crypto_testsuite_params *ts_params = &testsuite_params;
12255 struct crypto_unittest_params *ut_params = &unittest_params;
12257 const unsigned int auth_tag_len = tdata->auth_tag.len;
12258 const unsigned int iv_len = tdata->iv.len;
12259 unsigned int aad_len = tdata->aad.len;
12260 unsigned int aad_len_pad = 0;
12262 /* Generate Crypto op data structure */
12263 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12264 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12265 TEST_ASSERT_NOT_NULL(ut_params->op,
12266 "Failed to allocate symmetric crypto operation struct");
12268 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
12270 sym_op->aead.digest.data = digest_mem;
12272 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
12273 "no room to append digest");
12275 sym_op->aead.digest.phys_addr = digest_phys;
12277 if (op == RTE_CRYPTO_AEAD_OP_DECRYPT) {
12278 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
12280 debug_hexdump(stdout, "digest:",
12281 sym_op->aead.digest.data,
12285 /* Append aad data */
12286 if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
12287 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
12288 uint8_t *, IV_OFFSET);
12290 /* Copy IV 1 byte after the IV pointer, according to the API */
12291 rte_memcpy(iv_ptr + 1, tdata->iv.data, iv_len);
12293 aad_len = RTE_ALIGN_CEIL(aad_len + 18, 16);
12295 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
12296 ut_params->ibuf, aad_len);
12297 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
12298 "no room to prepend aad");
12299 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
12302 memset(sym_op->aead.aad.data, 0, aad_len);
12303 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
12304 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
12306 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
12307 debug_hexdump(stdout, "aad:",
12308 sym_op->aead.aad.data, aad_len);
12310 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
12311 uint8_t *, IV_OFFSET);
12313 rte_memcpy(iv_ptr, tdata->iv.data, iv_len);
12315 aad_len_pad = RTE_ALIGN_CEIL(aad_len, 16);
12317 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
12318 ut_params->ibuf, aad_len_pad);
12319 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
12320 "no room to prepend aad");
12321 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
12324 memset(sym_op->aead.aad.data, 0, aad_len);
12325 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
12327 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
12328 debug_hexdump(stdout, "aad:",
12329 sym_op->aead.aad.data, aad_len);
12332 sym_op->aead.data.length = tdata->plaintext.len;
12333 sym_op->aead.data.offset = aad_len_pad;
12338 #define SGL_MAX_NO 16
12341 test_authenticated_encryption_SGL(const struct aead_test_data *tdata,
12342 const int oop, uint32_t fragsz, uint32_t fragsz_oop)
12344 struct crypto_testsuite_params *ts_params = &testsuite_params;
12345 struct crypto_unittest_params *ut_params = &unittest_params;
12346 struct rte_mbuf *buf, *buf_oop = NULL, *buf_last_oop = NULL;
12349 int to_trn_tbl[SGL_MAX_NO];
12351 unsigned int trn_data = 0;
12352 uint8_t *plaintext, *ciphertext, *auth_tag;
12353 struct rte_cryptodev_info dev_info;
12355 /* Verify the capabilities */
12356 struct rte_cryptodev_sym_capability_idx cap_idx;
12357 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
12358 cap_idx.algo.aead = tdata->algo;
12359 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12363 /* OOP not supported with CPU crypto */
12364 if (oop && gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12367 /* Detailed check for the particular SGL support flag */
12368 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12370 unsigned int sgl_in = fragsz < tdata->plaintext.len;
12371 if (sgl_in && (!(dev_info.feature_flags &
12372 RTE_CRYPTODEV_FF_IN_PLACE_SGL)))
12375 uint64_t feat_flags = dev_info.feature_flags;
12377 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12378 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12379 printf("Device doesn't support RAW data-path APIs.\n");
12383 unsigned int sgl_in = fragsz < tdata->plaintext.len;
12384 unsigned int sgl_out = (fragsz_oop ? fragsz_oop : fragsz) <
12385 tdata->plaintext.len;
12386 /* Raw data path API does not support OOP */
12387 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12389 if (sgl_in && !sgl_out) {
12390 if (!(dev_info.feature_flags &
12391 RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT))
12393 } else if (!sgl_in && sgl_out) {
12394 if (!(dev_info.feature_flags &
12395 RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT))
12397 } else if (sgl_in && sgl_out) {
12398 if (!(dev_info.feature_flags &
12399 RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT))
12404 if (fragsz > tdata->plaintext.len)
12405 fragsz = tdata->plaintext.len;
12407 uint16_t plaintext_len = fragsz;
12408 uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
12410 if (fragsz_oop > tdata->plaintext.len)
12411 frag_size_oop = tdata->plaintext.len;
12414 void *digest_mem = NULL;
12416 uint32_t prepend_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
12418 if (tdata->plaintext.len % fragsz != 0) {
12419 if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO)
12422 if (tdata->plaintext.len / fragsz > SGL_MAX_NO)
12427 * For out-op-place we need to alloc another mbuf
12430 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12431 rte_pktmbuf_append(ut_params->obuf,
12432 frag_size_oop + prepend_len);
12433 buf_oop = ut_params->obuf;
12436 /* Create AEAD session */
12437 retval = create_aead_session(ts_params->valid_devs[0],
12439 RTE_CRYPTO_AEAD_OP_ENCRYPT,
12440 tdata->key.data, tdata->key.len,
12441 tdata->aad.len, tdata->auth_tag.len,
12446 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12448 /* clear mbuf payload */
12449 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12450 rte_pktmbuf_tailroom(ut_params->ibuf));
12452 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12455 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
12457 trn_data += plaintext_len;
12459 buf = ut_params->ibuf;
12462 * Loop until no more fragments
12465 while (trn_data < tdata->plaintext.len) {
12467 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
12468 (tdata->plaintext.len - trn_data) : fragsz;
12470 to_trn_tbl[ecx++] = to_trn;
12472 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12475 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
12476 rte_pktmbuf_tailroom(buf));
12479 if (oop && !fragsz_oop) {
12480 buf_last_oop = buf_oop->next =
12481 rte_pktmbuf_alloc(ts_params->mbuf_pool);
12482 buf_oop = buf_oop->next;
12483 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
12484 0, rte_pktmbuf_tailroom(buf_oop));
12485 rte_pktmbuf_append(buf_oop, to_trn);
12488 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
12491 memcpy(plaintext, tdata->plaintext.data + trn_data,
12493 trn_data += to_trn;
12494 if (trn_data == tdata->plaintext.len) {
12497 digest_mem = rte_pktmbuf_append(buf_oop,
12498 tdata->auth_tag.len);
12500 digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
12501 tdata->auth_tag.len);
12505 uint64_t digest_phys = 0;
12507 ut_params->ibuf->nb_segs = segs;
12510 if (fragsz_oop && oop) {
12514 if (frag_size_oop == tdata->plaintext.len) {
12515 digest_mem = rte_pktmbuf_append(ut_params->obuf,
12516 tdata->auth_tag.len);
12518 digest_phys = rte_pktmbuf_iova_offset(
12520 tdata->plaintext.len + prepend_len);
12523 trn_data = frag_size_oop;
12524 while (trn_data < tdata->plaintext.len) {
12527 (tdata->plaintext.len - trn_data <
12529 (tdata->plaintext.len - trn_data) :
12532 to_trn_tbl[ecx++] = to_trn;
12534 buf_last_oop = buf_oop->next =
12535 rte_pktmbuf_alloc(ts_params->mbuf_pool);
12536 buf_oop = buf_oop->next;
12537 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
12538 0, rte_pktmbuf_tailroom(buf_oop));
12539 rte_pktmbuf_append(buf_oop, to_trn);
12541 trn_data += to_trn;
12543 if (trn_data == tdata->plaintext.len) {
12544 digest_mem = rte_pktmbuf_append(buf_oop,
12545 tdata->auth_tag.len);
12549 ut_params->obuf->nb_segs = segs;
12553 * Place digest at the end of the last buffer
12556 digest_phys = rte_pktmbuf_iova(buf) + to_trn;
12557 if (oop && buf_last_oop)
12558 digest_phys = rte_pktmbuf_iova(buf_last_oop) + to_trn;
12560 if (!digest_mem && !oop) {
12561 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12562 + tdata->auth_tag.len);
12563 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
12564 tdata->plaintext.len);
12567 /* Create AEAD operation */
12568 retval = create_aead_operation_SGL(RTE_CRYPTO_AEAD_OP_ENCRYPT,
12569 tdata, digest_mem, digest_phys);
12574 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12576 ut_params->op->sym->m_src = ut_params->ibuf;
12578 ut_params->op->sym->m_dst = ut_params->obuf;
12580 /* Process crypto operation */
12581 if (oop == IN_PLACE &&
12582 gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12583 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
12584 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12585 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12586 ut_params->op, 0, 0, 0, 0);
12588 TEST_ASSERT_NOT_NULL(
12589 process_crypto_request(ts_params->valid_devs[0],
12590 ut_params->op), "failed to process sym crypto op");
12592 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12593 "crypto op processing failed");
12596 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
12597 uint8_t *, prepend_len);
12599 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
12600 uint8_t *, prepend_len);
12604 fragsz = fragsz_oop;
12606 TEST_ASSERT_BUFFERS_ARE_EQUAL(
12608 tdata->ciphertext.data,
12610 "Ciphertext data not as expected");
12612 buf = ut_params->op->sym->m_src->next;
12614 buf = ut_params->op->sym->m_dst->next;
12616 unsigned int off = fragsz;
12620 ciphertext = rte_pktmbuf_mtod(buf,
12623 TEST_ASSERT_BUFFERS_ARE_EQUAL(
12625 tdata->ciphertext.data + off,
12627 "Ciphertext data not as expected");
12629 off += to_trn_tbl[ecx++];
12633 auth_tag = digest_mem;
12634 TEST_ASSERT_BUFFERS_ARE_EQUAL(
12636 tdata->auth_tag.data,
12637 tdata->auth_tag.len,
12638 "Generated auth tag not as expected");
12644 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void)
12646 return test_authenticated_encryption_SGL(
12647 &gcm_test_case_SGL_1, OUT_OF_PLACE, 400, 400);
12651 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B(void)
12653 return test_authenticated_encryption_SGL(
12654 &gcm_test_case_SGL_1, OUT_OF_PLACE, 1500, 2000);
12658 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void)
12660 return test_authenticated_encryption_SGL(
12661 &gcm_test_case_8, OUT_OF_PLACE, 400,
12662 gcm_test_case_8.plaintext.len);
12666 test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void)
12668 /* This test is not for OPENSSL PMD */
12669 if (gbl_driver_id == rte_cryptodev_driver_id_get(
12670 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)))
12673 return test_authenticated_encryption_SGL(
12674 &gcm_test_case_SGL_1, IN_PLACE, 1500, 0);
12678 test_authentication_verify_fail_when_data_corrupted(
12679 struct crypto_testsuite_params *ts_params,
12680 struct crypto_unittest_params *ut_params,
12681 const struct test_crypto_vector *reference)
12683 return test_authentication_verify_fail_when_data_corruption(
12684 ts_params, ut_params, reference, 1);
12688 test_authentication_verify_fail_when_tag_corrupted(
12689 struct crypto_testsuite_params *ts_params,
12690 struct crypto_unittest_params *ut_params,
12691 const struct test_crypto_vector *reference)
12693 return test_authentication_verify_fail_when_data_corruption(
12694 ts_params, ut_params, reference, 0);
12698 test_authentication_verify_GMAC_fail_when_data_corrupted(
12699 struct crypto_testsuite_params *ts_params,
12700 struct crypto_unittest_params *ut_params,
12701 const struct test_crypto_vector *reference)
12703 return test_authentication_verify_GMAC_fail_when_corruption(
12704 ts_params, ut_params, reference, 1);
12708 test_authentication_verify_GMAC_fail_when_tag_corrupted(
12709 struct crypto_testsuite_params *ts_params,
12710 struct crypto_unittest_params *ut_params,
12711 const struct test_crypto_vector *reference)
12713 return test_authentication_verify_GMAC_fail_when_corruption(
12714 ts_params, ut_params, reference, 0);
12718 test_authenticated_decryption_fail_when_data_corrupted(
12719 struct crypto_testsuite_params *ts_params,
12720 struct crypto_unittest_params *ut_params,
12721 const struct test_crypto_vector *reference)
12723 return test_authenticated_decryption_fail_when_corruption(
12724 ts_params, ut_params, reference, 1);
12728 test_authenticated_decryption_fail_when_tag_corrupted(
12729 struct crypto_testsuite_params *ts_params,
12730 struct crypto_unittest_params *ut_params,
12731 const struct test_crypto_vector *reference)
12733 return test_authenticated_decryption_fail_when_corruption(
12734 ts_params, ut_params, reference, 0);
12738 authentication_verify_HMAC_SHA1_fail_data_corrupt(void)
12740 return test_authentication_verify_fail_when_data_corrupted(
12741 &testsuite_params, &unittest_params,
12742 &hmac_sha1_test_crypto_vector);
12746 authentication_verify_HMAC_SHA1_fail_tag_corrupt(void)
12748 return test_authentication_verify_fail_when_tag_corrupted(
12749 &testsuite_params, &unittest_params,
12750 &hmac_sha1_test_crypto_vector);
12754 authentication_verify_AES128_GMAC_fail_data_corrupt(void)
12756 return test_authentication_verify_GMAC_fail_when_data_corrupted(
12757 &testsuite_params, &unittest_params,
12758 &aes128_gmac_test_vector);
12762 authentication_verify_AES128_GMAC_fail_tag_corrupt(void)
12764 return test_authentication_verify_GMAC_fail_when_tag_corrupted(
12765 &testsuite_params, &unittest_params,
12766 &aes128_gmac_test_vector);
12770 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void)
12772 return test_authenticated_decryption_fail_when_data_corrupted(
12775 &aes128cbc_hmac_sha1_test_vector);
12779 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void)
12781 return test_authenticated_decryption_fail_when_tag_corrupted(
12784 &aes128cbc_hmac_sha1_test_vector);
12788 auth_encrypt_AES128CBC_HMAC_SHA1_esn_check(void)
12790 return test_authenticated_encryt_with_esn(
12793 &aes128cbc_hmac_sha1_aad_test_vector);
12797 auth_decrypt_AES128CBC_HMAC_SHA1_esn_check(void)
12799 return test_authenticated_decrypt_with_esn(
12802 &aes128cbc_hmac_sha1_aad_test_vector);
12806 test_chacha20_poly1305_encrypt_test_case_rfc8439(void)
12808 return test_authenticated_encryption(&chacha20_poly1305_case_rfc8439);
12812 test_chacha20_poly1305_decrypt_test_case_rfc8439(void)
12814 return test_authenticated_decryption(&chacha20_poly1305_case_rfc8439);
12817 #ifdef RTE_CRYPTO_SCHEDULER
12819 /* global AESNI worker IDs for the scheduler test */
12820 uint8_t aesni_ids[2];
12823 test_scheduler_attach_slave_op(void)
12825 struct crypto_testsuite_params *ts_params = &testsuite_params;
12826 uint8_t sched_id = ts_params->valid_devs[0];
12827 uint32_t nb_devs, i, nb_devs_attached = 0;
12829 char vdev_name[32];
12831 /* create 2 AESNI_MB if necessary */
12832 nb_devs = rte_cryptodev_device_count_by_driver(
12833 rte_cryptodev_driver_id_get(
12834 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)));
12836 for (i = nb_devs; i < 2; i++) {
12837 snprintf(vdev_name, sizeof(vdev_name), "%s_%u",
12838 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD),
12840 ret = rte_vdev_init(vdev_name, NULL);
12842 TEST_ASSERT(ret == 0,
12843 "Failed to create instance %u of"
12845 i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
12849 /* attach 2 AESNI_MB cdevs */
12850 for (i = 0; i < rte_cryptodev_count() && nb_devs_attached < 2;
12852 struct rte_cryptodev_info info;
12853 unsigned int session_size;
12855 rte_cryptodev_info_get(i, &info);
12856 if (info.driver_id != rte_cryptodev_driver_id_get(
12857 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)))
12860 session_size = rte_cryptodev_sym_get_private_session_size(i);
12862 * Create the session mempool again, since now there are new devices
12863 * to use the mempool.
12865 if (ts_params->session_mpool) {
12866 rte_mempool_free(ts_params->session_mpool);
12867 ts_params->session_mpool = NULL;
12869 if (ts_params->session_priv_mpool) {
12870 rte_mempool_free(ts_params->session_priv_mpool);
12871 ts_params->session_priv_mpool = NULL;
12874 if (info.sym.max_nb_sessions != 0 &&
12875 info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
12876 RTE_LOG(ERR, USER1,
12877 "Device does not support "
12878 "at least %u sessions\n",
12880 return TEST_FAILED;
12883 * Create mempool with maximum number of sessions,
12884 * to include the session headers
12886 if (ts_params->session_mpool == NULL) {
12887 ts_params->session_mpool =
12888 rte_cryptodev_sym_session_pool_create(
12890 MAX_NB_SESSIONS, 0, 0, 0,
12892 TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
12893 "session mempool allocation failed");
12897 * Create mempool with maximum number of sessions,
12898 * to include device specific session private data
12900 if (ts_params->session_priv_mpool == NULL) {
12901 ts_params->session_priv_mpool = rte_mempool_create(
12902 "test_sess_mp_priv",
12905 0, 0, NULL, NULL, NULL,
12906 NULL, SOCKET_ID_ANY,
12909 TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
12910 "session mempool allocation failed");
12913 ts_params->qp_conf.mp_session = ts_params->session_mpool;
12914 ts_params->qp_conf.mp_session_private =
12915 ts_params->session_priv_mpool;
12917 ret = rte_cryptodev_scheduler_worker_attach(sched_id,
12920 TEST_ASSERT(ret == 0,
12921 "Failed to attach device %u of pmd : %s", i,
12922 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
12924 aesni_ids[nb_devs_attached] = (uint8_t)i;
12926 nb_devs_attached++;
12933 test_scheduler_detach_slave_op(void)
12935 struct crypto_testsuite_params *ts_params = &testsuite_params;
12936 uint8_t sched_id = ts_params->valid_devs[0];
12940 for (i = 0; i < 2; i++) {
12941 ret = rte_cryptodev_scheduler_worker_detach(sched_id,
12943 TEST_ASSERT(ret == 0,
12944 "Failed to detach device %u", aesni_ids[i]);
12951 test_scheduler_mode_op(enum rte_cryptodev_scheduler_mode scheduler_mode)
12953 struct crypto_testsuite_params *ts_params = &testsuite_params;
12954 uint8_t sched_id = ts_params->valid_devs[0];
12956 return rte_cryptodev_scheduler_mode_set(sched_id,
12961 test_scheduler_mode_roundrobin_op(void)
12963 TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) ==
12964 0, "Failed to set roundrobin mode");
12970 test_scheduler_mode_multicore_op(void)
12972 TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) ==
12973 0, "Failed to set multicore mode");
12979 test_scheduler_mode_failover_op(void)
12981 TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) ==
12982 0, "Failed to set failover mode");
12988 test_scheduler_mode_pkt_size_distr_op(void)
12990 TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) ==
12991 0, "Failed to set pktsize mode");
12996 static struct unit_test_suite cryptodev_scheduler_testsuite = {
12997 .suite_name = "Crypto Device Scheduler Unit Test Suite",
12998 .setup = testsuite_setup,
12999 .teardown = testsuite_teardown,
13000 .unit_test_cases = {
13002 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
13003 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_multicore_op),
13004 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
13005 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13006 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
13007 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
13010 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
13011 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_roundrobin_op),
13012 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
13013 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13014 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
13015 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
13018 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
13019 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_failover_op),
13020 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
13021 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13022 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
13023 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
13026 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
13027 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_pkt_size_distr_op),
13028 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
13029 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13030 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
13031 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
13033 TEST_CASES_END() /**< NULL terminate unit test array */
13037 #endif /* RTE_CRYPTO_SCHEDULER */
13039 static struct unit_test_suite cryptodev_testsuite = {
13040 .suite_name = "Crypto Unit Test Suite",
13041 .setup = testsuite_setup,
13042 .teardown = testsuite_teardown,
13043 .unit_test_cases = {
13044 TEST_CASE_ST(ut_setup, ut_teardown,
13045 test_device_configure_invalid_dev_id),
13046 TEST_CASE_ST(ut_setup, ut_teardown,
13047 test_queue_pair_descriptor_setup),
13048 TEST_CASE_ST(ut_setup, ut_teardown,
13049 test_device_configure_invalid_queue_pair_ids),
13051 TEST_CASE_ST(ut_setup, ut_teardown,
13052 test_multi_session),
13053 TEST_CASE_ST(ut_setup, ut_teardown,
13054 test_multi_session_random_usage),
13056 TEST_CASE_ST(ut_setup, ut_teardown,
13057 test_null_invalid_operation),
13058 TEST_CASE_ST(ut_setup, ut_teardown, test_null_burst_operation),
13060 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
13061 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13062 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
13063 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
13064 TEST_CASE_ST(ut_setup, ut_teardown, test_DES_cipheronly_all),
13065 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_docsis_all),
13066 TEST_CASE_ST(ut_setup, ut_teardown, test_DES_docsis_all),
13067 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
13068 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
13070 /** AES CCM Authenticated Encryption 128 bits key */
13071 TEST_CASE_ST(ut_setup, ut_teardown,
13072 test_AES_CCM_authenticated_encryption_test_case_128_1),
13073 TEST_CASE_ST(ut_setup, ut_teardown,
13074 test_AES_CCM_authenticated_encryption_test_case_128_2),
13075 TEST_CASE_ST(ut_setup, ut_teardown,
13076 test_AES_CCM_authenticated_encryption_test_case_128_3),
13078 /** AES CCM Authenticated Decryption 128 bits key*/
13079 TEST_CASE_ST(ut_setup, ut_teardown,
13080 test_AES_CCM_authenticated_decryption_test_case_128_1),
13081 TEST_CASE_ST(ut_setup, ut_teardown,
13082 test_AES_CCM_authenticated_decryption_test_case_128_2),
13083 TEST_CASE_ST(ut_setup, ut_teardown,
13084 test_AES_CCM_authenticated_decryption_test_case_128_3),
13086 /** AES CCM Authenticated Encryption 192 bits key */
13087 TEST_CASE_ST(ut_setup, ut_teardown,
13088 test_AES_CCM_authenticated_encryption_test_case_192_1),
13089 TEST_CASE_ST(ut_setup, ut_teardown,
13090 test_AES_CCM_authenticated_encryption_test_case_192_2),
13091 TEST_CASE_ST(ut_setup, ut_teardown,
13092 test_AES_CCM_authenticated_encryption_test_case_192_3),
13094 /** AES CCM Authenticated Decryption 192 bits key*/
13095 TEST_CASE_ST(ut_setup, ut_teardown,
13096 test_AES_CCM_authenticated_decryption_test_case_192_1),
13097 TEST_CASE_ST(ut_setup, ut_teardown,
13098 test_AES_CCM_authenticated_decryption_test_case_192_2),
13099 TEST_CASE_ST(ut_setup, ut_teardown,
13100 test_AES_CCM_authenticated_decryption_test_case_192_3),
13102 /** AES CCM Authenticated Encryption 256 bits key */
13103 TEST_CASE_ST(ut_setup, ut_teardown,
13104 test_AES_CCM_authenticated_encryption_test_case_256_1),
13105 TEST_CASE_ST(ut_setup, ut_teardown,
13106 test_AES_CCM_authenticated_encryption_test_case_256_2),
13107 TEST_CASE_ST(ut_setup, ut_teardown,
13108 test_AES_CCM_authenticated_encryption_test_case_256_3),
13110 /** AES CCM Authenticated Decryption 256 bits key*/
13111 TEST_CASE_ST(ut_setup, ut_teardown,
13112 test_AES_CCM_authenticated_decryption_test_case_256_1),
13113 TEST_CASE_ST(ut_setup, ut_teardown,
13114 test_AES_CCM_authenticated_decryption_test_case_256_2),
13115 TEST_CASE_ST(ut_setup, ut_teardown,
13116 test_AES_CCM_authenticated_decryption_test_case_256_3),
13118 /** AES GCM Authenticated Encryption */
13119 TEST_CASE_ST(ut_setup, ut_teardown,
13120 test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
13121 TEST_CASE_ST(ut_setup, ut_teardown,
13122 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
13123 TEST_CASE_ST(ut_setup, ut_teardown,
13124 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
13125 TEST_CASE_ST(ut_setup, ut_teardown,
13126 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
13127 TEST_CASE_ST(ut_setup, ut_teardown,
13128 test_AES_GCM_authenticated_encryption_test_case_1),
13129 TEST_CASE_ST(ut_setup, ut_teardown,
13130 test_AES_GCM_authenticated_encryption_test_case_2),
13131 TEST_CASE_ST(ut_setup, ut_teardown,
13132 test_AES_GCM_authenticated_encryption_test_case_3),
13133 TEST_CASE_ST(ut_setup, ut_teardown,
13134 test_AES_GCM_authenticated_encryption_test_case_4),
13135 TEST_CASE_ST(ut_setup, ut_teardown,
13136 test_AES_GCM_authenticated_encryption_test_case_5),
13137 TEST_CASE_ST(ut_setup, ut_teardown,
13138 test_AES_GCM_authenticated_encryption_test_case_6),
13139 TEST_CASE_ST(ut_setup, ut_teardown,
13140 test_AES_GCM_authenticated_encryption_test_case_7),
13141 TEST_CASE_ST(ut_setup, ut_teardown,
13142 test_AES_GCM_authenticated_encryption_test_case_8),
13143 TEST_CASE_ST(ut_setup, ut_teardown,
13144 test_AES_GCM_J0_authenticated_encryption_test_case_1),
13146 /** AES GCM Authenticated Decryption */
13147 TEST_CASE_ST(ut_setup, ut_teardown,
13148 test_AES_GCM_authenticated_decryption_test_case_1),
13149 TEST_CASE_ST(ut_setup, ut_teardown,
13150 test_AES_GCM_authenticated_decryption_test_case_2),
13151 TEST_CASE_ST(ut_setup, ut_teardown,
13152 test_AES_GCM_authenticated_decryption_test_case_3),
13153 TEST_CASE_ST(ut_setup, ut_teardown,
13154 test_AES_GCM_authenticated_decryption_test_case_4),
13155 TEST_CASE_ST(ut_setup, ut_teardown,
13156 test_AES_GCM_authenticated_decryption_test_case_5),
13157 TEST_CASE_ST(ut_setup, ut_teardown,
13158 test_AES_GCM_authenticated_decryption_test_case_6),
13159 TEST_CASE_ST(ut_setup, ut_teardown,
13160 test_AES_GCM_authenticated_decryption_test_case_7),
13161 TEST_CASE_ST(ut_setup, ut_teardown,
13162 test_AES_GCM_authenticated_decryption_test_case_8),
13163 TEST_CASE_ST(ut_setup, ut_teardown,
13164 test_AES_GCM_J0_authenticated_decryption_test_case_1),
13166 /** AES GCM Authenticated Encryption 192 bits key */
13167 TEST_CASE_ST(ut_setup, ut_teardown,
13168 test_AES_GCM_auth_encryption_test_case_192_1),
13169 TEST_CASE_ST(ut_setup, ut_teardown,
13170 test_AES_GCM_auth_encryption_test_case_192_2),
13171 TEST_CASE_ST(ut_setup, ut_teardown,
13172 test_AES_GCM_auth_encryption_test_case_192_3),
13173 TEST_CASE_ST(ut_setup, ut_teardown,
13174 test_AES_GCM_auth_encryption_test_case_192_4),
13175 TEST_CASE_ST(ut_setup, ut_teardown,
13176 test_AES_GCM_auth_encryption_test_case_192_5),
13177 TEST_CASE_ST(ut_setup, ut_teardown,
13178 test_AES_GCM_auth_encryption_test_case_192_6),
13179 TEST_CASE_ST(ut_setup, ut_teardown,
13180 test_AES_GCM_auth_encryption_test_case_192_7),
13182 /** AES GCM Authenticated Decryption 192 bits key */
13183 TEST_CASE_ST(ut_setup, ut_teardown,
13184 test_AES_GCM_auth_decryption_test_case_192_1),
13185 TEST_CASE_ST(ut_setup, ut_teardown,
13186 test_AES_GCM_auth_decryption_test_case_192_2),
13187 TEST_CASE_ST(ut_setup, ut_teardown,
13188 test_AES_GCM_auth_decryption_test_case_192_3),
13189 TEST_CASE_ST(ut_setup, ut_teardown,
13190 test_AES_GCM_auth_decryption_test_case_192_4),
13191 TEST_CASE_ST(ut_setup, ut_teardown,
13192 test_AES_GCM_auth_decryption_test_case_192_5),
13193 TEST_CASE_ST(ut_setup, ut_teardown,
13194 test_AES_GCM_auth_decryption_test_case_192_6),
13195 TEST_CASE_ST(ut_setup, ut_teardown,
13196 test_AES_GCM_auth_decryption_test_case_192_7),
13198 /** AES GCM Authenticated Encryption 256 bits key */
13199 TEST_CASE_ST(ut_setup, ut_teardown,
13200 test_AES_GCM_auth_encryption_test_case_256_1),
13201 TEST_CASE_ST(ut_setup, ut_teardown,
13202 test_AES_GCM_auth_encryption_test_case_256_2),
13203 TEST_CASE_ST(ut_setup, ut_teardown,
13204 test_AES_GCM_auth_encryption_test_case_256_3),
13205 TEST_CASE_ST(ut_setup, ut_teardown,
13206 test_AES_GCM_auth_encryption_test_case_256_4),
13207 TEST_CASE_ST(ut_setup, ut_teardown,
13208 test_AES_GCM_auth_encryption_test_case_256_5),
13209 TEST_CASE_ST(ut_setup, ut_teardown,
13210 test_AES_GCM_auth_encryption_test_case_256_6),
13211 TEST_CASE_ST(ut_setup, ut_teardown,
13212 test_AES_GCM_auth_encryption_test_case_256_7),
13214 /** AES GCM Authenticated Decryption 256 bits key */
13215 TEST_CASE_ST(ut_setup, ut_teardown,
13216 test_AES_GCM_auth_decryption_test_case_256_1),
13217 TEST_CASE_ST(ut_setup, ut_teardown,
13218 test_AES_GCM_auth_decryption_test_case_256_2),
13219 TEST_CASE_ST(ut_setup, ut_teardown,
13220 test_AES_GCM_auth_decryption_test_case_256_3),
13221 TEST_CASE_ST(ut_setup, ut_teardown,
13222 test_AES_GCM_auth_decryption_test_case_256_4),
13223 TEST_CASE_ST(ut_setup, ut_teardown,
13224 test_AES_GCM_auth_decryption_test_case_256_5),
13225 TEST_CASE_ST(ut_setup, ut_teardown,
13226 test_AES_GCM_auth_decryption_test_case_256_6),
13227 TEST_CASE_ST(ut_setup, ut_teardown,
13228 test_AES_GCM_auth_decryption_test_case_256_7),
13230 /** AES GCM Authenticated Encryption big aad size */
13231 TEST_CASE_ST(ut_setup, ut_teardown,
13232 test_AES_GCM_auth_encryption_test_case_aad_1),
13233 TEST_CASE_ST(ut_setup, ut_teardown,
13234 test_AES_GCM_auth_encryption_test_case_aad_2),
13236 /** AES GCM Authenticated Decryption big aad size */
13237 TEST_CASE_ST(ut_setup, ut_teardown,
13238 test_AES_GCM_auth_decryption_test_case_aad_1),
13239 TEST_CASE_ST(ut_setup, ut_teardown,
13240 test_AES_GCM_auth_decryption_test_case_aad_2),
13242 /** Out of place tests */
13243 TEST_CASE_ST(ut_setup, ut_teardown,
13244 test_AES_GCM_authenticated_encryption_oop_test_case_1),
13245 TEST_CASE_ST(ut_setup, ut_teardown,
13246 test_AES_GCM_authenticated_decryption_oop_test_case_1),
13248 /** Session-less tests */
13249 TEST_CASE_ST(ut_setup, ut_teardown,
13250 test_AES_GCM_authenticated_encryption_sessionless_test_case_1),
13251 TEST_CASE_ST(ut_setup, ut_teardown,
13252 test_AES_GCM_authenticated_decryption_sessionless_test_case_1),
13254 /** AES GMAC Authentication */
13255 TEST_CASE_ST(ut_setup, ut_teardown,
13256 test_AES_GMAC_authentication_test_case_1),
13257 TEST_CASE_ST(ut_setup, ut_teardown,
13258 test_AES_GMAC_authentication_verify_test_case_1),
13259 TEST_CASE_ST(ut_setup, ut_teardown,
13260 test_AES_GMAC_authentication_test_case_2),
13261 TEST_CASE_ST(ut_setup, ut_teardown,
13262 test_AES_GMAC_authentication_verify_test_case_2),
13263 TEST_CASE_ST(ut_setup, ut_teardown,
13264 test_AES_GMAC_authentication_test_case_3),
13265 TEST_CASE_ST(ut_setup, ut_teardown,
13266 test_AES_GMAC_authentication_verify_test_case_3),
13267 TEST_CASE_ST(ut_setup, ut_teardown,
13268 test_AES_GMAC_authentication_test_case_4),
13269 TEST_CASE_ST(ut_setup, ut_teardown,
13270 test_AES_GMAC_authentication_verify_test_case_4),
13271 TEST_CASE_ST(ut_setup, ut_teardown,
13272 test_AES_GMAC_authentication_SGL_40B),
13273 TEST_CASE_ST(ut_setup, ut_teardown,
13274 test_AES_GMAC_authentication_SGL_80B),
13275 TEST_CASE_ST(ut_setup, ut_teardown,
13276 test_AES_GMAC_authentication_SGL_2048B),
13277 TEST_CASE_ST(ut_setup, ut_teardown,
13278 test_AES_GMAC_authentication_SGL_2047B),
13280 /** Chacha20-Poly1305 */
13281 TEST_CASE_ST(ut_setup, ut_teardown,
13282 test_chacha20_poly1305_encrypt_test_case_rfc8439),
13283 TEST_CASE_ST(ut_setup, ut_teardown,
13284 test_chacha20_poly1305_decrypt_test_case_rfc8439),
13285 /** SNOW 3G encrypt only (UEA2) */
13286 TEST_CASE_ST(ut_setup, ut_teardown,
13287 test_snow3g_encryption_test_case_1),
13288 TEST_CASE_ST(ut_setup, ut_teardown,
13289 test_snow3g_encryption_test_case_2),
13290 TEST_CASE_ST(ut_setup, ut_teardown,
13291 test_snow3g_encryption_test_case_3),
13292 TEST_CASE_ST(ut_setup, ut_teardown,
13293 test_snow3g_encryption_test_case_4),
13294 TEST_CASE_ST(ut_setup, ut_teardown,
13295 test_snow3g_encryption_test_case_5),
13297 TEST_CASE_ST(ut_setup, ut_teardown,
13298 test_snow3g_encryption_test_case_1_oop),
13299 TEST_CASE_ST(ut_setup, ut_teardown,
13300 test_snow3g_encryption_test_case_1_oop_sgl),
13301 TEST_CASE_ST(ut_setup, ut_teardown,
13302 test_snow3g_encryption_test_case_1_offset_oop),
13303 TEST_CASE_ST(ut_setup, ut_teardown,
13304 test_snow3g_decryption_test_case_1_oop),
13306 /** SNOW 3G generate auth, then encrypt (UEA2) */
13307 TEST_CASE_ST(ut_setup, ut_teardown,
13308 test_snow3g_auth_cipher_test_case_1),
13309 TEST_CASE_ST(ut_setup, ut_teardown,
13310 test_snow3g_auth_cipher_test_case_2),
13311 TEST_CASE_ST(ut_setup, ut_teardown,
13312 test_snow3g_auth_cipher_test_case_2_oop),
13313 TEST_CASE_ST(ut_setup, ut_teardown,
13314 test_snow3g_auth_cipher_part_digest_enc),
13315 TEST_CASE_ST(ut_setup, ut_teardown,
13316 test_snow3g_auth_cipher_part_digest_enc_oop),
13317 TEST_CASE_ST(ut_setup, ut_teardown,
13318 test_snow3g_auth_cipher_test_case_3_sgl),
13319 TEST_CASE_ST(ut_setup, ut_teardown,
13320 test_snow3g_auth_cipher_test_case_3_oop_sgl),
13321 TEST_CASE_ST(ut_setup, ut_teardown,
13322 test_snow3g_auth_cipher_part_digest_enc_sgl),
13323 TEST_CASE_ST(ut_setup, ut_teardown,
13324 test_snow3g_auth_cipher_part_digest_enc_oop_sgl),
13326 /** SNOW 3G decrypt (UEA2), then verify auth */
13327 TEST_CASE_ST(ut_setup, ut_teardown,
13328 test_snow3g_auth_cipher_verify_test_case_1),
13329 TEST_CASE_ST(ut_setup, ut_teardown,
13330 test_snow3g_auth_cipher_verify_test_case_2),
13331 TEST_CASE_ST(ut_setup, ut_teardown,
13332 test_snow3g_auth_cipher_verify_test_case_2_oop),
13333 TEST_CASE_ST(ut_setup, ut_teardown,
13334 test_snow3g_auth_cipher_verify_part_digest_enc),
13335 TEST_CASE_ST(ut_setup, ut_teardown,
13336 test_snow3g_auth_cipher_verify_part_digest_enc_oop),
13337 TEST_CASE_ST(ut_setup, ut_teardown,
13338 test_snow3g_auth_cipher_verify_test_case_3_sgl),
13339 TEST_CASE_ST(ut_setup, ut_teardown,
13340 test_snow3g_auth_cipher_verify_test_case_3_oop_sgl),
13341 TEST_CASE_ST(ut_setup, ut_teardown,
13342 test_snow3g_auth_cipher_verify_part_digest_enc_sgl),
13343 TEST_CASE_ST(ut_setup, ut_teardown,
13344 test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl),
13346 /** SNOW 3G decrypt only (UEA2) */
13347 TEST_CASE_ST(ut_setup, ut_teardown,
13348 test_snow3g_decryption_test_case_1),
13349 TEST_CASE_ST(ut_setup, ut_teardown,
13350 test_snow3g_decryption_test_case_2),
13351 TEST_CASE_ST(ut_setup, ut_teardown,
13352 test_snow3g_decryption_test_case_3),
13353 TEST_CASE_ST(ut_setup, ut_teardown,
13354 test_snow3g_decryption_test_case_4),
13355 TEST_CASE_ST(ut_setup, ut_teardown,
13356 test_snow3g_decryption_test_case_5),
13357 TEST_CASE_ST(ut_setup, ut_teardown,
13358 test_snow3g_decryption_with_digest_test_case_1),
13359 TEST_CASE_ST(ut_setup, ut_teardown,
13360 test_snow3g_hash_generate_test_case_1),
13361 TEST_CASE_ST(ut_setup, ut_teardown,
13362 test_snow3g_hash_generate_test_case_2),
13363 TEST_CASE_ST(ut_setup, ut_teardown,
13364 test_snow3g_hash_generate_test_case_3),
13365 /* Tests with buffers which length is not byte-aligned */
13366 TEST_CASE_ST(ut_setup, ut_teardown,
13367 test_snow3g_hash_generate_test_case_4),
13368 TEST_CASE_ST(ut_setup, ut_teardown,
13369 test_snow3g_hash_generate_test_case_5),
13370 TEST_CASE_ST(ut_setup, ut_teardown,
13371 test_snow3g_hash_generate_test_case_6),
13372 TEST_CASE_ST(ut_setup, ut_teardown,
13373 test_snow3g_hash_verify_test_case_1),
13374 TEST_CASE_ST(ut_setup, ut_teardown,
13375 test_snow3g_hash_verify_test_case_2),
13376 TEST_CASE_ST(ut_setup, ut_teardown,
13377 test_snow3g_hash_verify_test_case_3),
13378 /* Tests with buffers which length is not byte-aligned */
13379 TEST_CASE_ST(ut_setup, ut_teardown,
13380 test_snow3g_hash_verify_test_case_4),
13381 TEST_CASE_ST(ut_setup, ut_teardown,
13382 test_snow3g_hash_verify_test_case_5),
13383 TEST_CASE_ST(ut_setup, ut_teardown,
13384 test_snow3g_hash_verify_test_case_6),
13385 TEST_CASE_ST(ut_setup, ut_teardown,
13386 test_snow3g_cipher_auth_test_case_1),
13387 TEST_CASE_ST(ut_setup, ut_teardown,
13388 test_snow3g_auth_cipher_with_digest_test_case_1),
13390 /** ZUC encrypt only (EEA3) */
13391 TEST_CASE_ST(ut_setup, ut_teardown,
13392 test_zuc_encryption_test_case_1),
13393 TEST_CASE_ST(ut_setup, ut_teardown,
13394 test_zuc_encryption_test_case_2),
13395 TEST_CASE_ST(ut_setup, ut_teardown,
13396 test_zuc_encryption_test_case_3),
13397 TEST_CASE_ST(ut_setup, ut_teardown,
13398 test_zuc_encryption_test_case_4),
13399 TEST_CASE_ST(ut_setup, ut_teardown,
13400 test_zuc_encryption_test_case_5),
13401 TEST_CASE_ST(ut_setup, ut_teardown,
13402 test_zuc_encryption_test_case_6_sgl),
13404 /** ZUC authenticate (EIA3) */
13405 TEST_CASE_ST(ut_setup, ut_teardown,
13406 test_zuc_hash_generate_test_case_1),
13407 TEST_CASE_ST(ut_setup, ut_teardown,
13408 test_zuc_hash_generate_test_case_2),
13409 TEST_CASE_ST(ut_setup, ut_teardown,
13410 test_zuc_hash_generate_test_case_3),
13411 TEST_CASE_ST(ut_setup, ut_teardown,
13412 test_zuc_hash_generate_test_case_4),
13413 TEST_CASE_ST(ut_setup, ut_teardown,
13414 test_zuc_hash_generate_test_case_5),
13415 TEST_CASE_ST(ut_setup, ut_teardown,
13416 test_zuc_hash_generate_test_case_6),
13417 TEST_CASE_ST(ut_setup, ut_teardown,
13418 test_zuc_hash_generate_test_case_7),
13419 TEST_CASE_ST(ut_setup, ut_teardown,
13420 test_zuc_hash_generate_test_case_8),
13422 /** ZUC alg-chain (EEA3/EIA3) */
13423 TEST_CASE_ST(ut_setup, ut_teardown,
13424 test_zuc_cipher_auth_test_case_1),
13425 TEST_CASE_ST(ut_setup, ut_teardown,
13426 test_zuc_cipher_auth_test_case_2),
13428 /** ZUC generate auth, then encrypt (EEA3) */
13429 TEST_CASE_ST(ut_setup, ut_teardown,
13430 test_zuc_auth_cipher_test_case_1),
13431 TEST_CASE_ST(ut_setup, ut_teardown,
13432 test_zuc_auth_cipher_test_case_1_oop),
13433 TEST_CASE_ST(ut_setup, ut_teardown,
13434 test_zuc_auth_cipher_test_case_1_sgl),
13435 TEST_CASE_ST(ut_setup, ut_teardown,
13436 test_zuc_auth_cipher_test_case_1_oop_sgl),
13438 /** ZUC decrypt (EEA3), then verify auth */
13439 TEST_CASE_ST(ut_setup, ut_teardown,
13440 test_zuc_auth_cipher_verify_test_case_1),
13441 TEST_CASE_ST(ut_setup, ut_teardown,
13442 test_zuc_auth_cipher_verify_test_case_1_oop),
13443 TEST_CASE_ST(ut_setup, ut_teardown,
13444 test_zuc_auth_cipher_verify_test_case_1_sgl),
13445 TEST_CASE_ST(ut_setup, ut_teardown,
13446 test_zuc_auth_cipher_verify_test_case_1_oop_sgl),
13448 /** HMAC_MD5 Authentication */
13449 TEST_CASE_ST(ut_setup, ut_teardown,
13450 test_MD5_HMAC_generate_case_1),
13451 TEST_CASE_ST(ut_setup, ut_teardown,
13452 test_MD5_HMAC_verify_case_1),
13453 TEST_CASE_ST(ut_setup, ut_teardown,
13454 test_MD5_HMAC_generate_case_2),
13455 TEST_CASE_ST(ut_setup, ut_teardown,
13456 test_MD5_HMAC_verify_case_2),
13458 /** KASUMI hash only (UIA1) */
13459 TEST_CASE_ST(ut_setup, ut_teardown,
13460 test_kasumi_hash_generate_test_case_1),
13461 TEST_CASE_ST(ut_setup, ut_teardown,
13462 test_kasumi_hash_generate_test_case_2),
13463 TEST_CASE_ST(ut_setup, ut_teardown,
13464 test_kasumi_hash_generate_test_case_3),
13465 TEST_CASE_ST(ut_setup, ut_teardown,
13466 test_kasumi_hash_generate_test_case_4),
13467 TEST_CASE_ST(ut_setup, ut_teardown,
13468 test_kasumi_hash_generate_test_case_5),
13469 TEST_CASE_ST(ut_setup, ut_teardown,
13470 test_kasumi_hash_generate_test_case_6),
13472 TEST_CASE_ST(ut_setup, ut_teardown,
13473 test_kasumi_hash_verify_test_case_1),
13474 TEST_CASE_ST(ut_setup, ut_teardown,
13475 test_kasumi_hash_verify_test_case_2),
13476 TEST_CASE_ST(ut_setup, ut_teardown,
13477 test_kasumi_hash_verify_test_case_3),
13478 TEST_CASE_ST(ut_setup, ut_teardown,
13479 test_kasumi_hash_verify_test_case_4),
13480 TEST_CASE_ST(ut_setup, ut_teardown,
13481 test_kasumi_hash_verify_test_case_5),
13483 /** KASUMI encrypt only (UEA1) */
13484 TEST_CASE_ST(ut_setup, ut_teardown,
13485 test_kasumi_encryption_test_case_1),
13486 TEST_CASE_ST(ut_setup, ut_teardown,
13487 test_kasumi_encryption_test_case_1_sgl),
13488 TEST_CASE_ST(ut_setup, ut_teardown,
13489 test_kasumi_encryption_test_case_1_oop),
13490 TEST_CASE_ST(ut_setup, ut_teardown,
13491 test_kasumi_encryption_test_case_1_oop_sgl),
13492 TEST_CASE_ST(ut_setup, ut_teardown,
13493 test_kasumi_encryption_test_case_2),
13494 TEST_CASE_ST(ut_setup, ut_teardown,
13495 test_kasumi_encryption_test_case_3),
13496 TEST_CASE_ST(ut_setup, ut_teardown,
13497 test_kasumi_encryption_test_case_4),
13498 TEST_CASE_ST(ut_setup, ut_teardown,
13499 test_kasumi_encryption_test_case_5),
13501 /** KASUMI decrypt only (UEA1) */
13502 TEST_CASE_ST(ut_setup, ut_teardown,
13503 test_kasumi_decryption_test_case_1),
13504 TEST_CASE_ST(ut_setup, ut_teardown,
13505 test_kasumi_decryption_test_case_2),
13506 TEST_CASE_ST(ut_setup, ut_teardown,
13507 test_kasumi_decryption_test_case_3),
13508 TEST_CASE_ST(ut_setup, ut_teardown,
13509 test_kasumi_decryption_test_case_4),
13510 TEST_CASE_ST(ut_setup, ut_teardown,
13511 test_kasumi_decryption_test_case_5),
13512 TEST_CASE_ST(ut_setup, ut_teardown,
13513 test_kasumi_decryption_test_case_1_oop),
13515 TEST_CASE_ST(ut_setup, ut_teardown,
13516 test_kasumi_cipher_auth_test_case_1),
13518 /** KASUMI generate auth, then encrypt (F8) */
13519 TEST_CASE_ST(ut_setup, ut_teardown,
13520 test_kasumi_auth_cipher_test_case_1),
13521 TEST_CASE_ST(ut_setup, ut_teardown,
13522 test_kasumi_auth_cipher_test_case_2),
13523 TEST_CASE_ST(ut_setup, ut_teardown,
13524 test_kasumi_auth_cipher_test_case_2_oop),
13525 TEST_CASE_ST(ut_setup, ut_teardown,
13526 test_kasumi_auth_cipher_test_case_2_sgl),
13527 TEST_CASE_ST(ut_setup, ut_teardown,
13528 test_kasumi_auth_cipher_test_case_2_oop_sgl),
13530 /** KASUMI decrypt (F8), then verify auth */
13531 TEST_CASE_ST(ut_setup, ut_teardown,
13532 test_kasumi_auth_cipher_verify_test_case_1),
13533 TEST_CASE_ST(ut_setup, ut_teardown,
13534 test_kasumi_auth_cipher_verify_test_case_2),
13535 TEST_CASE_ST(ut_setup, ut_teardown,
13536 test_kasumi_auth_cipher_verify_test_case_2_oop),
13537 TEST_CASE_ST(ut_setup, ut_teardown,
13538 test_kasumi_auth_cipher_verify_test_case_2_sgl),
13539 TEST_CASE_ST(ut_setup, ut_teardown,
13540 test_kasumi_auth_cipher_verify_test_case_2_oop_sgl),
13542 /** ESN Testcase */
13543 TEST_CASE_ST(ut_setup, ut_teardown,
13544 auth_encrypt_AES128CBC_HMAC_SHA1_esn_check),
13545 TEST_CASE_ST(ut_setup, ut_teardown,
13546 auth_decrypt_AES128CBC_HMAC_SHA1_esn_check),
13548 /** Negative tests */
13549 TEST_CASE_ST(ut_setup, ut_teardown,
13550 authentication_verify_HMAC_SHA1_fail_data_corrupt),
13551 TEST_CASE_ST(ut_setup, ut_teardown,
13552 authentication_verify_HMAC_SHA1_fail_tag_corrupt),
13553 TEST_CASE_ST(ut_setup, ut_teardown,
13554 test_AES_GCM_auth_encryption_fail_iv_corrupt),
13555 TEST_CASE_ST(ut_setup, ut_teardown,
13556 test_AES_GCM_auth_encryption_fail_in_data_corrupt),
13557 TEST_CASE_ST(ut_setup, ut_teardown,
13558 test_AES_GCM_auth_encryption_fail_out_data_corrupt),
13559 TEST_CASE_ST(ut_setup, ut_teardown,
13560 test_AES_GCM_auth_encryption_fail_aad_len_corrupt),
13561 TEST_CASE_ST(ut_setup, ut_teardown,
13562 test_AES_GCM_auth_encryption_fail_aad_corrupt),
13563 TEST_CASE_ST(ut_setup, ut_teardown,
13564 test_AES_GCM_auth_encryption_fail_tag_corrupt),
13565 TEST_CASE_ST(ut_setup, ut_teardown,
13566 test_AES_GCM_auth_decryption_fail_iv_corrupt),
13567 TEST_CASE_ST(ut_setup, ut_teardown,
13568 test_AES_GCM_auth_decryption_fail_in_data_corrupt),
13569 TEST_CASE_ST(ut_setup, ut_teardown,
13570 test_AES_GCM_auth_decryption_fail_out_data_corrupt),
13571 TEST_CASE_ST(ut_setup, ut_teardown,
13572 test_AES_GCM_auth_decryption_fail_aad_len_corrupt),
13573 TEST_CASE_ST(ut_setup, ut_teardown,
13574 test_AES_GCM_auth_decryption_fail_aad_corrupt),
13575 TEST_CASE_ST(ut_setup, ut_teardown,
13576 test_AES_GCM_auth_decryption_fail_tag_corrupt),
13577 TEST_CASE_ST(ut_setup, ut_teardown,
13578 authentication_verify_AES128_GMAC_fail_data_corrupt),
13579 TEST_CASE_ST(ut_setup, ut_teardown,
13580 authentication_verify_AES128_GMAC_fail_tag_corrupt),
13581 TEST_CASE_ST(ut_setup, ut_teardown,
13582 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
13583 TEST_CASE_ST(ut_setup, ut_teardown,
13584 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
13586 /** Mixed CIPHER + HASH algorithms */
13587 /** AUTH AES CMAC + CIPHER AES CTR */
13588 TEST_CASE_ST(ut_setup, ut_teardown,
13589 test_aes_cmac_aes_ctr_digest_enc_test_case_1),
13590 TEST_CASE_ST(ut_setup, ut_teardown,
13591 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
13592 TEST_CASE_ST(ut_setup, ut_teardown,
13593 test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
13594 TEST_CASE_ST(ut_setup, ut_teardown,
13595 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
13596 TEST_CASE_ST(ut_setup, ut_teardown,
13597 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1),
13598 TEST_CASE_ST(ut_setup, ut_teardown,
13599 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
13600 TEST_CASE_ST(ut_setup, ut_teardown,
13601 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
13602 TEST_CASE_ST(ut_setup, ut_teardown,
13603 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
13605 /** AUTH ZUC + CIPHER SNOW3G */
13606 TEST_CASE_ST(ut_setup, ut_teardown,
13607 test_auth_zuc_cipher_snow_test_case_1),
13608 TEST_CASE_ST(ut_setup, ut_teardown,
13609 test_verify_auth_zuc_cipher_snow_test_case_1),
13610 /** AUTH AES CMAC + CIPHER SNOW3G */
13611 TEST_CASE_ST(ut_setup, ut_teardown,
13612 test_auth_aes_cmac_cipher_snow_test_case_1),
13613 TEST_CASE_ST(ut_setup, ut_teardown,
13614 test_verify_auth_aes_cmac_cipher_snow_test_case_1),
13615 /** AUTH ZUC + CIPHER AES CTR */
13616 TEST_CASE_ST(ut_setup, ut_teardown,
13617 test_auth_zuc_cipher_aes_ctr_test_case_1),
13618 TEST_CASE_ST(ut_setup, ut_teardown,
13619 test_verify_auth_zuc_cipher_aes_ctr_test_case_1),
13620 /** AUTH SNOW3G + CIPHER AES CTR */
13621 TEST_CASE_ST(ut_setup, ut_teardown,
13622 test_auth_snow_cipher_aes_ctr_test_case_1),
13623 TEST_CASE_ST(ut_setup, ut_teardown,
13624 test_verify_auth_snow_cipher_aes_ctr_test_case_1),
13625 /** AUTH SNOW3G + CIPHER ZUC */
13626 TEST_CASE_ST(ut_setup, ut_teardown,
13627 test_auth_snow_cipher_zuc_test_case_1),
13628 TEST_CASE_ST(ut_setup, ut_teardown,
13629 test_verify_auth_snow_cipher_zuc_test_case_1),
13630 /** AUTH AES CMAC + CIPHER ZUC */
13631 TEST_CASE_ST(ut_setup, ut_teardown,
13632 test_auth_aes_cmac_cipher_zuc_test_case_1),
13633 TEST_CASE_ST(ut_setup, ut_teardown,
13634 test_verify_auth_aes_cmac_cipher_zuc_test_case_1),
13636 /** AUTH NULL + CIPHER SNOW3G */
13637 TEST_CASE_ST(ut_setup, ut_teardown,
13638 test_auth_null_cipher_snow_test_case_1),
13639 TEST_CASE_ST(ut_setup, ut_teardown,
13640 test_verify_auth_null_cipher_snow_test_case_1),
13641 /** AUTH NULL + CIPHER ZUC */
13642 TEST_CASE_ST(ut_setup, ut_teardown,
13643 test_auth_null_cipher_zuc_test_case_1),
13644 TEST_CASE_ST(ut_setup, ut_teardown,
13645 test_verify_auth_null_cipher_zuc_test_case_1),
13646 /** AUTH SNOW3G + CIPHER NULL */
13647 TEST_CASE_ST(ut_setup, ut_teardown,
13648 test_auth_snow_cipher_null_test_case_1),
13649 TEST_CASE_ST(ut_setup, ut_teardown,
13650 test_verify_auth_snow_cipher_null_test_case_1),
13651 /** AUTH ZUC + CIPHER NULL */
13652 TEST_CASE_ST(ut_setup, ut_teardown,
13653 test_auth_zuc_cipher_null_test_case_1),
13654 TEST_CASE_ST(ut_setup, ut_teardown,
13655 test_verify_auth_zuc_cipher_null_test_case_1),
13656 /** AUTH NULL + CIPHER AES CTR */
13657 TEST_CASE_ST(ut_setup, ut_teardown,
13658 test_auth_null_cipher_aes_ctr_test_case_1),
13659 TEST_CASE_ST(ut_setup, ut_teardown,
13660 test_verify_auth_null_cipher_aes_ctr_test_case_1),
13661 /** AUTH AES CMAC + CIPHER NULL */
13662 TEST_CASE_ST(ut_setup, ut_teardown,
13663 test_auth_aes_cmac_cipher_null_test_case_1),
13664 TEST_CASE_ST(ut_setup, ut_teardown,
13665 test_verify_auth_aes_cmac_cipher_null_test_case_1),
13667 #ifdef RTE_LIB_SECURITY
13668 TEST_CASE_ST(ut_setup_security, ut_teardown,
13669 test_PDCP_PROTO_all),
13670 TEST_CASE_ST(ut_setup_security, ut_teardown,
13671 test_DOCSIS_PROTO_all),
13673 TEST_CASES_END() /**< NULL terminate unit test array */
13677 static struct unit_test_suite cryptodev_virtio_testsuite = {
13678 .suite_name = "Crypto VIRTIO Unit Test Suite",
13679 .setup = testsuite_setup,
13680 .teardown = testsuite_teardown,
13681 .unit_test_cases = {
13682 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13684 TEST_CASES_END() /**< NULL terminate unit test array */
13688 static struct unit_test_suite cryptodev_caam_jr_testsuite = {
13689 .suite_name = "Crypto CAAM JR Unit Test Suite",
13690 .setup = testsuite_setup,
13691 .teardown = testsuite_teardown,
13692 .unit_test_cases = {
13693 TEST_CASE_ST(ut_setup, ut_teardown,
13694 test_device_configure_invalid_dev_id),
13695 TEST_CASE_ST(ut_setup, ut_teardown,
13696 test_multi_session),
13698 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
13699 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
13700 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13701 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
13702 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
13704 TEST_CASES_END() /**< NULL terminate unit test array */
13708 static struct unit_test_suite cryptodev_mrvl_testsuite = {
13709 .suite_name = "Crypto Device Marvell Component Test Suite",
13710 .setup = testsuite_setup,
13711 .teardown = testsuite_teardown,
13712 .unit_test_cases = {
13713 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
13714 TEST_CASE_ST(ut_setup, ut_teardown,
13715 test_multi_session_random_usage),
13716 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
13717 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13718 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
13719 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
13720 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
13722 /** Negative tests */
13723 TEST_CASE_ST(ut_setup, ut_teardown,
13724 authentication_verify_HMAC_SHA1_fail_data_corrupt),
13725 TEST_CASE_ST(ut_setup, ut_teardown,
13726 authentication_verify_HMAC_SHA1_fail_tag_corrupt),
13727 TEST_CASE_ST(ut_setup, ut_teardown,
13728 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
13729 TEST_CASE_ST(ut_setup, ut_teardown,
13730 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
13732 TEST_CASES_END() /**< NULL terminate unit test array */
13736 static struct unit_test_suite cryptodev_ccp_testsuite = {
13737 .suite_name = "Crypto Device CCP Unit Test Suite",
13738 .setup = testsuite_setup,
13739 .teardown = testsuite_teardown,
13740 .unit_test_cases = {
13741 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
13742 TEST_CASE_ST(ut_setup, ut_teardown,
13743 test_multi_session_random_usage),
13744 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
13745 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13746 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
13747 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
13748 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
13750 /** Negative tests */
13751 TEST_CASE_ST(ut_setup, ut_teardown,
13752 authentication_verify_HMAC_SHA1_fail_data_corrupt),
13753 TEST_CASE_ST(ut_setup, ut_teardown,
13754 authentication_verify_HMAC_SHA1_fail_tag_corrupt),
13755 TEST_CASE_ST(ut_setup, ut_teardown,
13756 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
13757 TEST_CASE_ST(ut_setup, ut_teardown,
13758 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
13760 TEST_CASES_END() /**< NULL terminate unit test array */
13765 test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/)
13767 gbl_driver_id = rte_cryptodev_driver_id_get(
13768 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
13770 if (gbl_driver_id == -1) {
13771 RTE_LOG(ERR, USER1, "QAT PMD must be loaded.\n");
13772 return TEST_SKIPPED;
13775 return unit_test_suite_runner(&cryptodev_testsuite);
13779 test_cryptodev_virtio(void /*argv __rte_unused, int argc __rte_unused*/)
13781 gbl_driver_id = rte_cryptodev_driver_id_get(
13782 RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD));
13784 if (gbl_driver_id == -1) {
13785 RTE_LOG(ERR, USER1, "VIRTIO PMD must be loaded.\n");
13786 return TEST_FAILED;
13789 return unit_test_suite_runner(&cryptodev_virtio_testsuite);
13793 test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/)
13795 gbl_driver_id = rte_cryptodev_driver_id_get(
13796 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
13798 if (gbl_driver_id == -1) {
13799 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded.\n");
13800 return TEST_SKIPPED;
13803 return unit_test_suite_runner(&cryptodev_testsuite);
13807 test_cryptodev_cpu_aesni_mb(void)
13810 enum rte_security_session_action_type at;
13812 gbl_driver_id = rte_cryptodev_driver_id_get(
13813 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
13815 if (gbl_driver_id == -1) {
13816 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded.\n");
13817 return TEST_SKIPPED;
13820 at = gbl_action_type;
13821 gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
13822 rc = unit_test_suite_runner(&cryptodev_testsuite);
13823 gbl_action_type = at;
13828 test_cryptodev_openssl(void)
13830 gbl_driver_id = rte_cryptodev_driver_id_get(
13831 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
13833 if (gbl_driver_id == -1) {
13834 RTE_LOG(ERR, USER1, "OPENSSL PMD must be loaded.\n");
13835 return TEST_SKIPPED;
13838 return unit_test_suite_runner(&cryptodev_testsuite);
13842 test_cryptodev_aesni_gcm(void)
13844 gbl_driver_id = rte_cryptodev_driver_id_get(
13845 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
13847 if (gbl_driver_id == -1) {
13848 RTE_LOG(ERR, USER1, "AESNI GCM PMD must be loaded.\n");
13849 return TEST_SKIPPED;
13852 return unit_test_suite_runner(&cryptodev_testsuite);
13856 test_cryptodev_cpu_aesni_gcm(void)
13859 enum rte_security_session_action_type at;
13861 gbl_driver_id = rte_cryptodev_driver_id_get(
13862 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
13864 if (gbl_driver_id == -1) {
13865 RTE_LOG(ERR, USER1, "AESNI GCM PMD must be loaded.\n");
13866 return TEST_SKIPPED;
13869 at = gbl_action_type;
13870 gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
13871 rc = unit_test_suite_runner(&cryptodev_testsuite);
13872 gbl_action_type = at;
13877 test_cryptodev_null(void)
13879 gbl_driver_id = rte_cryptodev_driver_id_get(
13880 RTE_STR(CRYPTODEV_NAME_NULL_PMD));
13882 if (gbl_driver_id == -1) {
13883 RTE_LOG(ERR, USER1, "NULL PMD must be loaded.\n");
13884 return TEST_SKIPPED;
13887 return unit_test_suite_runner(&cryptodev_testsuite);
13891 test_cryptodev_sw_snow3g(void /*argv __rte_unused, int argc __rte_unused*/)
13893 gbl_driver_id = rte_cryptodev_driver_id_get(
13894 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
13896 if (gbl_driver_id == -1) {
13897 RTE_LOG(ERR, USER1, "SNOW3G PMD must be loaded.\n");
13898 return TEST_SKIPPED;
13901 return unit_test_suite_runner(&cryptodev_testsuite);
13905 test_cryptodev_sw_kasumi(void /*argv __rte_unused, int argc __rte_unused*/)
13907 gbl_driver_id = rte_cryptodev_driver_id_get(
13908 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
13910 if (gbl_driver_id == -1) {
13911 RTE_LOG(ERR, USER1, "ZUC PMD must be loaded.\n");
13912 return TEST_SKIPPED;
13915 return unit_test_suite_runner(&cryptodev_testsuite);
13919 test_cryptodev_sw_zuc(void /*argv __rte_unused, int argc __rte_unused*/)
13921 gbl_driver_id = rte_cryptodev_driver_id_get(
13922 RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
13924 if (gbl_driver_id == -1) {
13925 RTE_LOG(ERR, USER1, "ZUC PMD must be loaded.\n");
13926 return TEST_SKIPPED;
13929 return unit_test_suite_runner(&cryptodev_testsuite);
13933 test_cryptodev_armv8(void)
13935 gbl_driver_id = rte_cryptodev_driver_id_get(
13936 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
13938 if (gbl_driver_id == -1) {
13939 RTE_LOG(ERR, USER1, "ARMV8 PMD must be loaded.\n");
13940 return TEST_SKIPPED;
13943 return unit_test_suite_runner(&cryptodev_testsuite);
13947 test_cryptodev_mrvl(void)
13949 gbl_driver_id = rte_cryptodev_driver_id_get(
13950 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
13952 if (gbl_driver_id == -1) {
13953 RTE_LOG(ERR, USER1, "MVSAM PMD must be loaded.\n");
13954 return TEST_SKIPPED;
13957 return unit_test_suite_runner(&cryptodev_mrvl_testsuite);
13960 #ifdef RTE_CRYPTO_SCHEDULER
13963 test_cryptodev_scheduler(void /*argv __rte_unused, int argc __rte_unused*/)
13965 gbl_driver_id = rte_cryptodev_driver_id_get(
13966 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
13968 if (gbl_driver_id == -1) {
13969 RTE_LOG(ERR, USER1, "SCHEDULER PMD must be loaded.\n");
13970 return TEST_SKIPPED;
13973 if (rte_cryptodev_driver_id_get(
13974 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) == -1) {
13975 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded.\n");
13976 return TEST_SKIPPED;
13978 return unit_test_suite_runner(&cryptodev_scheduler_testsuite);
13981 REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler);
13986 test_cryptodev_dpaa2_sec(void /*argv __rte_unused, int argc __rte_unused*/)
13988 gbl_driver_id = rte_cryptodev_driver_id_get(
13989 RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
13991 if (gbl_driver_id == -1) {
13992 RTE_LOG(ERR, USER1, "DPAA2 SEC PMD must be loaded.\n");
13993 return TEST_SKIPPED;
13996 return unit_test_suite_runner(&cryptodev_testsuite);
14000 test_cryptodev_dpaa_sec(void /*argv __rte_unused, int argc __rte_unused*/)
14002 gbl_driver_id = rte_cryptodev_driver_id_get(
14003 RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD));
14005 if (gbl_driver_id == -1) {
14006 RTE_LOG(ERR, USER1, "DPAA SEC PMD must be loaded.\n");
14007 return TEST_SKIPPED;
14010 return unit_test_suite_runner(&cryptodev_testsuite);
14014 test_cryptodev_ccp(void)
14016 gbl_driver_id = rte_cryptodev_driver_id_get(
14017 RTE_STR(CRYPTODEV_NAME_CCP_PMD));
14019 if (gbl_driver_id == -1) {
14020 RTE_LOG(ERR, USER1, "CCP PMD must be loaded.\n");
14021 return TEST_FAILED;
14024 return unit_test_suite_runner(&cryptodev_ccp_testsuite);
14028 test_cryptodev_octeontx(void)
14030 gbl_driver_id = rte_cryptodev_driver_id_get(
14031 RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD));
14032 if (gbl_driver_id == -1) {
14033 RTE_LOG(ERR, USER1, "OCTEONTX PMD must be loaded.\n");
14034 return TEST_FAILED;
14036 return unit_test_suite_runner(&cryptodev_testsuite);
14040 test_cryptodev_octeontx2(void)
14042 gbl_driver_id = rte_cryptodev_driver_id_get(
14043 RTE_STR(CRYPTODEV_NAME_OCTEONTX2_PMD));
14044 if (gbl_driver_id == -1) {
14045 RTE_LOG(ERR, USER1, "OCTEON TX2 PMD must be loaded.\n");
14046 return TEST_FAILED;
14048 return unit_test_suite_runner(&cryptodev_testsuite);
14052 test_cryptodev_caam_jr(void /*argv __rte_unused, int argc __rte_unused*/)
14054 gbl_driver_id = rte_cryptodev_driver_id_get(
14055 RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD));
14057 if (gbl_driver_id == -1) {
14058 RTE_LOG(ERR, USER1, "CAAM_JR PMD must be loaded.\n");
14059 return TEST_FAILED;
14062 return unit_test_suite_runner(&cryptodev_caam_jr_testsuite);
14066 test_cryptodev_nitrox(void)
14068 gbl_driver_id = rte_cryptodev_driver_id_get(
14069 RTE_STR(CRYPTODEV_NAME_NITROX_PMD));
14071 if (gbl_driver_id == -1) {
14072 RTE_LOG(ERR, USER1, "NITROX PMD must be loaded.\n");
14073 return TEST_FAILED;
14076 return unit_test_suite_runner(&cryptodev_testsuite);
14080 test_cryptodev_bcmfs(void)
14082 gbl_driver_id = rte_cryptodev_driver_id_get(
14083 RTE_STR(CRYPTODEV_NAME_BCMFS_PMD));
14085 if (gbl_driver_id == -1) {
14086 RTE_LOG(ERR, USER1, "BCMFS PMD must be loaded.\n");
14087 return TEST_FAILED;
14090 return unit_test_suite_runner(&cryptodev_testsuite);
14094 test_cryptodev_qat_raw_api(void /*argv __rte_unused, int argc __rte_unused*/)
14098 gbl_driver_id = rte_cryptodev_driver_id_get(
14099 RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
14101 if (gbl_driver_id == -1) {
14102 RTE_LOG(ERR, USER1, "QAT PMD must be loaded.\n");
14103 return TEST_SKIPPED;
14106 global_api_test_type = CRYPTODEV_RAW_API_TEST;
14107 ret = unit_test_suite_runner(&cryptodev_testsuite);
14108 global_api_test_type = CRYPTODEV_API_TEST;
14113 REGISTER_TEST_COMMAND(cryptodev_qat_raw_api_autotest,
14114 test_cryptodev_qat_raw_api);
14115 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
14116 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
14117 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_mb_autotest,
14118 test_cryptodev_cpu_aesni_mb);
14119 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl);
14120 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm);
14121 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_gcm_autotest,
14122 test_cryptodev_cpu_aesni_gcm);
14123 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null);
14124 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
14125 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);
14126 REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc);
14127 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_autotest, test_cryptodev_armv8);
14128 REGISTER_TEST_COMMAND(cryptodev_sw_mvsam_autotest, test_cryptodev_mrvl);
14129 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_autotest, test_cryptodev_dpaa2_sec);
14130 REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_autotest, test_cryptodev_dpaa_sec);
14131 REGISTER_TEST_COMMAND(cryptodev_ccp_autotest, test_cryptodev_ccp);
14132 REGISTER_TEST_COMMAND(cryptodev_virtio_autotest, test_cryptodev_virtio);
14133 REGISTER_TEST_COMMAND(cryptodev_octeontx_autotest, test_cryptodev_octeontx);
14134 REGISTER_TEST_COMMAND(cryptodev_octeontx2_autotest, test_cryptodev_octeontx2);
14135 REGISTER_TEST_COMMAND(cryptodev_caam_jr_autotest, test_cryptodev_caam_jr);
14136 REGISTER_TEST_COMMAND(cryptodev_nitrox_autotest, test_cryptodev_nitrox);
14137 REGISTER_TEST_COMMAND(cryptodev_bcmfs_autotest, test_cryptodev_bcmfs);