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>
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_ipsec.h"
46 #include "test_cryptodev_security_ipsec_test_vectors.h"
47 #include "test_cryptodev_security_pdcp_test_vectors.h"
48 #include "test_cryptodev_security_pdcp_sdap_test_vectors.h"
49 #include "test_cryptodev_security_pdcp_test_func.h"
50 #include "test_cryptodev_security_docsis_test_vectors.h"
52 #define SDAP_DISABLED 0
53 #define SDAP_ENABLED 1
56 #define VDEV_ARGS_SIZE 100
57 #define MAX_NB_SESSIONS 4
59 #define MAX_DRV_SERVICE_CTX_SIZE 256
61 #define MAX_RAW_DEQUEUE_COUNT 65535
64 #define OUT_OF_PLACE 1
66 static int gbl_driver_id;
68 static enum rte_security_session_action_type gbl_action_type =
69 RTE_SECURITY_ACTION_TYPE_NONE;
71 enum cryptodev_api_test_type global_api_test_type = CRYPTODEV_API_TEST;
73 struct crypto_unittest_params {
74 struct rte_crypto_sym_xform cipher_xform;
75 struct rte_crypto_sym_xform auth_xform;
76 struct rte_crypto_sym_xform aead_xform;
77 #ifdef RTE_LIB_SECURITY
78 struct rte_security_docsis_xform docsis_xform;
82 struct rte_cryptodev_sym_session *sess;
83 #ifdef RTE_LIB_SECURITY
84 struct rte_security_session *sec_session;
87 #ifdef RTE_LIB_SECURITY
88 enum rte_security_session_action_type type;
90 struct rte_crypto_op *op;
92 struct rte_mbuf *obuf, *ibuf;
97 #define ALIGN_POW2_ROUNDUP(num, align) \
98 (((num) + (align) - 1) & ~((align) - 1))
100 #define ADD_STATIC_TESTSUITE(index, parent_ts, child_ts, num_child_ts) \
101 for (j = 0; j < num_child_ts; index++, j++) \
102 parent_ts.unit_test_suites[index] = child_ts[j]
104 #define ADD_BLOCKCIPHER_TESTSUITE(index, parent_ts, blk_types, num_blk_types) \
105 for (j = 0; j < num_blk_types; index++, j++) \
106 parent_ts.unit_test_suites[index] = \
107 build_blockcipher_test_suite(blk_types[j])
109 #define FREE_BLOCKCIPHER_TESTSUITE(index, parent_ts, num_blk_types) \
110 for (j = index; j < index + num_blk_types; j++) \
111 free_blockcipher_test_suite(parent_ts.unit_test_suites[j])
114 * Forward declarations.
117 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
118 struct crypto_unittest_params *ut_params, uint8_t *cipher_key,
122 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
123 struct crypto_unittest_params *ut_params,
124 struct crypto_testsuite_params *ts_param,
125 const uint8_t *cipher,
126 const uint8_t *digest,
130 security_proto_supported(enum rte_security_session_action_type action,
131 enum rte_security_session_protocol proto);
134 dev_configure_and_start(uint64_t ff_disable);
136 static struct rte_mbuf *
137 setup_test_string(struct rte_mempool *mpool,
138 const char *string, size_t len, uint8_t blocksize)
140 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
141 size_t t_len = len - (blocksize ? (len % blocksize) : 0);
146 memset(m->buf_addr, 0, m->buf_len);
147 dst = rte_pktmbuf_append(m, t_len);
153 rte_memcpy(dst, string, t_len);
155 memset(dst, 0, t_len);
161 /* Get number of bytes in X bits (rounding up) */
163 ceil_byte_length(uint32_t num_bits)
166 return ((num_bits >> 3) + 1);
168 return (num_bits >> 3);
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 NULL, 1, 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 struct crypto_testsuite_params *p_testsuite_params = &testsuite_params;
492 static struct crypto_unittest_params unittest_params;
495 testsuite_setup(void)
497 struct crypto_testsuite_params *ts_params = &testsuite_params;
498 struct rte_cryptodev_info info;
499 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 nb_devs = rte_cryptodev_count();
547 RTE_LOG(WARNING, USER1, "No crypto devices found?\n");
551 if (rte_cryptodev_device_count_by_driver(gbl_driver_id) < 1) {
552 RTE_LOG(WARNING, USER1, "No %s devices found?\n",
553 rte_cryptodev_driver_name_get(gbl_driver_id));
557 /* Create list of valid crypto devs */
558 for (i = 0; i < nb_devs; i++) {
559 rte_cryptodev_info_get(i, &info);
560 if (info.driver_id == gbl_driver_id)
561 ts_params->valid_devs[ts_params->valid_dev_count++] = i;
564 if (ts_params->valid_dev_count < 1)
567 /* Set up all the qps on the first of the valid devices found */
569 dev_id = ts_params->valid_devs[0];
571 rte_cryptodev_info_get(dev_id, &info);
573 ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
574 ts_params->conf.socket_id = SOCKET_ID_ANY;
575 ts_params->conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY;
577 unsigned int session_size =
578 rte_cryptodev_sym_get_private_session_size(dev_id);
580 #ifdef RTE_LIB_SECURITY
581 unsigned int security_session_size = rte_security_session_get_size(
582 rte_cryptodev_get_sec_ctx(dev_id));
584 if (session_size < security_session_size)
585 session_size = security_session_size;
588 * Create mempool with maximum number of sessions.
590 if (info.sym.max_nb_sessions != 0 &&
591 info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
592 RTE_LOG(ERR, USER1, "Device does not support "
593 "at least %u sessions\n",
598 ts_params->session_mpool = rte_cryptodev_sym_session_pool_create(
599 "test_sess_mp", MAX_NB_SESSIONS, 0, 0, 0,
601 TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
602 "session mempool allocation failed");
604 ts_params->session_priv_mpool = rte_mempool_create(
608 0, 0, NULL, NULL, NULL,
611 TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
612 "session mempool allocation failed");
616 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id,
618 "Failed to configure cryptodev %u with %u qps",
619 dev_id, ts_params->conf.nb_queue_pairs);
621 ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
622 ts_params->qp_conf.mp_session = ts_params->session_mpool;
623 ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
625 for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) {
626 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
627 dev_id, qp_id, &ts_params->qp_conf,
628 rte_cryptodev_socket_id(dev_id)),
629 "Failed to setup queue pair %u on cryptodev %u",
637 testsuite_teardown(void)
639 struct crypto_testsuite_params *ts_params = &testsuite_params;
642 if (ts_params->mbuf_pool != NULL) {
643 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
644 rte_mempool_avail_count(ts_params->mbuf_pool));
647 if (ts_params->op_mpool != NULL) {
648 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n",
649 rte_mempool_avail_count(ts_params->op_mpool));
652 /* Free session mempools */
653 if (ts_params->session_priv_mpool != NULL) {
654 rte_mempool_free(ts_params->session_priv_mpool);
655 ts_params->session_priv_mpool = NULL;
658 if (ts_params->session_mpool != NULL) {
659 rte_mempool_free(ts_params->session_mpool);
660 ts_params->session_mpool = NULL;
663 res = rte_cryptodev_close(ts_params->valid_devs[0]);
665 RTE_LOG(ERR, USER1, "Crypto device close error %d\n", res);
669 check_capabilities_supported(enum rte_crypto_sym_xform_type type,
670 const int *algs, uint16_t num_algs)
672 uint8_t dev_id = testsuite_params.valid_devs[0];
673 bool some_alg_supported = FALSE;
676 for (i = 0; i < num_algs && !some_alg_supported; i++) {
677 struct rte_cryptodev_sym_capability_idx alg = {
680 if (rte_cryptodev_sym_capability_get(dev_id,
682 some_alg_supported = TRUE;
684 if (!some_alg_supported)
691 check_cipher_capabilities_supported(const enum rte_crypto_cipher_algorithm *ciphers,
692 uint16_t num_ciphers)
694 return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_CIPHER,
695 (const int *) ciphers, num_ciphers);
699 check_auth_capabilities_supported(const enum rte_crypto_auth_algorithm *auths,
702 return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_AUTH,
703 (const int *) auths, num_auths);
707 check_aead_capabilities_supported(const enum rte_crypto_aead_algorithm *aeads,
710 return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_AEAD,
711 (const int *) aeads, num_aeads);
715 null_testsuite_setup(void)
717 struct crypto_testsuite_params *ts_params = &testsuite_params;
718 uint8_t dev_id = ts_params->valid_devs[0];
719 struct rte_cryptodev_info dev_info;
720 const enum rte_crypto_cipher_algorithm ciphers[] = {
721 RTE_CRYPTO_CIPHER_NULL
723 const enum rte_crypto_auth_algorithm auths[] = {
727 rte_cryptodev_info_get(dev_id, &dev_info);
729 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
730 RTE_LOG(INFO, USER1, "Feature flag requirements for NULL "
731 "testsuite not met\n");
735 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
736 && check_auth_capabilities_supported(auths,
737 RTE_DIM(auths)) != 0) {
738 RTE_LOG(INFO, USER1, "Capability requirements for NULL "
739 "testsuite not met\n");
747 crypto_gen_testsuite_setup(void)
749 struct crypto_testsuite_params *ts_params = &testsuite_params;
750 uint8_t dev_id = ts_params->valid_devs[0];
751 struct rte_cryptodev_info dev_info;
753 rte_cryptodev_info_get(dev_id, &dev_info);
755 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
756 RTE_LOG(INFO, USER1, "Feature flag requirements for Crypto Gen "
757 "testsuite not met\n");
764 #ifdef RTE_LIB_SECURITY
766 ipsec_proto_testsuite_setup(void)
768 struct crypto_testsuite_params *ts_params = &testsuite_params;
769 struct crypto_unittest_params *ut_params = &unittest_params;
770 struct rte_cryptodev_info dev_info;
773 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
775 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SECURITY)) {
776 RTE_LOG(INFO, USER1, "Feature flag requirements for IPsec Proto "
777 "testsuite not met\n");
781 /* Reconfigure to enable security */
782 ret = dev_configure_and_start(0);
783 if (ret != TEST_SUCCESS)
786 /* Set action type */
787 ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
789 if (security_proto_supported(
790 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
791 RTE_SECURITY_PROTOCOL_IPSEC) < 0) {
792 RTE_LOG(INFO, USER1, "Capability requirements for IPsec Proto "
798 * Stop the device. Device would be started again by individual test
799 * case setup routine.
801 rte_cryptodev_stop(ts_params->valid_devs[0]);
807 pdcp_proto_testsuite_setup(void)
809 struct crypto_testsuite_params *ts_params = &testsuite_params;
810 uint8_t dev_id = ts_params->valid_devs[0];
811 struct rte_cryptodev_info dev_info;
812 const enum rte_crypto_cipher_algorithm ciphers[] = {
813 RTE_CRYPTO_CIPHER_NULL,
814 RTE_CRYPTO_CIPHER_AES_CTR,
815 RTE_CRYPTO_CIPHER_ZUC_EEA3,
816 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
818 const enum rte_crypto_auth_algorithm auths[] = {
819 RTE_CRYPTO_AUTH_NULL,
820 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
821 RTE_CRYPTO_AUTH_AES_CMAC,
822 RTE_CRYPTO_AUTH_ZUC_EIA3
825 rte_cryptodev_info_get(dev_id, &dev_info);
827 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
828 !(dev_info.feature_flags &
829 RTE_CRYPTODEV_FF_SECURITY)) {
830 RTE_LOG(INFO, USER1, "Feature flag requirements for PDCP Proto "
831 "testsuite not met\n");
835 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
836 && check_auth_capabilities_supported(auths,
837 RTE_DIM(auths)) != 0) {
838 RTE_LOG(INFO, USER1, "Capability requirements for PDCP Proto "
839 "testsuite not met\n");
847 docsis_proto_testsuite_setup(void)
849 struct crypto_testsuite_params *ts_params = &testsuite_params;
850 uint8_t dev_id = ts_params->valid_devs[0];
851 struct rte_cryptodev_info dev_info;
852 const enum rte_crypto_cipher_algorithm ciphers[] = {
853 RTE_CRYPTO_CIPHER_AES_DOCSISBPI
856 rte_cryptodev_info_get(dev_id, &dev_info);
858 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
859 !(dev_info.feature_flags &
860 RTE_CRYPTODEV_FF_SECURITY)) {
861 RTE_LOG(INFO, USER1, "Feature flag requirements for Docsis "
862 "Proto testsuite not met\n");
866 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0) {
867 RTE_LOG(INFO, USER1, "Capability requirements for Docsis Proto "
868 "testsuite not met\n");
877 aes_ccm_auth_testsuite_setup(void)
879 struct crypto_testsuite_params *ts_params = &testsuite_params;
880 uint8_t dev_id = ts_params->valid_devs[0];
881 struct rte_cryptodev_info dev_info;
882 const enum rte_crypto_aead_algorithm aeads[] = {
883 RTE_CRYPTO_AEAD_AES_CCM
886 rte_cryptodev_info_get(dev_id, &dev_info);
888 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
889 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
890 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
891 RTE_LOG(INFO, USER1, "Feature flag requirements for AES CCM "
892 "testsuite not met\n");
896 if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
897 RTE_LOG(INFO, USER1, "Capability requirements for AES CCM "
898 "testsuite not met\n");
906 aes_gcm_auth_testsuite_setup(void)
908 struct crypto_testsuite_params *ts_params = &testsuite_params;
909 uint8_t dev_id = ts_params->valid_devs[0];
910 struct rte_cryptodev_info dev_info;
911 const enum rte_crypto_aead_algorithm aeads[] = {
912 RTE_CRYPTO_AEAD_AES_GCM
915 rte_cryptodev_info_get(dev_id, &dev_info);
917 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
918 RTE_LOG(INFO, USER1, "Feature flag requirements for AES GCM "
919 "testsuite not met\n");
923 if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
924 RTE_LOG(INFO, USER1, "Capability requirements for AES GCM "
925 "testsuite not met\n");
933 aes_gmac_auth_testsuite_setup(void)
935 struct crypto_testsuite_params *ts_params = &testsuite_params;
936 uint8_t dev_id = ts_params->valid_devs[0];
937 struct rte_cryptodev_info dev_info;
938 const enum rte_crypto_auth_algorithm auths[] = {
939 RTE_CRYPTO_AUTH_AES_GMAC
942 rte_cryptodev_info_get(dev_id, &dev_info);
944 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
945 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
946 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
947 RTE_LOG(INFO, USER1, "Feature flag requirements for AES GMAC "
948 "testsuite not met\n");
952 if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
953 RTE_LOG(INFO, USER1, "Capability requirements for AES GMAC "
954 "testsuite not met\n");
962 chacha20_poly1305_testsuite_setup(void)
964 struct crypto_testsuite_params *ts_params = &testsuite_params;
965 uint8_t dev_id = ts_params->valid_devs[0];
966 struct rte_cryptodev_info dev_info;
967 const enum rte_crypto_aead_algorithm aeads[] = {
968 RTE_CRYPTO_AEAD_CHACHA20_POLY1305
971 rte_cryptodev_info_get(dev_id, &dev_info);
973 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
974 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
975 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
976 RTE_LOG(INFO, USER1, "Feature flag requirements for "
977 "Chacha20-Poly1305 testsuite not met\n");
981 if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
982 RTE_LOG(INFO, USER1, "Capability requirements for "
983 "Chacha20-Poly1305 testsuite not met\n");
991 snow3g_testsuite_setup(void)
993 struct crypto_testsuite_params *ts_params = &testsuite_params;
994 uint8_t dev_id = ts_params->valid_devs[0];
995 struct rte_cryptodev_info dev_info;
996 const enum rte_crypto_cipher_algorithm ciphers[] = {
997 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
1000 const enum rte_crypto_auth_algorithm auths[] = {
1001 RTE_CRYPTO_AUTH_SNOW3G_UIA2
1004 rte_cryptodev_info_get(dev_id, &dev_info);
1006 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1007 RTE_LOG(INFO, USER1, "Feature flag requirements for Snow3G "
1008 "testsuite not met\n");
1009 return TEST_SKIPPED;
1012 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1013 && check_auth_capabilities_supported(auths,
1014 RTE_DIM(auths)) != 0) {
1015 RTE_LOG(INFO, USER1, "Capability requirements for Snow3G "
1016 "testsuite not met\n");
1017 return TEST_SKIPPED;
1024 zuc_testsuite_setup(void)
1026 struct crypto_testsuite_params *ts_params = &testsuite_params;
1027 uint8_t dev_id = ts_params->valid_devs[0];
1028 struct rte_cryptodev_info dev_info;
1029 const enum rte_crypto_cipher_algorithm ciphers[] = {
1030 RTE_CRYPTO_CIPHER_ZUC_EEA3
1032 const enum rte_crypto_auth_algorithm auths[] = {
1033 RTE_CRYPTO_AUTH_ZUC_EIA3
1036 rte_cryptodev_info_get(dev_id, &dev_info);
1038 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1039 RTE_LOG(INFO, USER1, "Feature flag requirements for ZUC "
1040 "testsuite not met\n");
1041 return TEST_SKIPPED;
1044 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1045 && check_auth_capabilities_supported(auths,
1046 RTE_DIM(auths)) != 0) {
1047 RTE_LOG(INFO, USER1, "Capability requirements for ZUC "
1048 "testsuite not met\n");
1049 return TEST_SKIPPED;
1056 hmac_md5_auth_testsuite_setup(void)
1058 struct crypto_testsuite_params *ts_params = &testsuite_params;
1059 uint8_t dev_id = ts_params->valid_devs[0];
1060 struct rte_cryptodev_info dev_info;
1061 const enum rte_crypto_auth_algorithm auths[] = {
1062 RTE_CRYPTO_AUTH_MD5_HMAC
1065 rte_cryptodev_info_get(dev_id, &dev_info);
1067 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1068 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1069 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1070 RTE_LOG(INFO, USER1, "Feature flag requirements for HMAC MD5 "
1071 "Auth testsuite not met\n");
1072 return TEST_SKIPPED;
1075 if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
1076 RTE_LOG(INFO, USER1, "Capability requirements for HMAC MD5 "
1077 "testsuite not met\n");
1078 return TEST_SKIPPED;
1085 kasumi_testsuite_setup(void)
1087 struct crypto_testsuite_params *ts_params = &testsuite_params;
1088 uint8_t dev_id = ts_params->valid_devs[0];
1089 struct rte_cryptodev_info dev_info;
1090 const enum rte_crypto_cipher_algorithm ciphers[] = {
1091 RTE_CRYPTO_CIPHER_KASUMI_F8
1093 const enum rte_crypto_auth_algorithm auths[] = {
1094 RTE_CRYPTO_AUTH_KASUMI_F9
1097 rte_cryptodev_info_get(dev_id, &dev_info);
1099 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1100 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1101 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1102 RTE_LOG(INFO, USER1, "Feature flag requirements for Kasumi "
1103 "testsuite not met\n");
1104 return TEST_SKIPPED;
1107 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1108 && check_auth_capabilities_supported(auths,
1109 RTE_DIM(auths)) != 0) {
1110 RTE_LOG(INFO, USER1, "Capability requirements for Kasumi "
1111 "testsuite not met\n");
1112 return TEST_SKIPPED;
1119 negative_aes_gcm_testsuite_setup(void)
1121 struct crypto_testsuite_params *ts_params = &testsuite_params;
1122 uint8_t dev_id = ts_params->valid_devs[0];
1123 struct rte_cryptodev_info dev_info;
1124 const enum rte_crypto_aead_algorithm aeads[] = {
1125 RTE_CRYPTO_AEAD_AES_GCM
1128 rte_cryptodev_info_get(dev_id, &dev_info);
1130 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1131 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1132 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1133 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1134 "AES GCM testsuite not met\n");
1135 return TEST_SKIPPED;
1138 if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
1139 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1140 "AES GCM testsuite not met\n");
1141 return TEST_SKIPPED;
1148 negative_aes_gmac_testsuite_setup(void)
1150 struct crypto_testsuite_params *ts_params = &testsuite_params;
1151 uint8_t dev_id = ts_params->valid_devs[0];
1152 struct rte_cryptodev_info dev_info;
1153 const enum rte_crypto_auth_algorithm auths[] = {
1154 RTE_CRYPTO_AUTH_AES_GMAC
1157 rte_cryptodev_info_get(dev_id, &dev_info);
1159 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1160 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1161 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1162 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1163 "AES GMAC testsuite not met\n");
1164 return TEST_SKIPPED;
1167 if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
1168 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1169 "AES GMAC testsuite not met\n");
1170 return TEST_SKIPPED;
1177 mixed_cipher_hash_testsuite_setup(void)
1179 struct crypto_testsuite_params *ts_params = &testsuite_params;
1180 uint8_t dev_id = ts_params->valid_devs[0];
1181 struct rte_cryptodev_info dev_info;
1182 uint64_t feat_flags;
1183 const enum rte_crypto_cipher_algorithm ciphers[] = {
1184 RTE_CRYPTO_CIPHER_NULL,
1185 RTE_CRYPTO_CIPHER_AES_CTR,
1186 RTE_CRYPTO_CIPHER_ZUC_EEA3,
1187 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
1189 const enum rte_crypto_auth_algorithm auths[] = {
1190 RTE_CRYPTO_AUTH_NULL,
1191 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
1192 RTE_CRYPTO_AUTH_AES_CMAC,
1193 RTE_CRYPTO_AUTH_ZUC_EIA3
1196 rte_cryptodev_info_get(dev_id, &dev_info);
1197 feat_flags = dev_info.feature_flags;
1199 if (!(feat_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1200 (global_api_test_type == CRYPTODEV_RAW_API_TEST)) {
1201 RTE_LOG(INFO, USER1, "Feature flag requirements for Mixed "
1202 "Cipher Hash testsuite not met\n");
1203 return TEST_SKIPPED;
1206 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1207 && check_auth_capabilities_supported(auths,
1208 RTE_DIM(auths)) != 0) {
1209 RTE_LOG(INFO, USER1, "Capability requirements for Mixed "
1210 "Cipher Hash testsuite not met\n");
1211 return TEST_SKIPPED;
1218 esn_testsuite_setup(void)
1220 struct crypto_testsuite_params *ts_params = &testsuite_params;
1221 uint8_t dev_id = ts_params->valid_devs[0];
1222 struct rte_cryptodev_info dev_info;
1223 const enum rte_crypto_cipher_algorithm ciphers[] = {
1224 RTE_CRYPTO_CIPHER_AES_CBC
1226 const enum rte_crypto_auth_algorithm auths[] = {
1227 RTE_CRYPTO_AUTH_SHA1_HMAC
1230 rte_cryptodev_info_get(dev_id, &dev_info);
1232 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1233 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1234 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1235 RTE_LOG(INFO, USER1, "Feature flag requirements for ESN "
1236 "testsuite not met\n");
1237 return TEST_SKIPPED;
1240 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1241 && check_auth_capabilities_supported(auths,
1242 RTE_DIM(auths)) != 0) {
1243 RTE_LOG(INFO, USER1, "Capability requirements for ESN "
1244 "testsuite not met\n");
1245 return TEST_SKIPPED;
1252 multi_session_testsuite_setup(void)
1254 struct crypto_testsuite_params *ts_params = &testsuite_params;
1255 uint8_t dev_id = ts_params->valid_devs[0];
1256 struct rte_cryptodev_info dev_info;
1257 const enum rte_crypto_cipher_algorithm ciphers[] = {
1258 RTE_CRYPTO_CIPHER_AES_CBC
1260 const enum rte_crypto_auth_algorithm auths[] = {
1261 RTE_CRYPTO_AUTH_SHA512_HMAC
1264 rte_cryptodev_info_get(dev_id, &dev_info);
1266 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1267 RTE_LOG(INFO, USER1, "Feature flag requirements for Multi "
1268 "Session testsuite not met\n");
1269 return TEST_SKIPPED;
1272 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1273 && check_auth_capabilities_supported(auths,
1274 RTE_DIM(auths)) != 0) {
1275 RTE_LOG(INFO, USER1, "Capability requirements for Multi "
1276 "Session testsuite not met\n");
1277 return TEST_SKIPPED;
1284 negative_hmac_sha1_testsuite_setup(void)
1286 struct crypto_testsuite_params *ts_params = &testsuite_params;
1287 uint8_t dev_id = ts_params->valid_devs[0];
1288 struct rte_cryptodev_info dev_info;
1289 const enum rte_crypto_cipher_algorithm ciphers[] = {
1290 RTE_CRYPTO_CIPHER_AES_CBC
1292 const enum rte_crypto_auth_algorithm auths[] = {
1293 RTE_CRYPTO_AUTH_SHA1_HMAC
1296 rte_cryptodev_info_get(dev_id, &dev_info);
1298 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1299 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1300 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1301 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1302 "HMAC SHA1 testsuite not met\n");
1303 return TEST_SKIPPED;
1306 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1307 && check_auth_capabilities_supported(auths,
1308 RTE_DIM(auths)) != 0) {
1309 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1310 "HMAC SHA1 testsuite not met\n");
1311 return TEST_SKIPPED;
1318 dev_configure_and_start(uint64_t ff_disable)
1320 struct crypto_testsuite_params *ts_params = &testsuite_params;
1321 struct crypto_unittest_params *ut_params = &unittest_params;
1325 /* Clear unit test parameters before running test */
1326 memset(ut_params, 0, sizeof(*ut_params));
1328 /* Reconfigure device to default parameters */
1329 ts_params->conf.socket_id = SOCKET_ID_ANY;
1330 ts_params->conf.ff_disable = ff_disable;
1331 ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
1332 ts_params->qp_conf.mp_session = ts_params->session_mpool;
1333 ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
1335 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1337 "Failed to configure cryptodev %u",
1338 ts_params->valid_devs[0]);
1340 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
1341 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1342 ts_params->valid_devs[0], qp_id,
1343 &ts_params->qp_conf,
1344 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1345 "Failed to setup queue pair %u on cryptodev %u",
1346 qp_id, ts_params->valid_devs[0]);
1350 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
1352 /* Start the device */
1353 TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
1354 "Failed to start cryptodev %u",
1355 ts_params->valid_devs[0]);
1357 return TEST_SUCCESS;
1363 /* Configure and start the device with security feature disabled */
1364 return dev_configure_and_start(RTE_CRYPTODEV_FF_SECURITY);
1368 ut_setup_security(void)
1370 /* Configure and start the device with no features disabled */
1371 return dev_configure_and_start(0);
1377 struct crypto_testsuite_params *ts_params = &testsuite_params;
1378 struct crypto_unittest_params *ut_params = &unittest_params;
1379 struct rte_cryptodev_stats stats;
1381 /* free crypto session structure */
1382 #ifdef RTE_LIB_SECURITY
1383 if (ut_params->type == RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL) {
1384 if (ut_params->sec_session) {
1385 rte_security_session_destroy(rte_cryptodev_get_sec_ctx
1386 (ts_params->valid_devs[0]),
1387 ut_params->sec_session);
1388 ut_params->sec_session = NULL;
1393 if (ut_params->sess) {
1394 rte_cryptodev_sym_session_clear(
1395 ts_params->valid_devs[0],
1397 rte_cryptodev_sym_session_free(ut_params->sess);
1398 ut_params->sess = NULL;
1402 /* free crypto operation structure */
1404 rte_crypto_op_free(ut_params->op);
1407 * free mbuf - both obuf and ibuf are usually the same,
1408 * so check if they point at the same address is necessary,
1409 * to avoid freeing the mbuf twice.
1411 if (ut_params->obuf) {
1412 rte_pktmbuf_free(ut_params->obuf);
1413 if (ut_params->ibuf == ut_params->obuf)
1414 ut_params->ibuf = 0;
1415 ut_params->obuf = 0;
1417 if (ut_params->ibuf) {
1418 rte_pktmbuf_free(ut_params->ibuf);
1419 ut_params->ibuf = 0;
1422 if (ts_params->mbuf_pool != NULL)
1423 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
1424 rte_mempool_avail_count(ts_params->mbuf_pool));
1426 rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats);
1428 /* Stop the device */
1429 rte_cryptodev_stop(ts_params->valid_devs[0]);
1433 test_device_configure_invalid_dev_id(void)
1435 struct crypto_testsuite_params *ts_params = &testsuite_params;
1436 uint16_t dev_id, num_devs = 0;
1438 TEST_ASSERT((num_devs = rte_cryptodev_count()) >= 1,
1439 "Need at least %d devices for test", 1);
1441 /* valid dev_id values */
1442 dev_id = ts_params->valid_devs[0];
1444 /* Stop the device in case it's started so it can be configured */
1445 rte_cryptodev_stop(dev_id);
1447 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf),
1448 "Failed test for rte_cryptodev_configure: "
1449 "invalid dev_num %u", dev_id);
1451 /* invalid dev_id values */
1454 TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
1455 "Failed test for rte_cryptodev_configure: "
1456 "invalid dev_num %u", dev_id);
1460 TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
1461 "Failed test for rte_cryptodev_configure:"
1462 "invalid dev_num %u", dev_id);
1464 return TEST_SUCCESS;
1468 test_device_configure_invalid_queue_pair_ids(void)
1470 struct crypto_testsuite_params *ts_params = &testsuite_params;
1471 uint16_t orig_nb_qps = ts_params->conf.nb_queue_pairs;
1473 /* Stop the device in case it's started so it can be configured */
1474 rte_cryptodev_stop(ts_params->valid_devs[0]);
1476 /* valid - max value queue pairs */
1477 ts_params->conf.nb_queue_pairs = orig_nb_qps;
1479 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1481 "Failed to configure cryptodev: dev_id %u, qp_id %u",
1482 ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
1484 /* valid - one queue pairs */
1485 ts_params->conf.nb_queue_pairs = 1;
1487 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1489 "Failed to configure cryptodev: dev_id %u, qp_id %u",
1490 ts_params->valid_devs[0],
1491 ts_params->conf.nb_queue_pairs);
1494 /* invalid - zero queue pairs */
1495 ts_params->conf.nb_queue_pairs = 0;
1497 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1499 "Failed test for rte_cryptodev_configure, dev_id %u,"
1501 ts_params->valid_devs[0],
1502 ts_params->conf.nb_queue_pairs);
1505 /* invalid - max value supported by field queue pairs */
1506 ts_params->conf.nb_queue_pairs = UINT16_MAX;
1508 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1510 "Failed test for rte_cryptodev_configure, dev_id %u,"
1512 ts_params->valid_devs[0],
1513 ts_params->conf.nb_queue_pairs);
1516 /* invalid - max value + 1 queue pairs */
1517 ts_params->conf.nb_queue_pairs = orig_nb_qps + 1;
1519 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1521 "Failed test for rte_cryptodev_configure, dev_id %u,"
1523 ts_params->valid_devs[0],
1524 ts_params->conf.nb_queue_pairs);
1526 /* revert to original testsuite value */
1527 ts_params->conf.nb_queue_pairs = orig_nb_qps;
1529 return TEST_SUCCESS;
1533 test_queue_pair_descriptor_setup(void)
1535 struct crypto_testsuite_params *ts_params = &testsuite_params;
1536 struct rte_cryptodev_qp_conf qp_conf = {
1537 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
1541 /* Stop the device in case it's started so it can be configured */
1542 rte_cryptodev_stop(ts_params->valid_devs[0]);
1544 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1546 "Failed to configure cryptodev %u",
1547 ts_params->valid_devs[0]);
1550 * Test various ring sizes on this device. memzones can't be
1551 * freed so are re-used if ring is released and re-created.
1553 qp_conf.nb_descriptors = MIN_NUM_OPS_INFLIGHT; /* min size*/
1554 qp_conf.mp_session = ts_params->session_mpool;
1555 qp_conf.mp_session_private = ts_params->session_priv_mpool;
1557 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1558 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1559 ts_params->valid_devs[0], qp_id, &qp_conf,
1560 rte_cryptodev_socket_id(
1561 ts_params->valid_devs[0])),
1563 "rte_cryptodev_queue_pair_setup: num_inflights "
1564 "%u on qp %u on cryptodev %u",
1565 qp_conf.nb_descriptors, qp_id,
1566 ts_params->valid_devs[0]);
1569 qp_conf.nb_descriptors = (uint32_t)(MAX_NUM_OPS_INFLIGHT / 2);
1571 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1572 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1573 ts_params->valid_devs[0], qp_id, &qp_conf,
1574 rte_cryptodev_socket_id(
1575 ts_params->valid_devs[0])),
1577 " rte_cryptodev_queue_pair_setup: num_inflights"
1578 " %u on qp %u on cryptodev %u",
1579 qp_conf.nb_descriptors, qp_id,
1580 ts_params->valid_devs[0]);
1583 qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; /* valid */
1585 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1586 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1587 ts_params->valid_devs[0], qp_id, &qp_conf,
1588 rte_cryptodev_socket_id(
1589 ts_params->valid_devs[0])),
1591 "rte_cryptodev_queue_pair_setup: num_inflights"
1592 " %u on qp %u on cryptodev %u",
1593 qp_conf.nb_descriptors, qp_id,
1594 ts_params->valid_devs[0]);
1597 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
1599 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1600 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1601 ts_params->valid_devs[0], qp_id, &qp_conf,
1602 rte_cryptodev_socket_id(
1603 ts_params->valid_devs[0])),
1605 " rte_cryptodev_queue_pair_setup:"
1606 "num_inflights %u on qp %u on cryptodev %u",
1607 qp_conf.nb_descriptors, qp_id,
1608 ts_params->valid_devs[0]);
1611 /* test invalid queue pair id */
1612 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT; /*valid */
1614 qp_id = ts_params->conf.nb_queue_pairs; /*invalid */
1616 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
1617 ts_params->valid_devs[0],
1619 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1620 "Failed test for rte_cryptodev_queue_pair_setup:"
1621 "invalid qp %u on cryptodev %u",
1622 qp_id, ts_params->valid_devs[0]);
1624 qp_id = 0xffff; /*invalid*/
1626 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
1627 ts_params->valid_devs[0],
1629 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1630 "Failed test for rte_cryptodev_queue_pair_setup:"
1631 "invalid qp %u on cryptodev %u",
1632 qp_id, ts_params->valid_devs[0]);
1634 return TEST_SUCCESS;
1637 /* ***** Plaintext data for tests ***** */
1639 const char catch_22_quote_1[] =
1640 "There was only one catch and that was Catch-22, which "
1641 "specified that a concern for one's safety in the face of "
1642 "dangers that were real and immediate was the process of a "
1643 "rational mind. Orr was crazy and could be grounded. All he "
1644 "had to do was ask; and as soon as he did, he would no longer "
1645 "be crazy and would have to fly more missions. Orr would be "
1646 "crazy to fly more missions and sane if he didn't, but if he "
1647 "was sane he had to fly them. If he flew them he was crazy "
1648 "and didn't have to; but if he didn't want to he was sane and "
1649 "had to. Yossarian was moved very deeply by the absolute "
1650 "simplicity of this clause of Catch-22 and let out a "
1651 "respectful whistle. \"That's some catch, that Catch-22\", he "
1652 "observed. \"It's the best there is,\" Doc Daneeka agreed.";
1654 const char catch_22_quote[] =
1655 "What a lousy earth! He wondered how many people were "
1656 "destitute that same night even in his own prosperous country, "
1657 "how many homes were shanties, how many husbands were drunk "
1658 "and wives socked, and how many children were bullied, abused, "
1659 "or abandoned. How many families hungered for food they could "
1660 "not afford to buy? How many hearts were broken? How many "
1661 "suicides would take place that same night, how many people "
1662 "would go insane? How many cockroaches and landlords would "
1663 "triumph? How many winners were losers, successes failures, "
1664 "and rich men poor men? How many wise guys were stupid? How "
1665 "many happy endings were unhappy endings? How many honest men "
1666 "were liars, brave men cowards, loyal men traitors, how many "
1667 "sainted men were corrupt, how many people in positions of "
1668 "trust had sold their souls to bodyguards, how many had never "
1669 "had souls? How many straight-and-narrow paths were crooked "
1670 "paths? How many best families were worst families and how "
1671 "many good people were bad people? When you added them all up "
1672 "and then subtracted, you might be left with only the children, "
1673 "and perhaps with Albert Einstein and an old violinist or "
1674 "sculptor somewhere.";
1676 #define QUOTE_480_BYTES (480)
1677 #define QUOTE_512_BYTES (512)
1678 #define QUOTE_768_BYTES (768)
1679 #define QUOTE_1024_BYTES (1024)
1683 /* ***** SHA1 Hash Tests ***** */
1685 #define HMAC_KEY_LENGTH_SHA1 (DIGEST_BYTE_LENGTH_SHA1)
1687 static uint8_t hmac_sha1_key[] = {
1688 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
1689 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
1690 0xDE, 0xF4, 0xDE, 0xAD };
1692 /* ***** SHA224 Hash Tests ***** */
1694 #define HMAC_KEY_LENGTH_SHA224 (DIGEST_BYTE_LENGTH_SHA224)
1697 /* ***** AES-CBC Cipher Tests ***** */
1699 #define CIPHER_KEY_LENGTH_AES_CBC (16)
1700 #define CIPHER_IV_LENGTH_AES_CBC (CIPHER_KEY_LENGTH_AES_CBC)
1702 static uint8_t aes_cbc_key[] = {
1703 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
1704 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A };
1706 static uint8_t aes_cbc_iv[] = {
1707 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1708 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
1711 /* ***** AES-CBC / HMAC-SHA1 Hash Tests ***** */
1713 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_ciphertext[] = {
1714 0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31,
1715 0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76,
1716 0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E,
1717 0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A,
1718 0x3F, 0x6B, 0x5D, 0xDF, 0x52, 0x85, 0x5F, 0x8E,
1719 0x42, 0x3C, 0xFB, 0xE9, 0x1A, 0x24, 0xD6, 0x08,
1720 0xDD, 0xFD, 0x16, 0xFB, 0xE9, 0x55, 0xEF, 0xF0,
1721 0xA0, 0x8D, 0x13, 0xAB, 0x81, 0xC6, 0x90, 0x01,
1722 0xB5, 0x18, 0x84, 0xB3, 0xF6, 0xE6, 0x11, 0x57,
1723 0xD6, 0x71, 0xC6, 0x3C, 0x3F, 0x2F, 0x33, 0xEE,
1724 0x24, 0x42, 0x6E, 0xAC, 0x0B, 0xCA, 0xEC, 0xF9,
1725 0x84, 0xF8, 0x22, 0xAA, 0x60, 0xF0, 0x32, 0xA9,
1726 0x75, 0x75, 0x3B, 0xCB, 0x70, 0x21, 0x0A, 0x8D,
1727 0x0F, 0xE0, 0xC4, 0x78, 0x2B, 0xF8, 0x97, 0xE3,
1728 0xE4, 0x26, 0x4B, 0x29, 0xDA, 0x88, 0xCD, 0x46,
1729 0xEC, 0xAA, 0xF9, 0x7F, 0xF1, 0x15, 0xEA, 0xC3,
1730 0x87, 0xE6, 0x31, 0xF2, 0xCF, 0xDE, 0x4D, 0x80,
1731 0x70, 0x91, 0x7E, 0x0C, 0xF7, 0x26, 0x3A, 0x92,
1732 0x4F, 0x18, 0x83, 0xC0, 0x8F, 0x59, 0x01, 0xA5,
1733 0x88, 0xD1, 0xDB, 0x26, 0x71, 0x27, 0x16, 0xF5,
1734 0xEE, 0x10, 0x82, 0xAC, 0x68, 0x26, 0x9B, 0xE2,
1735 0x6D, 0xD8, 0x9A, 0x80, 0xDF, 0x04, 0x31, 0xD5,
1736 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1737 0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
1738 0x73, 0x02, 0x42, 0xC9, 0x23, 0x18, 0x8E, 0xB4,
1739 0x6F, 0xB4, 0xA3, 0x54, 0x6E, 0x88, 0x3B, 0x62,
1740 0x7C, 0x02, 0x8D, 0x4C, 0x9F, 0xC8, 0x45, 0xF4,
1741 0xC9, 0xDE, 0x4F, 0xEB, 0x22, 0x83, 0x1B, 0xE4,
1742 0x49, 0x37, 0xE4, 0xAD, 0xE7, 0xCD, 0x21, 0x54,
1743 0xBC, 0x1C, 0xC2, 0x04, 0x97, 0xB4, 0x10, 0x61,
1744 0xF0, 0xE4, 0xEF, 0x27, 0x63, 0x3A, 0xDA, 0x91,
1745 0x41, 0x25, 0x62, 0x1C, 0x5C, 0xB6, 0x38, 0x4A,
1746 0x88, 0x71, 0x59, 0x5A, 0x8D, 0xA0, 0x09, 0xAF,
1747 0x72, 0x94, 0xD7, 0x79, 0x5C, 0x60, 0x7C, 0x8F,
1748 0x4C, 0xF5, 0xD9, 0xA1, 0x39, 0x6D, 0x81, 0x28,
1749 0xEF, 0x13, 0x28, 0xDF, 0xF5, 0x3E, 0xF7, 0x8E,
1750 0x09, 0x9C, 0x78, 0x18, 0x79, 0xB8, 0x68, 0xD7,
1751 0xA8, 0x29, 0x62, 0xAD, 0xDE, 0xE1, 0x61, 0x76,
1752 0x1B, 0x05, 0x16, 0xCD, 0xBF, 0x02, 0x8E, 0xA6,
1753 0x43, 0x6E, 0x92, 0x55, 0x4F, 0x60, 0x9C, 0x03,
1754 0xB8, 0x4F, 0xA3, 0x02, 0xAC, 0xA8, 0xA7, 0x0C,
1755 0x1E, 0xB5, 0x6B, 0xF8, 0xC8, 0x4D, 0xDE, 0xD2,
1756 0xB0, 0x29, 0x6E, 0x40, 0xE6, 0xD6, 0xC9, 0xE6,
1757 0xB9, 0x0F, 0xB6, 0x63, 0xF5, 0xAA, 0x2B, 0x96,
1758 0xA7, 0x16, 0xAC, 0x4E, 0x0A, 0x33, 0x1C, 0xA6,
1759 0xE6, 0xBD, 0x8A, 0xCF, 0x40, 0xA9, 0xB2, 0xFA,
1760 0x63, 0x27, 0xFD, 0x9B, 0xD9, 0xFC, 0xD5, 0x87,
1761 0x8D, 0x4C, 0xB6, 0xA4, 0xCB, 0xE7, 0x74, 0x55,
1762 0xF4, 0xFB, 0x41, 0x25, 0xB5, 0x4B, 0x0A, 0x1B,
1763 0xB1, 0xD6, 0xB7, 0xD9, 0x47, 0x2A, 0xC3, 0x98,
1764 0x6A, 0xC4, 0x03, 0x73, 0x1F, 0x93, 0x6E, 0x53,
1765 0x19, 0x25, 0x64, 0x15, 0x83, 0xF9, 0x73, 0x2A,
1766 0x74, 0xB4, 0x93, 0x69, 0xC4, 0x72, 0xFC, 0x26,
1767 0xA2, 0x9F, 0x43, 0x45, 0xDD, 0xB9, 0xEF, 0x36,
1768 0xC8, 0x3A, 0xCD, 0x99, 0x9B, 0x54, 0x1A, 0x36,
1769 0xC1, 0x59, 0xF8, 0x98, 0xA8, 0xCC, 0x28, 0x0D,
1770 0x73, 0x4C, 0xEE, 0x98, 0xCB, 0x7C, 0x58, 0x7E,
1771 0x20, 0x75, 0x1E, 0xB7, 0xC9, 0xF8, 0xF2, 0x0E,
1772 0x63, 0x9E, 0x05, 0x78, 0x1A, 0xB6, 0xA8, 0x7A,
1773 0xF9, 0x98, 0x6A, 0xA6, 0x46, 0x84, 0x2E, 0xF6,
1774 0x4B, 0xDC, 0x9B, 0x8F, 0x9B, 0x8F, 0xEE, 0xB4,
1775 0xAA, 0x3F, 0xEE, 0xC0, 0x37, 0x27, 0x76, 0xC7,
1776 0x95, 0xBB, 0x26, 0x74, 0x69, 0x12, 0x7F, 0xF1,
1777 0xBB, 0xFF, 0xAE, 0xB5, 0x99, 0x6E, 0xCB, 0x0C
1780 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest[] = {
1781 0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60,
1782 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1783 0x18, 0x8c, 0x1d, 0x32
1787 /* Multisession Vector context Test */
1788 /*Begin Session 0 */
1789 static uint8_t ms_aes_cbc_key0[] = {
1790 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1791 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1794 static uint8_t ms_aes_cbc_iv0[] = {
1795 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1796 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1799 static const uint8_t ms_aes_cbc_cipher0[] = {
1800 0x3C, 0xE4, 0xEE, 0x42, 0xB6, 0x9B, 0xC3, 0x38,
1801 0x5F, 0xAD, 0x54, 0xDC, 0xA8, 0x32, 0x81, 0xDC,
1802 0x7A, 0x6F, 0x85, 0x58, 0x07, 0x35, 0xED, 0xEB,
1803 0xAD, 0x79, 0x79, 0x96, 0xD3, 0x0E, 0xA6, 0xD9,
1804 0xAA, 0x86, 0xA4, 0x8F, 0xB5, 0xD6, 0x6E, 0x6D,
1805 0x0C, 0x91, 0x2F, 0xC4, 0x67, 0x98, 0x0E, 0xC4,
1806 0x8D, 0x83, 0x68, 0x69, 0xC4, 0xD3, 0x94, 0x34,
1807 0xC4, 0x5D, 0x60, 0x55, 0x22, 0x87, 0x8F, 0x6F,
1808 0x17, 0x8E, 0x75, 0xE4, 0x02, 0xF5, 0x1B, 0x99,
1809 0xC8, 0x39, 0xA9, 0xAB, 0x23, 0x91, 0x12, 0xED,
1810 0x08, 0xE7, 0xD9, 0x25, 0x89, 0x24, 0x4F, 0x8D,
1811 0x68, 0xF3, 0x10, 0x39, 0x0A, 0xEE, 0x45, 0x24,
1812 0xDF, 0x7A, 0x9D, 0x00, 0x25, 0xE5, 0x35, 0x71,
1813 0x4E, 0x40, 0x59, 0x6F, 0x0A, 0x13, 0xB3, 0x72,
1814 0x1D, 0x98, 0x63, 0x94, 0x89, 0xA5, 0x39, 0x8E,
1815 0xD3, 0x9C, 0x8A, 0x7F, 0x71, 0x2F, 0xC7, 0xCD,
1816 0x81, 0x05, 0xDC, 0xC0, 0x8D, 0xCE, 0x6D, 0x18,
1817 0x30, 0xC4, 0x72, 0x51, 0xF0, 0x27, 0xC8, 0xF6,
1818 0x60, 0x5B, 0x7C, 0xB2, 0xE3, 0x49, 0x0C, 0x29,
1819 0xC6, 0x9F, 0x39, 0x57, 0x80, 0x55, 0x24, 0x2C,
1820 0x9B, 0x0F, 0x5A, 0xB3, 0x89, 0x55, 0x31, 0x96,
1821 0x0D, 0xCD, 0xF6, 0x51, 0x03, 0x2D, 0x89, 0x26,
1822 0x74, 0x44, 0xD6, 0xE8, 0xDC, 0xEA, 0x44, 0x55,
1823 0x64, 0x71, 0x9C, 0x9F, 0x5D, 0xBA, 0x39, 0x46,
1824 0xA8, 0x17, 0xA1, 0x9C, 0x52, 0x9D, 0xBC, 0x6B,
1825 0x4A, 0x98, 0xE6, 0xEA, 0x33, 0xEC, 0x58, 0xB4,
1826 0x43, 0xF0, 0x32, 0x45, 0xA4, 0xC1, 0x55, 0xB7,
1827 0x5D, 0xB5, 0x59, 0xB2, 0xE3, 0x96, 0xFF, 0xA5,
1828 0xAF, 0xE1, 0x86, 0x1B, 0x42, 0xE6, 0x3B, 0xA0,
1829 0x90, 0x4A, 0xE8, 0x8C, 0x21, 0x7F, 0x36, 0x1E,
1830 0x5B, 0x65, 0x25, 0xD1, 0xC1, 0x5A, 0xCA, 0x3D,
1831 0x10, 0xED, 0x2D, 0x79, 0xD0, 0x0F, 0x58, 0x44,
1832 0x69, 0x81, 0xF5, 0xD4, 0xC9, 0x0F, 0x90, 0x76,
1833 0x1F, 0x54, 0xD2, 0xD5, 0x97, 0xCE, 0x2C, 0xE3,
1834 0xEF, 0xF4, 0xB7, 0xC6, 0x3A, 0x87, 0x7F, 0x83,
1835 0x2A, 0xAF, 0xCD, 0x90, 0x12, 0xA7, 0x7D, 0x85,
1836 0x1D, 0x62, 0xD3, 0x85, 0x25, 0x05, 0xDB, 0x45,
1837 0x92, 0xA3, 0xF6, 0xA2, 0xA8, 0x41, 0xE4, 0x25,
1838 0x86, 0x87, 0x67, 0x24, 0xEC, 0x89, 0x23, 0x2A,
1839 0x9B, 0x20, 0x4D, 0x93, 0xEE, 0xE2, 0x2E, 0xC1,
1840 0x0B, 0x15, 0x33, 0xCF, 0x00, 0xD1, 0x1A, 0xDA,
1841 0x93, 0xFD, 0x28, 0x21, 0x5B, 0xCF, 0xD1, 0xF3,
1842 0x5A, 0x81, 0xBA, 0x82, 0x5E, 0x2F, 0x61, 0xB4,
1843 0x05, 0x71, 0xB5, 0xF4, 0x39, 0x3C, 0x1F, 0x60,
1844 0x00, 0x7A, 0xC4, 0xF8, 0x35, 0x20, 0x6C, 0x3A,
1845 0xCC, 0x03, 0x8F, 0x7B, 0xA2, 0xB6, 0x65, 0x8A,
1846 0xB6, 0x5F, 0xFD, 0x25, 0xD3, 0x5F, 0x92, 0xF9,
1847 0xAE, 0x17, 0x9B, 0x5E, 0x6E, 0x9A, 0xE4, 0x55,
1848 0x10, 0x25, 0x07, 0xA4, 0xAF, 0x21, 0x69, 0x13,
1849 0xD8, 0xFA, 0x31, 0xED, 0xF7, 0xA7, 0xA7, 0x3B,
1850 0xB8, 0x96, 0x8E, 0x10, 0x86, 0x74, 0xD8, 0xB1,
1851 0x34, 0x9E, 0x9B, 0x6A, 0x26, 0xA8, 0xD4, 0xD0,
1852 0xB5, 0xF6, 0xDE, 0xE7, 0xCA, 0x06, 0xDC, 0xA3,
1853 0x6F, 0xEE, 0x6B, 0x1E, 0xB5, 0x30, 0x99, 0x23,
1854 0xF9, 0x76, 0xF0, 0xA0, 0xCF, 0x3B, 0x94, 0x7B,
1855 0x19, 0x8D, 0xA5, 0x0C, 0x18, 0xA6, 0x1D, 0x07,
1856 0x89, 0xBE, 0x5B, 0x61, 0xE5, 0xF1, 0x42, 0xDB,
1857 0xD4, 0x2E, 0x02, 0x1F, 0xCE, 0xEF, 0x92, 0xB1,
1858 0x1B, 0x56, 0x50, 0xF2, 0x16, 0xE5, 0xE7, 0x4F,
1859 0xFD, 0xBB, 0x3E, 0xD2, 0xFC, 0x3C, 0xC6, 0x0F,
1860 0xF9, 0x12, 0x4E, 0xCB, 0x1E, 0x0C, 0x15, 0x84,
1861 0x2A, 0x14, 0x8A, 0x02, 0xE4, 0x7E, 0x95, 0x5B,
1862 0x86, 0xDB, 0x9B, 0x62, 0x5B, 0x19, 0xD2, 0x17,
1863 0xFA, 0x13, 0xBB, 0x6B, 0x3F, 0x45, 0x9F, 0xBF
1867 static uint8_t ms_hmac_key0[] = {
1868 0xFF, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1869 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1870 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1871 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1872 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1873 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1874 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1875 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1878 static const uint8_t ms_hmac_digest0[] = {
1879 0x43, 0x52, 0xED, 0x34, 0xAB, 0x36, 0xB2, 0x51,
1880 0xFB, 0xA3, 0xA6, 0x7C, 0x38, 0xFC, 0x42, 0x8F,
1881 0x57, 0x64, 0xAB, 0x81, 0xA7, 0x89, 0xB7, 0x6C,
1882 0xA0, 0xDC, 0xB9, 0x4D, 0xC4, 0x30, 0xF9, 0xD4,
1883 0x10, 0x82, 0x55, 0xD0, 0xAB, 0x32, 0xFB, 0x56,
1884 0x0D, 0xE4, 0x68, 0x3D, 0x76, 0xD0, 0x7B, 0xE4,
1885 0xA6, 0x2C, 0x34, 0x9E, 0x8C, 0x41, 0xF8, 0x23,
1886 0x28, 0x1B, 0x3A, 0x90, 0x26, 0x34, 0x47, 0x90
1890 /* Begin session 1 */
1892 static uint8_t ms_aes_cbc_key1[] = {
1893 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1894 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1897 static uint8_t ms_aes_cbc_iv1[] = {
1898 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1899 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1902 static const uint8_t ms_aes_cbc_cipher1[] = {
1903 0x5A, 0x7A, 0x67, 0x5D, 0xB8, 0xE1, 0xDC, 0x71,
1904 0x39, 0xA8, 0x74, 0x93, 0x9C, 0x4C, 0xFE, 0x23,
1905 0x61, 0xCD, 0xA4, 0xB3, 0xD9, 0xCE, 0x99, 0x09,
1906 0x2A, 0x23, 0xF3, 0x29, 0xBF, 0x4C, 0xB4, 0x6A,
1907 0x1B, 0x6B, 0x73, 0x4D, 0x48, 0x0C, 0xCF, 0x6C,
1908 0x5E, 0x34, 0x9E, 0x7F, 0xBC, 0x8F, 0xCC, 0x8F,
1909 0x75, 0x1D, 0x3D, 0x77, 0x10, 0x76, 0xC8, 0xB9,
1910 0x99, 0x6F, 0xD6, 0x56, 0x75, 0xA9, 0xB2, 0x66,
1911 0xC2, 0x24, 0x2B, 0x9C, 0xFE, 0x40, 0x8E, 0x43,
1912 0x20, 0x97, 0x1B, 0xFA, 0xD0, 0xCF, 0x04, 0xAB,
1913 0xBB, 0xF6, 0x5D, 0xF5, 0xA0, 0x19, 0x7C, 0x23,
1914 0x5D, 0x80, 0x8C, 0x49, 0xF6, 0x76, 0x88, 0x29,
1915 0x27, 0x4C, 0x59, 0x2B, 0x43, 0xA6, 0xB2, 0x26,
1916 0x27, 0x78, 0xBE, 0x1B, 0xE1, 0x4F, 0x5A, 0x1F,
1917 0xFC, 0x68, 0x08, 0xE7, 0xC4, 0xD1, 0x34, 0x68,
1918 0xB7, 0x13, 0x14, 0x41, 0x62, 0x6B, 0x1F, 0x77,
1919 0x0C, 0x68, 0x1D, 0x0D, 0xED, 0x89, 0xAA, 0xD8,
1920 0x97, 0x02, 0xBA, 0x5E, 0xD4, 0x84, 0x25, 0x97,
1921 0x03, 0xA5, 0xA6, 0x13, 0x66, 0x02, 0xF4, 0xC3,
1922 0xF3, 0xD3, 0xCC, 0x95, 0xC3, 0x87, 0x46, 0x90,
1923 0x1F, 0x6E, 0x14, 0xA8, 0x00, 0xF2, 0x6F, 0xD5,
1924 0xA1, 0xAD, 0xD5, 0x40, 0xA2, 0x0F, 0x32, 0x7E,
1925 0x99, 0xA3, 0xF5, 0x53, 0xC3, 0x26, 0xA1, 0x45,
1926 0x01, 0x88, 0x57, 0x84, 0x3E, 0x7B, 0x4E, 0x0B,
1927 0x3C, 0xB5, 0x3E, 0x9E, 0xE9, 0x78, 0x77, 0xC5,
1928 0xC0, 0x89, 0xA8, 0xF8, 0xF1, 0xA5, 0x2D, 0x5D,
1929 0xF9, 0xC6, 0xFB, 0xCB, 0x05, 0x23, 0xBD, 0x6E,
1930 0x5E, 0x14, 0xC6, 0x57, 0x73, 0xCF, 0x98, 0xBD,
1931 0x10, 0x8B, 0x18, 0xA6, 0x01, 0x5B, 0x13, 0xAE,
1932 0x8E, 0xDE, 0x1F, 0xB5, 0xB7, 0x40, 0x6C, 0xC1,
1933 0x1E, 0xA1, 0x19, 0x20, 0x9E, 0x95, 0xE0, 0x2F,
1934 0x1C, 0xF5, 0xD9, 0xD0, 0x2B, 0x1E, 0x82, 0x25,
1935 0x62, 0xB4, 0xEB, 0xA1, 0x1F, 0xCE, 0x44, 0xA1,
1936 0xCB, 0x92, 0x01, 0x6B, 0xE4, 0x26, 0x23, 0xE3,
1937 0xC5, 0x67, 0x35, 0x55, 0xDA, 0xE5, 0x27, 0xEE,
1938 0x8D, 0x12, 0x84, 0xB7, 0xBA, 0xA7, 0x1C, 0xD6,
1939 0x32, 0x3F, 0x67, 0xED, 0xFB, 0x5B, 0x8B, 0x52,
1940 0x46, 0x8C, 0xF9, 0x69, 0xCD, 0xAE, 0x79, 0xAA,
1941 0x37, 0x78, 0x49, 0xEB, 0xC6, 0x8E, 0x76, 0x63,
1942 0x84, 0xFF, 0x9D, 0x22, 0x99, 0x51, 0xB7, 0x5E,
1943 0x83, 0x4C, 0x8B, 0xDF, 0x5A, 0x07, 0xCC, 0xBA,
1944 0x42, 0xA5, 0x98, 0xB6, 0x47, 0x0E, 0x66, 0xEB,
1945 0x23, 0x0E, 0xBA, 0x44, 0xA8, 0xAA, 0x20, 0x71,
1946 0x79, 0x9C, 0x77, 0x5F, 0xF5, 0xFE, 0xEC, 0xEF,
1947 0xC6, 0x64, 0x3D, 0x84, 0xD0, 0x2B, 0xA7, 0x0A,
1948 0xC3, 0x72, 0x5B, 0x9C, 0xFA, 0xA8, 0x87, 0x95,
1949 0x94, 0x11, 0x38, 0xA7, 0x1E, 0x58, 0xE3, 0x73,
1950 0xC6, 0xC9, 0xD1, 0x7B, 0x92, 0xDB, 0x0F, 0x49,
1951 0x74, 0xC2, 0xA2, 0x0E, 0x35, 0x57, 0xAC, 0xDB,
1952 0x9A, 0x1C, 0xCF, 0x5A, 0x32, 0x3E, 0x26, 0x9B,
1953 0xEC, 0xB3, 0xEF, 0x9C, 0xFE, 0xBE, 0x52, 0xAC,
1954 0xB1, 0x29, 0xDD, 0xFD, 0x07, 0xE2, 0xEE, 0xED,
1955 0xE4, 0x46, 0x37, 0xFE, 0xD1, 0xDC, 0xCD, 0x02,
1956 0xF9, 0x31, 0xB0, 0xFB, 0x36, 0xB7, 0x34, 0xA4,
1957 0x76, 0xE8, 0x57, 0xBF, 0x99, 0x92, 0xC7, 0xAF,
1958 0x98, 0x10, 0xE2, 0x70, 0xCA, 0xC9, 0x2B, 0x82,
1959 0x06, 0x96, 0x88, 0x0D, 0xB3, 0xAC, 0x9E, 0x6D,
1960 0x43, 0xBC, 0x5B, 0x31, 0xCF, 0x65, 0x8D, 0xA6,
1961 0xC7, 0xFE, 0x73, 0xE1, 0x54, 0xF7, 0x10, 0xF9,
1962 0x86, 0xF7, 0xDF, 0xA1, 0xA1, 0xD8, 0xAE, 0x35,
1963 0xB3, 0x90, 0xDC, 0x6F, 0x43, 0x7A, 0x8B, 0xE0,
1964 0xFE, 0x8F, 0x33, 0x4D, 0x29, 0x6C, 0x45, 0x53,
1965 0x73, 0xDD, 0x21, 0x0B, 0x85, 0x30, 0xB5, 0xA5,
1966 0xF3, 0x5D, 0xEC, 0x79, 0x61, 0x9D, 0x9E, 0xB3
1970 static uint8_t ms_hmac_key1[] = {
1971 0xFE, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1972 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1973 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1974 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1975 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1976 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1977 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1978 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1981 static const uint8_t ms_hmac_digest1[] = {
1982 0xCE, 0x6E, 0x5F, 0x77, 0x96, 0x9A, 0xB1, 0x69,
1983 0x2D, 0x5E, 0xF3, 0x2F, 0x32, 0x10, 0xCB, 0x50,
1984 0x0E, 0x09, 0x56, 0x25, 0x07, 0x34, 0xC9, 0x20,
1985 0xEC, 0x13, 0x43, 0x23, 0x5C, 0x08, 0x8B, 0xCD,
1986 0xDC, 0x86, 0x8C, 0xEE, 0x0A, 0x95, 0x2E, 0xB9,
1987 0x8C, 0x7B, 0x02, 0x7A, 0xD4, 0xE1, 0x49, 0xB4,
1988 0x45, 0xB5, 0x52, 0x37, 0xC6, 0xFF, 0xFE, 0xAA,
1989 0x0A, 0x87, 0xB8, 0x51, 0xF9, 0x2A, 0x01, 0x8F
1992 /* Begin Session 2 */
1993 static uint8_t ms_aes_cbc_key2[] = {
1994 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1995 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1998 static uint8_t ms_aes_cbc_iv2[] = {
1999 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
2000 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
2003 static const uint8_t ms_aes_cbc_cipher2[] = {
2004 0xBB, 0x3C, 0x68, 0x25, 0xFD, 0xB6, 0xA2, 0x91,
2005 0x20, 0x56, 0xF6, 0x30, 0x35, 0xFC, 0x9E, 0x97,
2006 0xF2, 0x90, 0xFC, 0x7E, 0x3E, 0x0A, 0x75, 0xC8,
2007 0x4C, 0xF2, 0x2D, 0xAC, 0xD3, 0x93, 0xF0, 0xC5,
2008 0x14, 0x88, 0x8A, 0x23, 0xC2, 0x59, 0x9A, 0x98,
2009 0x4B, 0xD5, 0x2C, 0xDA, 0x43, 0xA9, 0x34, 0x69,
2010 0x7C, 0x6D, 0xDB, 0xDC, 0xCB, 0xC0, 0xA0, 0x09,
2011 0xA7, 0x86, 0x16, 0x4B, 0xBF, 0xA8, 0xB6, 0xCF,
2012 0x7F, 0x74, 0x1F, 0x22, 0xF0, 0xF6, 0xBB, 0x44,
2013 0x8B, 0x4C, 0x9E, 0x23, 0xF8, 0x9F, 0xFC, 0x5B,
2014 0x9E, 0x9C, 0x2A, 0x79, 0x30, 0x8F, 0xBF, 0xA9,
2015 0x68, 0xA1, 0x20, 0x71, 0x7C, 0x77, 0x22, 0x34,
2016 0x07, 0xCD, 0xC6, 0xF6, 0x50, 0x0A, 0x08, 0x99,
2017 0x17, 0x98, 0xE3, 0x93, 0x8A, 0xB0, 0xEE, 0xDF,
2018 0xC2, 0xBA, 0x3B, 0x44, 0x73, 0xDF, 0xDD, 0xDC,
2019 0x14, 0x4D, 0x3B, 0xBB, 0x5E, 0x58, 0xC1, 0x26,
2020 0xA7, 0xAE, 0x47, 0xF3, 0x24, 0x6D, 0x4F, 0xD3,
2021 0x6E, 0x3E, 0x33, 0xE6, 0x7F, 0xCA, 0x50, 0xAF,
2022 0x5D, 0x3D, 0xA0, 0xDD, 0xC9, 0xF3, 0x30, 0xD3,
2023 0x6E, 0x8B, 0x2E, 0x12, 0x24, 0x34, 0xF0, 0xD3,
2024 0xC7, 0x8D, 0x23, 0x29, 0xAA, 0x05, 0xE1, 0xFA,
2025 0x2E, 0xF6, 0x8D, 0x37, 0x86, 0xC0, 0x6D, 0x13,
2026 0x2D, 0x98, 0xF3, 0x52, 0x39, 0x22, 0xCE, 0x38,
2027 0xC2, 0x1A, 0x72, 0xED, 0xFB, 0xCC, 0xE4, 0x71,
2028 0x5A, 0x0C, 0x0D, 0x09, 0xF8, 0xE8, 0x1B, 0xBC,
2029 0x53, 0xC8, 0xD8, 0x8F, 0xE5, 0x98, 0x5A, 0xB1,
2030 0x06, 0xA6, 0x5B, 0xE6, 0xA2, 0x88, 0x21, 0x9E,
2031 0x36, 0xC0, 0x34, 0xF9, 0xFB, 0x3B, 0x0A, 0x22,
2032 0x00, 0x00, 0x39, 0x48, 0x8D, 0x23, 0x74, 0x62,
2033 0x72, 0x91, 0xE6, 0x36, 0xAA, 0x77, 0x9C, 0x72,
2034 0x9D, 0xA8, 0xC3, 0xA9, 0xD5, 0x44, 0x72, 0xA6,
2035 0xB9, 0x28, 0x8F, 0x64, 0x4C, 0x8A, 0x64, 0xE6,
2036 0x4E, 0xFA, 0xEF, 0x87, 0xDE, 0x7B, 0x22, 0x44,
2037 0xB0, 0xDF, 0x2E, 0x5F, 0x0B, 0xA5, 0xF2, 0x24,
2038 0x07, 0x5C, 0x2D, 0x39, 0xB7, 0x3D, 0x8A, 0xE5,
2039 0x0E, 0x9D, 0x4E, 0x50, 0xED, 0x03, 0x99, 0x8E,
2040 0xF0, 0x06, 0x55, 0x4E, 0xA2, 0x24, 0xE7, 0x17,
2041 0x46, 0xDF, 0x6C, 0xCD, 0xC6, 0x44, 0xE8, 0xF9,
2042 0xB9, 0x1B, 0x36, 0xF6, 0x7F, 0x10, 0xA4, 0x7D,
2043 0x90, 0xBD, 0xE4, 0xAA, 0xD6, 0x9E, 0x18, 0x9D,
2044 0x22, 0x35, 0xD6, 0x55, 0x54, 0xAA, 0xF7, 0x22,
2045 0xA3, 0x3E, 0xEF, 0xC8, 0xA2, 0x34, 0x8D, 0xA9,
2046 0x37, 0x63, 0xA6, 0xC3, 0x57, 0xCB, 0x0C, 0x49,
2047 0x7D, 0x02, 0xBE, 0xAA, 0x13, 0x75, 0xB7, 0x4E,
2048 0x52, 0x62, 0xA5, 0xC2, 0x33, 0xC7, 0x6C, 0x1B,
2049 0xF6, 0x34, 0xF6, 0x09, 0xA5, 0x0C, 0xC7, 0xA2,
2050 0x61, 0x48, 0x62, 0x7D, 0x17, 0x15, 0xE3, 0x95,
2051 0xC8, 0x63, 0xD2, 0xA4, 0x43, 0xA9, 0x49, 0x07,
2052 0xB2, 0x3B, 0x2B, 0x62, 0x7D, 0xCB, 0x51, 0xB3,
2053 0x25, 0x33, 0x47, 0x0E, 0x14, 0x67, 0xDC, 0x6A,
2054 0x9B, 0x51, 0xAC, 0x9D, 0x8F, 0xA2, 0x2B, 0x57,
2055 0x8C, 0x5C, 0x5F, 0x76, 0x23, 0x92, 0x0F, 0x84,
2056 0x46, 0x0E, 0x40, 0x85, 0x38, 0x60, 0xFA, 0x61,
2057 0x20, 0xC5, 0xE3, 0xF1, 0x70, 0xAC, 0x1B, 0xBF,
2058 0xC4, 0x2B, 0xC5, 0x67, 0xD1, 0x43, 0xC5, 0x17,
2059 0x74, 0x71, 0x69, 0x6F, 0x82, 0x89, 0x19, 0x8A,
2060 0x70, 0x43, 0x92, 0x01, 0xC4, 0x63, 0x7E, 0xB1,
2061 0x59, 0x4E, 0xCD, 0xEA, 0x93, 0xA4, 0x52, 0x53,
2062 0x9B, 0x61, 0x5B, 0xD2, 0x3E, 0x19, 0x39, 0xB7,
2063 0x32, 0xEA, 0x8E, 0xF8, 0x1D, 0x76, 0x5C, 0xB2,
2064 0x73, 0x2D, 0x91, 0xC0, 0x18, 0xED, 0x25, 0x2A,
2065 0x53, 0x64, 0xF0, 0x92, 0x31, 0x55, 0x21, 0xA8,
2066 0x24, 0xA9, 0xD1, 0x02, 0xF6, 0x6C, 0x2B, 0x70,
2067 0xA9, 0x59, 0xC1, 0xD6, 0xC3, 0x57, 0x5B, 0x92
2070 static uint8_t ms_hmac_key2[] = {
2071 0xFC, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
2072 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
2073 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
2074 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
2075 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
2076 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
2077 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
2078 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
2081 static const uint8_t ms_hmac_digest2[] = {
2082 0xA5, 0x0F, 0x9C, 0xFB, 0x08, 0x62, 0x59, 0xFF,
2083 0x80, 0x2F, 0xEB, 0x4B, 0xE1, 0x46, 0x21, 0xD6,
2084 0x02, 0x98, 0xF2, 0x8E, 0xF4, 0xEC, 0xD4, 0x77,
2085 0x86, 0x4C, 0x31, 0x28, 0xC8, 0x25, 0x80, 0x27,
2086 0x3A, 0x72, 0x5D, 0x6A, 0x56, 0x8A, 0xD3, 0x82,
2087 0xB0, 0xEC, 0x31, 0x6D, 0x8B, 0x6B, 0xB4, 0x24,
2088 0xE7, 0x62, 0xC1, 0x52, 0xBC, 0x14, 0x1B, 0x8E,
2089 0xEC, 0x9A, 0xF1, 0x47, 0x80, 0xD2, 0xB0, 0x59
2096 test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
2098 struct crypto_testsuite_params *ts_params = &testsuite_params;
2099 struct crypto_unittest_params *ut_params = &unittest_params;
2101 /* Verify the capabilities */
2102 struct rte_cryptodev_sym_capability_idx cap_idx;
2103 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2104 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
2105 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2107 return TEST_SKIPPED;
2108 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2109 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
2110 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2112 return TEST_SKIPPED;
2114 /* Generate test mbuf data and space for digest */
2115 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
2116 catch_22_quote, QUOTE_512_BYTES, 0);
2118 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2119 DIGEST_BYTE_LENGTH_SHA1);
2120 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
2122 /* Setup Cipher Parameters */
2123 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2124 ut_params->cipher_xform.next = &ut_params->auth_xform;
2126 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
2127 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2128 ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
2129 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
2130 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2131 ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
2133 /* Setup HMAC Parameters */
2134 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2136 ut_params->auth_xform.next = NULL;
2138 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2139 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
2140 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1;
2141 ut_params->auth_xform.auth.key.data = hmac_sha1_key;
2142 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
2144 ut_params->sess = rte_cryptodev_sym_session_create(
2145 ts_params->session_mpool);
2147 /* Create crypto session*/
2148 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
2149 ut_params->sess, &ut_params->cipher_xform,
2150 ts_params->session_priv_mpool);
2151 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2153 /* Generate crypto op data structure */
2154 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2155 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2156 TEST_ASSERT_NOT_NULL(ut_params->op,
2157 "Failed to allocate symmetric crypto operation struct");
2159 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2161 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2163 /* set crypto operation source mbuf */
2164 sym_op->m_src = ut_params->ibuf;
2166 /* Set crypto operation authentication parameters */
2167 sym_op->auth.digest.data = ut_params->digest;
2168 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2169 ut_params->ibuf, QUOTE_512_BYTES);
2171 sym_op->auth.data.offset = 0;
2172 sym_op->auth.data.length = QUOTE_512_BYTES;
2174 /* Copy IV at the end of the crypto operation */
2175 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2176 aes_cbc_iv, CIPHER_IV_LENGTH_AES_CBC);
2178 /* Set crypto operation cipher parameters */
2179 sym_op->cipher.data.offset = 0;
2180 sym_op->cipher.data.length = QUOTE_512_BYTES;
2182 /* Process crypto operation */
2183 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2184 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
2187 TEST_ASSERT_NOT_NULL(
2188 process_crypto_request(ts_params->valid_devs[0],
2190 "failed to process sym crypto op");
2192 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2193 "crypto op processing failed");
2196 uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
2199 TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext,
2200 catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
2202 "ciphertext data not as expected");
2204 uint8_t *digest = ciphertext + QUOTE_512_BYTES;
2206 TEST_ASSERT_BUFFERS_ARE_EQUAL(digest,
2207 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
2208 gbl_driver_id == rte_cryptodev_driver_id_get(
2209 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) ?
2210 TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
2211 DIGEST_BYTE_LENGTH_SHA1,
2212 "Generated digest data not as expected");
2214 return TEST_SUCCESS;
2217 /* ***** AES-CBC / HMAC-SHA512 Hash Tests ***** */
2219 #define HMAC_KEY_LENGTH_SHA512 (DIGEST_BYTE_LENGTH_SHA512)
2221 static uint8_t hmac_sha512_key[] = {
2222 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
2223 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
2224 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
2225 0x9a, 0xaf, 0x88, 0x1b, 0xb6, 0x8f, 0xf8, 0x60,
2226 0xa2, 0x5a, 0x7f, 0x3f, 0xf4, 0x72, 0x70, 0xf1,
2227 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
2228 0x47, 0x3a, 0x75, 0x61, 0x5C, 0xa2, 0x10, 0x76,
2229 0x9a, 0xaf, 0x77, 0x5b, 0xb6, 0x7f, 0xf7, 0x60 };
2231 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest[] = {
2232 0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8,
2233 0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48,
2234 0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8,
2235 0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70,
2236 0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8,
2237 0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E,
2238 0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D,
2239 0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A };
2244 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
2245 struct crypto_unittest_params *ut_params,
2246 uint8_t *cipher_key,
2250 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
2251 struct crypto_unittest_params *ut_params,
2252 struct crypto_testsuite_params *ts_params,
2253 const uint8_t *cipher,
2254 const uint8_t *digest,
2259 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
2260 struct crypto_unittest_params *ut_params,
2261 uint8_t *cipher_key,
2265 /* Setup Cipher Parameters */
2266 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2267 ut_params->cipher_xform.next = NULL;
2269 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
2270 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
2271 ut_params->cipher_xform.cipher.key.data = cipher_key;
2272 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
2273 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2274 ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
2276 /* Setup HMAC Parameters */
2277 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2278 ut_params->auth_xform.next = &ut_params->cipher_xform;
2280 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
2281 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC;
2282 ut_params->auth_xform.auth.key.data = hmac_key;
2283 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512;
2284 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512;
2286 return TEST_SUCCESS;
2291 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
2292 struct crypto_unittest_params *ut_params,
2293 struct crypto_testsuite_params *ts_params,
2294 const uint8_t *cipher,
2295 const uint8_t *digest,
2298 /* Generate test mbuf data and digest */
2299 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
2302 QUOTE_512_BYTES, 0);
2304 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2305 DIGEST_BYTE_LENGTH_SHA512);
2306 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
2308 rte_memcpy(ut_params->digest,
2310 DIGEST_BYTE_LENGTH_SHA512);
2312 /* Generate Crypto op data structure */
2313 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2314 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2315 TEST_ASSERT_NOT_NULL(ut_params->op,
2316 "Failed to allocate symmetric crypto operation struct");
2318 rte_crypto_op_attach_sym_session(ut_params->op, sess);
2320 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2322 /* set crypto operation source mbuf */
2323 sym_op->m_src = ut_params->ibuf;
2325 sym_op->auth.digest.data = ut_params->digest;
2326 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2327 ut_params->ibuf, QUOTE_512_BYTES);
2329 sym_op->auth.data.offset = 0;
2330 sym_op->auth.data.length = QUOTE_512_BYTES;
2332 /* Copy IV at the end of the crypto operation */
2333 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2334 iv, CIPHER_IV_LENGTH_AES_CBC);
2336 sym_op->cipher.data.offset = 0;
2337 sym_op->cipher.data.length = QUOTE_512_BYTES;
2339 /* Process crypto operation */
2340 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2341 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
2343 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
2344 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
2345 ut_params->op, 1, 1, 0, 0);
2347 TEST_ASSERT_NOT_NULL(
2348 process_crypto_request(ts_params->valid_devs[0],
2350 "failed to process sym crypto op");
2352 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2353 "crypto op processing failed");
2355 ut_params->obuf = ut_params->op->sym->m_src;
2358 TEST_ASSERT_BUFFERS_ARE_EQUAL(
2359 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *),
2362 "Plaintext data not as expected");
2365 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2366 "Digest verification failed");
2368 return TEST_SUCCESS;
2371 /* ***** SNOW 3G Tests ***** */
2373 create_wireless_algo_hash_session(uint8_t dev_id,
2374 const uint8_t *key, const uint8_t key_len,
2375 const uint8_t iv_len, const uint8_t auth_len,
2376 enum rte_crypto_auth_operation op,
2377 enum rte_crypto_auth_algorithm algo)
2379 uint8_t hash_key[key_len];
2382 struct crypto_testsuite_params *ts_params = &testsuite_params;
2383 struct crypto_unittest_params *ut_params = &unittest_params;
2385 memcpy(hash_key, key, key_len);
2387 debug_hexdump(stdout, "key:", key, key_len);
2389 /* Setup Authentication Parameters */
2390 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2391 ut_params->auth_xform.next = NULL;
2393 ut_params->auth_xform.auth.op = op;
2394 ut_params->auth_xform.auth.algo = algo;
2395 ut_params->auth_xform.auth.key.length = key_len;
2396 ut_params->auth_xform.auth.key.data = hash_key;
2397 ut_params->auth_xform.auth.digest_length = auth_len;
2398 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
2399 ut_params->auth_xform.auth.iv.length = iv_len;
2400 ut_params->sess = rte_cryptodev_sym_session_create(
2401 ts_params->session_mpool);
2403 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2404 &ut_params->auth_xform,
2405 ts_params->session_priv_mpool);
2406 TEST_ASSERT_EQUAL(status, 0, "session init failed");
2407 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2412 create_wireless_algo_cipher_session(uint8_t dev_id,
2413 enum rte_crypto_cipher_operation op,
2414 enum rte_crypto_cipher_algorithm algo,
2415 const uint8_t *key, const uint8_t key_len,
2418 uint8_t cipher_key[key_len];
2420 struct crypto_testsuite_params *ts_params = &testsuite_params;
2421 struct crypto_unittest_params *ut_params = &unittest_params;
2423 memcpy(cipher_key, key, key_len);
2425 /* Setup Cipher Parameters */
2426 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2427 ut_params->cipher_xform.next = NULL;
2429 ut_params->cipher_xform.cipher.algo = algo;
2430 ut_params->cipher_xform.cipher.op = op;
2431 ut_params->cipher_xform.cipher.key.data = cipher_key;
2432 ut_params->cipher_xform.cipher.key.length = key_len;
2433 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2434 ut_params->cipher_xform.cipher.iv.length = iv_len;
2436 debug_hexdump(stdout, "key:", key, key_len);
2438 /* Create Crypto session */
2439 ut_params->sess = rte_cryptodev_sym_session_create(
2440 ts_params->session_mpool);
2442 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2443 &ut_params->cipher_xform,
2444 ts_params->session_priv_mpool);
2445 TEST_ASSERT_EQUAL(status, 0, "session init failed");
2446 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2451 create_wireless_algo_cipher_operation(const uint8_t *iv, uint8_t iv_len,
2452 unsigned int cipher_len,
2453 unsigned int cipher_offset)
2455 struct crypto_testsuite_params *ts_params = &testsuite_params;
2456 struct crypto_unittest_params *ut_params = &unittest_params;
2458 /* Generate Crypto op data structure */
2459 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2460 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2461 TEST_ASSERT_NOT_NULL(ut_params->op,
2462 "Failed to allocate pktmbuf offload");
2464 /* Set crypto operation data parameters */
2465 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2467 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2469 /* set crypto operation source mbuf */
2470 sym_op->m_src = ut_params->ibuf;
2473 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2475 sym_op->cipher.data.length = cipher_len;
2476 sym_op->cipher.data.offset = cipher_offset;
2481 create_wireless_algo_cipher_operation_oop(const uint8_t *iv, uint8_t iv_len,
2482 unsigned int cipher_len,
2483 unsigned int cipher_offset)
2485 struct crypto_testsuite_params *ts_params = &testsuite_params;
2486 struct crypto_unittest_params *ut_params = &unittest_params;
2488 /* Generate Crypto op data structure */
2489 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2490 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2491 TEST_ASSERT_NOT_NULL(ut_params->op,
2492 "Failed to allocate pktmbuf offload");
2494 /* Set crypto operation data parameters */
2495 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2497 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2499 /* set crypto operation source mbuf */
2500 sym_op->m_src = ut_params->ibuf;
2501 sym_op->m_dst = ut_params->obuf;
2504 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2506 sym_op->cipher.data.length = cipher_len;
2507 sym_op->cipher.data.offset = cipher_offset;
2512 create_wireless_algo_cipher_auth_session(uint8_t dev_id,
2513 enum rte_crypto_cipher_operation cipher_op,
2514 enum rte_crypto_auth_operation auth_op,
2515 enum rte_crypto_auth_algorithm auth_algo,
2516 enum rte_crypto_cipher_algorithm cipher_algo,
2517 const uint8_t *key, uint8_t key_len,
2518 uint8_t auth_iv_len, uint8_t auth_len,
2519 uint8_t cipher_iv_len)
2522 uint8_t cipher_auth_key[key_len];
2525 struct crypto_testsuite_params *ts_params = &testsuite_params;
2526 struct crypto_unittest_params *ut_params = &unittest_params;
2528 memcpy(cipher_auth_key, key, key_len);
2530 /* Setup Authentication Parameters */
2531 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2532 ut_params->auth_xform.next = NULL;
2534 ut_params->auth_xform.auth.op = auth_op;
2535 ut_params->auth_xform.auth.algo = auth_algo;
2536 ut_params->auth_xform.auth.key.length = key_len;
2537 /* Hash key = cipher key */
2538 ut_params->auth_xform.auth.key.data = cipher_auth_key;
2539 ut_params->auth_xform.auth.digest_length = auth_len;
2540 /* Auth IV will be after cipher IV */
2541 ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2542 ut_params->auth_xform.auth.iv.length = auth_iv_len;
2544 /* Setup Cipher Parameters */
2545 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2546 ut_params->cipher_xform.next = &ut_params->auth_xform;
2548 ut_params->cipher_xform.cipher.algo = cipher_algo;
2549 ut_params->cipher_xform.cipher.op = cipher_op;
2550 ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2551 ut_params->cipher_xform.cipher.key.length = key_len;
2552 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2553 ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2555 debug_hexdump(stdout, "key:", key, key_len);
2557 /* Create Crypto session*/
2558 ut_params->sess = rte_cryptodev_sym_session_create(
2559 ts_params->session_mpool);
2560 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2562 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2563 &ut_params->cipher_xform,
2564 ts_params->session_priv_mpool);
2565 if (status == -ENOTSUP)
2566 return TEST_SKIPPED;
2568 TEST_ASSERT_EQUAL(status, 0, "session init failed");
2573 create_wireless_cipher_auth_session(uint8_t dev_id,
2574 enum rte_crypto_cipher_operation cipher_op,
2575 enum rte_crypto_auth_operation auth_op,
2576 enum rte_crypto_auth_algorithm auth_algo,
2577 enum rte_crypto_cipher_algorithm cipher_algo,
2578 const struct wireless_test_data *tdata)
2580 const uint8_t key_len = tdata->key.len;
2581 uint8_t cipher_auth_key[key_len];
2584 struct crypto_testsuite_params *ts_params = &testsuite_params;
2585 struct crypto_unittest_params *ut_params = &unittest_params;
2586 const uint8_t *key = tdata->key.data;
2587 const uint8_t auth_len = tdata->digest.len;
2588 uint8_t cipher_iv_len = tdata->cipher_iv.len;
2589 uint8_t auth_iv_len = tdata->auth_iv.len;
2591 memcpy(cipher_auth_key, key, key_len);
2593 /* Setup Authentication Parameters */
2594 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2595 ut_params->auth_xform.next = NULL;
2597 ut_params->auth_xform.auth.op = auth_op;
2598 ut_params->auth_xform.auth.algo = auth_algo;
2599 ut_params->auth_xform.auth.key.length = key_len;
2600 /* Hash key = cipher key */
2601 ut_params->auth_xform.auth.key.data = cipher_auth_key;
2602 ut_params->auth_xform.auth.digest_length = auth_len;
2603 /* Auth IV will be after cipher IV */
2604 ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2605 ut_params->auth_xform.auth.iv.length = auth_iv_len;
2607 /* Setup Cipher Parameters */
2608 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2609 ut_params->cipher_xform.next = &ut_params->auth_xform;
2611 ut_params->cipher_xform.cipher.algo = cipher_algo;
2612 ut_params->cipher_xform.cipher.op = cipher_op;
2613 ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2614 ut_params->cipher_xform.cipher.key.length = key_len;
2615 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2616 ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2619 debug_hexdump(stdout, "key:", key, key_len);
2621 /* Create Crypto session*/
2622 ut_params->sess = rte_cryptodev_sym_session_create(
2623 ts_params->session_mpool);
2625 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2626 &ut_params->cipher_xform,
2627 ts_params->session_priv_mpool);
2628 if (status == -ENOTSUP)
2629 return TEST_SKIPPED;
2631 TEST_ASSERT_EQUAL(status, 0, "session init failed");
2632 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2637 create_zuc_cipher_auth_encrypt_generate_session(uint8_t dev_id,
2638 const struct wireless_test_data *tdata)
2640 return create_wireless_cipher_auth_session(dev_id,
2641 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2642 RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_ZUC_EIA3,
2643 RTE_CRYPTO_CIPHER_ZUC_EEA3, tdata);
2647 create_wireless_algo_auth_cipher_session(uint8_t dev_id,
2648 enum rte_crypto_cipher_operation cipher_op,
2649 enum rte_crypto_auth_operation auth_op,
2650 enum rte_crypto_auth_algorithm auth_algo,
2651 enum rte_crypto_cipher_algorithm cipher_algo,
2652 const uint8_t *key, const uint8_t key_len,
2653 uint8_t auth_iv_len, uint8_t auth_len,
2654 uint8_t cipher_iv_len)
2656 uint8_t auth_cipher_key[key_len];
2658 struct crypto_testsuite_params *ts_params = &testsuite_params;
2659 struct crypto_unittest_params *ut_params = &unittest_params;
2661 memcpy(auth_cipher_key, key, key_len);
2663 /* Setup Authentication Parameters */
2664 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2665 ut_params->auth_xform.auth.op = auth_op;
2666 ut_params->auth_xform.next = &ut_params->cipher_xform;
2667 ut_params->auth_xform.auth.algo = auth_algo;
2668 ut_params->auth_xform.auth.key.length = key_len;
2669 ut_params->auth_xform.auth.key.data = auth_cipher_key;
2670 ut_params->auth_xform.auth.digest_length = auth_len;
2671 /* Auth IV will be after cipher IV */
2672 ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2673 ut_params->auth_xform.auth.iv.length = auth_iv_len;
2675 /* Setup Cipher Parameters */
2676 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2677 ut_params->cipher_xform.next = NULL;
2678 ut_params->cipher_xform.cipher.algo = cipher_algo;
2679 ut_params->cipher_xform.cipher.op = cipher_op;
2680 ut_params->cipher_xform.cipher.key.data = auth_cipher_key;
2681 ut_params->cipher_xform.cipher.key.length = key_len;
2682 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2683 ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2685 debug_hexdump(stdout, "key:", key, key_len);
2687 /* Create Crypto session*/
2688 ut_params->sess = rte_cryptodev_sym_session_create(
2689 ts_params->session_mpool);
2690 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2692 if (cipher_op == RTE_CRYPTO_CIPHER_OP_DECRYPT) {
2693 ut_params->auth_xform.next = NULL;
2694 ut_params->cipher_xform.next = &ut_params->auth_xform;
2695 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2696 &ut_params->cipher_xform,
2697 ts_params->session_priv_mpool);
2700 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2701 &ut_params->auth_xform,
2702 ts_params->session_priv_mpool);
2704 if (status == -ENOTSUP)
2705 return TEST_SKIPPED;
2707 TEST_ASSERT_EQUAL(status, 0, "session init failed");
2713 create_wireless_algo_hash_operation(const uint8_t *auth_tag,
2714 unsigned int auth_tag_len,
2715 const uint8_t *iv, unsigned int iv_len,
2716 unsigned int data_pad_len,
2717 enum rte_crypto_auth_operation op,
2718 unsigned int auth_len, unsigned int auth_offset)
2720 struct crypto_testsuite_params *ts_params = &testsuite_params;
2722 struct crypto_unittest_params *ut_params = &unittest_params;
2724 /* Generate Crypto op data structure */
2725 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2726 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2727 TEST_ASSERT_NOT_NULL(ut_params->op,
2728 "Failed to allocate pktmbuf offload");
2730 /* Set crypto operation data parameters */
2731 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2733 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2735 /* set crypto operation source mbuf */
2736 sym_op->m_src = ut_params->ibuf;
2739 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2742 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2743 ut_params->ibuf, auth_tag_len);
2745 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2746 "no room to append auth tag");
2747 ut_params->digest = sym_op->auth.digest.data;
2748 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2749 ut_params->ibuf, data_pad_len);
2750 if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2751 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2753 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2755 debug_hexdump(stdout, "digest:",
2756 sym_op->auth.digest.data,
2759 sym_op->auth.data.length = auth_len;
2760 sym_op->auth.data.offset = auth_offset;
2766 create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata,
2767 enum rte_crypto_auth_operation op)
2769 struct crypto_testsuite_params *ts_params = &testsuite_params;
2770 struct crypto_unittest_params *ut_params = &unittest_params;
2772 const uint8_t *auth_tag = tdata->digest.data;
2773 const unsigned int auth_tag_len = tdata->digest.len;
2774 unsigned int plaintext_len = ceil_byte_length(tdata->plaintext.len);
2775 unsigned int data_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2777 const uint8_t *cipher_iv = tdata->cipher_iv.data;
2778 const uint8_t cipher_iv_len = tdata->cipher_iv.len;
2779 const uint8_t *auth_iv = tdata->auth_iv.data;
2780 const uint8_t auth_iv_len = tdata->auth_iv.len;
2781 const unsigned int cipher_len = tdata->validCipherLenInBits.len;
2782 const unsigned int auth_len = tdata->validAuthLenInBits.len;
2784 /* Generate Crypto op data structure */
2785 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2786 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2787 TEST_ASSERT_NOT_NULL(ut_params->op,
2788 "Failed to allocate pktmbuf offload");
2789 /* Set crypto operation data parameters */
2790 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2792 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2794 /* set crypto operation source mbuf */
2795 sym_op->m_src = ut_params->ibuf;
2798 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2799 ut_params->ibuf, auth_tag_len);
2801 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2802 "no room to append auth tag");
2803 ut_params->digest = sym_op->auth.digest.data;
2804 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2805 ut_params->ibuf, data_pad_len);
2806 if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2807 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2809 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2811 debug_hexdump(stdout, "digest:",
2812 sym_op->auth.digest.data,
2815 /* Copy cipher and auth IVs at the end of the crypto operation */
2816 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2818 rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2819 iv_ptr += cipher_iv_len;
2820 rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2822 sym_op->cipher.data.length = cipher_len;
2823 sym_op->cipher.data.offset = 0;
2824 sym_op->auth.data.length = auth_len;
2825 sym_op->auth.data.offset = 0;
2831 create_zuc_cipher_hash_generate_operation(
2832 const struct wireless_test_data *tdata)
2834 return create_wireless_cipher_hash_operation(tdata,
2835 RTE_CRYPTO_AUTH_OP_GENERATE);
2839 create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
2840 const unsigned auth_tag_len,
2841 const uint8_t *auth_iv, uint8_t auth_iv_len,
2842 unsigned data_pad_len,
2843 enum rte_crypto_auth_operation op,
2844 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2845 const unsigned cipher_len, const unsigned cipher_offset,
2846 const unsigned auth_len, const unsigned auth_offset)
2848 struct crypto_testsuite_params *ts_params = &testsuite_params;
2849 struct crypto_unittest_params *ut_params = &unittest_params;
2851 enum rte_crypto_cipher_algorithm cipher_algo =
2852 ut_params->cipher_xform.cipher.algo;
2853 enum rte_crypto_auth_algorithm auth_algo =
2854 ut_params->auth_xform.auth.algo;
2856 /* Generate Crypto op data structure */
2857 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2858 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2859 TEST_ASSERT_NOT_NULL(ut_params->op,
2860 "Failed to allocate pktmbuf offload");
2861 /* Set crypto operation data parameters */
2862 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2864 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2866 /* set crypto operation source mbuf */
2867 sym_op->m_src = ut_params->ibuf;
2870 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2871 ut_params->ibuf, auth_tag_len);
2873 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2874 "no room to append auth tag");
2875 ut_params->digest = sym_op->auth.digest.data;
2877 if (rte_pktmbuf_is_contiguous(ut_params->ibuf)) {
2878 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2879 ut_params->ibuf, data_pad_len);
2881 struct rte_mbuf *m = ut_params->ibuf;
2882 unsigned int offset = data_pad_len;
2884 while (offset > m->data_len && m->next != NULL) {
2885 offset -= m->data_len;
2888 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2892 if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2893 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2895 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2897 debug_hexdump(stdout, "digest:",
2898 sym_op->auth.digest.data,
2901 /* Copy cipher and auth IVs at the end of the crypto operation */
2902 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2904 rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2905 iv_ptr += cipher_iv_len;
2906 rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2908 if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
2909 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
2910 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
2911 sym_op->cipher.data.length = cipher_len;
2912 sym_op->cipher.data.offset = cipher_offset;
2914 sym_op->cipher.data.length = cipher_len >> 3;
2915 sym_op->cipher.data.offset = cipher_offset >> 3;
2918 if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
2919 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
2920 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
2921 sym_op->auth.data.length = auth_len;
2922 sym_op->auth.data.offset = auth_offset;
2924 sym_op->auth.data.length = auth_len >> 3;
2925 sym_op->auth.data.offset = auth_offset >> 3;
2932 create_wireless_algo_auth_cipher_operation(
2933 const uint8_t *auth_tag, unsigned int auth_tag_len,
2934 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2935 const uint8_t *auth_iv, uint8_t auth_iv_len,
2936 unsigned int data_pad_len,
2937 unsigned int cipher_len, unsigned int cipher_offset,
2938 unsigned int auth_len, unsigned int auth_offset,
2939 uint8_t op_mode, uint8_t do_sgl, uint8_t verify)
2941 struct crypto_testsuite_params *ts_params = &testsuite_params;
2942 struct crypto_unittest_params *ut_params = &unittest_params;
2944 enum rte_crypto_cipher_algorithm cipher_algo =
2945 ut_params->cipher_xform.cipher.algo;
2946 enum rte_crypto_auth_algorithm auth_algo =
2947 ut_params->auth_xform.auth.algo;
2949 /* Generate Crypto op data structure */
2950 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2951 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2952 TEST_ASSERT_NOT_NULL(ut_params->op,
2953 "Failed to allocate pktmbuf offload");
2955 /* Set crypto operation data parameters */
2956 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2958 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2960 /* set crypto operation mbufs */
2961 sym_op->m_src = ut_params->ibuf;
2962 if (op_mode == OUT_OF_PLACE)
2963 sym_op->m_dst = ut_params->obuf;
2967 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(
2968 (op_mode == IN_PLACE ?
2969 ut_params->ibuf : ut_params->obuf),
2970 uint8_t *, data_pad_len);
2971 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2972 (op_mode == IN_PLACE ?
2973 ut_params->ibuf : ut_params->obuf),
2975 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2977 uint16_t remaining_off = (auth_offset >> 3) + (auth_len >> 3);
2978 struct rte_mbuf *sgl_buf = (op_mode == IN_PLACE ?
2979 sym_op->m_src : sym_op->m_dst);
2980 while (remaining_off >= rte_pktmbuf_data_len(sgl_buf)) {
2981 remaining_off -= rte_pktmbuf_data_len(sgl_buf);
2982 sgl_buf = sgl_buf->next;
2984 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(sgl_buf,
2985 uint8_t *, remaining_off);
2986 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(sgl_buf,
2988 memset(sym_op->auth.digest.data, 0, remaining_off);
2989 while (sgl_buf->next != NULL) {
2990 memset(rte_pktmbuf_mtod(sgl_buf, uint8_t *),
2991 0, rte_pktmbuf_data_len(sgl_buf));
2992 sgl_buf = sgl_buf->next;
2996 /* Copy digest for the verification */
2998 memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
3000 /* Copy cipher and auth IVs at the end of the crypto operation */
3001 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(
3002 ut_params->op, uint8_t *, IV_OFFSET);
3004 rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
3005 iv_ptr += cipher_iv_len;
3006 rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
3008 /* Only copy over the offset data needed from src to dst in OOP,
3009 * if the auth and cipher offsets are not aligned
3011 if (op_mode == OUT_OF_PLACE) {
3012 if (cipher_offset > auth_offset)
3014 rte_pktmbuf_mtod_offset(
3016 uint8_t *, auth_offset >> 3),
3017 rte_pktmbuf_mtod_offset(
3019 uint8_t *, auth_offset >> 3),
3020 ((cipher_offset >> 3) - (auth_offset >> 3)));
3023 if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
3024 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
3025 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
3026 sym_op->cipher.data.length = cipher_len;
3027 sym_op->cipher.data.offset = cipher_offset;
3029 sym_op->cipher.data.length = cipher_len >> 3;
3030 sym_op->cipher.data.offset = cipher_offset >> 3;
3033 if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
3034 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
3035 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
3036 sym_op->auth.data.length = auth_len;
3037 sym_op->auth.data.offset = auth_offset;
3039 sym_op->auth.data.length = auth_len >> 3;
3040 sym_op->auth.data.offset = auth_offset >> 3;
3047 test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
3049 struct crypto_testsuite_params *ts_params = &testsuite_params;
3050 struct crypto_unittest_params *ut_params = &unittest_params;
3053 unsigned plaintext_pad_len;
3054 unsigned plaintext_len;
3056 struct rte_cryptodev_info dev_info;
3058 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3059 uint64_t feat_flags = dev_info.feature_flags;
3061 if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
3062 ((tdata->validAuthLenInBits.len % 8) != 0)) {
3063 printf("Device doesn't support NON-Byte Aligned Data.\n");
3064 return TEST_SKIPPED;
3067 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3068 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3069 printf("Device doesn't support RAW data-path APIs.\n");
3070 return TEST_SKIPPED;
3073 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3074 return TEST_SKIPPED;
3076 /* Verify the capabilities */
3077 struct rte_cryptodev_sym_capability_idx cap_idx;
3078 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3079 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
3080 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3082 return TEST_SKIPPED;
3084 /* Create SNOW 3G session */
3085 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3086 tdata->key.data, tdata->key.len,
3087 tdata->auth_iv.len, tdata->digest.len,
3088 RTE_CRYPTO_AUTH_OP_GENERATE,
3089 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
3093 /* alloc mbuf and set payload */
3094 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3096 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3097 rte_pktmbuf_tailroom(ut_params->ibuf));
3099 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3100 /* Append data which is padded to a multiple of */
3101 /* the algorithms block size */
3102 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3103 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3105 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3107 /* Create SNOW 3G operation */
3108 retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
3109 tdata->auth_iv.data, tdata->auth_iv.len,
3110 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3111 tdata->validAuthLenInBits.len,
3116 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3117 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3118 ut_params->op, 0, 1, 1, 0);
3120 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3122 ut_params->obuf = ut_params->op->sym->m_src;
3123 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3124 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3125 + plaintext_pad_len;
3128 TEST_ASSERT_BUFFERS_ARE_EQUAL(
3131 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
3132 "SNOW 3G Generated auth tag not as expected");
3138 test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
3140 struct crypto_testsuite_params *ts_params = &testsuite_params;
3141 struct crypto_unittest_params *ut_params = &unittest_params;
3144 unsigned plaintext_pad_len;
3145 unsigned plaintext_len;
3147 struct rte_cryptodev_info dev_info;
3149 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3150 uint64_t feat_flags = dev_info.feature_flags;
3152 if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
3153 ((tdata->validAuthLenInBits.len % 8) != 0)) {
3154 printf("Device doesn't support NON-Byte Aligned Data.\n");
3155 return TEST_SKIPPED;
3158 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3159 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3160 printf("Device doesn't support RAW data-path APIs.\n");
3161 return TEST_SKIPPED;
3164 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3165 return TEST_SKIPPED;
3167 /* Verify the capabilities */
3168 struct rte_cryptodev_sym_capability_idx cap_idx;
3169 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3170 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
3171 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3173 return TEST_SKIPPED;
3175 /* Create SNOW 3G session */
3176 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3177 tdata->key.data, tdata->key.len,
3178 tdata->auth_iv.len, tdata->digest.len,
3179 RTE_CRYPTO_AUTH_OP_VERIFY,
3180 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
3183 /* alloc mbuf and set payload */
3184 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3186 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3187 rte_pktmbuf_tailroom(ut_params->ibuf));
3189 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3190 /* Append data which is padded to a multiple of */
3191 /* the algorithms block size */
3192 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3193 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3195 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3197 /* Create SNOW 3G operation */
3198 retval = create_wireless_algo_hash_operation(tdata->digest.data,
3200 tdata->auth_iv.data, tdata->auth_iv.len,
3202 RTE_CRYPTO_AUTH_OP_VERIFY,
3203 tdata->validAuthLenInBits.len,
3208 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3209 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3210 ut_params->op, 0, 1, 1, 0);
3212 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3214 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3215 ut_params->obuf = ut_params->op->sym->m_src;
3216 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3217 + plaintext_pad_len;
3220 if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
3229 test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
3231 struct crypto_testsuite_params *ts_params = &testsuite_params;
3232 struct crypto_unittest_params *ut_params = &unittest_params;
3235 unsigned plaintext_pad_len;
3236 unsigned plaintext_len;
3238 struct rte_cryptodev_info dev_info;
3240 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3241 uint64_t feat_flags = dev_info.feature_flags;
3243 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3244 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3245 printf("Device doesn't support RAW data-path APIs.\n");
3246 return TEST_SKIPPED;
3249 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3250 return TEST_SKIPPED;
3252 /* Verify the capabilities */
3253 struct rte_cryptodev_sym_capability_idx cap_idx;
3254 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3255 cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
3256 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3258 return TEST_SKIPPED;
3260 /* Create KASUMI session */
3261 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3262 tdata->key.data, tdata->key.len,
3263 0, tdata->digest.len,
3264 RTE_CRYPTO_AUTH_OP_GENERATE,
3265 RTE_CRYPTO_AUTH_KASUMI_F9);
3269 /* alloc mbuf and set payload */
3270 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3272 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3273 rte_pktmbuf_tailroom(ut_params->ibuf));
3275 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3276 /* Append data which is padded to a multiple of */
3277 /* the algorithms block size */
3278 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3279 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3281 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3283 /* Create KASUMI operation */
3284 retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
3286 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3287 tdata->plaintext.len,
3292 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3293 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
3295 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3296 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3297 ut_params->op, 0, 1, 1, 0);
3299 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3302 ut_params->obuf = ut_params->op->sym->m_src;
3303 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3304 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3305 + plaintext_pad_len;
3308 TEST_ASSERT_BUFFERS_ARE_EQUAL(
3311 DIGEST_BYTE_LENGTH_KASUMI_F9,
3312 "KASUMI Generated auth tag not as expected");
3318 test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
3320 struct crypto_testsuite_params *ts_params = &testsuite_params;
3321 struct crypto_unittest_params *ut_params = &unittest_params;
3324 unsigned plaintext_pad_len;
3325 unsigned plaintext_len;
3327 struct rte_cryptodev_info dev_info;
3329 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3330 uint64_t feat_flags = dev_info.feature_flags;
3332 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3333 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3334 printf("Device doesn't support RAW data-path APIs.\n");
3335 return TEST_SKIPPED;
3338 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3339 return TEST_SKIPPED;
3341 /* Verify the capabilities */
3342 struct rte_cryptodev_sym_capability_idx cap_idx;
3343 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3344 cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
3345 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3347 return TEST_SKIPPED;
3349 /* Create KASUMI session */
3350 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3351 tdata->key.data, tdata->key.len,
3352 0, tdata->digest.len,
3353 RTE_CRYPTO_AUTH_OP_VERIFY,
3354 RTE_CRYPTO_AUTH_KASUMI_F9);
3357 /* alloc mbuf and set payload */
3358 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3360 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3361 rte_pktmbuf_tailroom(ut_params->ibuf));
3363 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3364 /* Append data which is padded to a multiple */
3365 /* of the algorithms block size */
3366 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3367 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3369 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3371 /* Create KASUMI operation */
3372 retval = create_wireless_algo_hash_operation(tdata->digest.data,
3376 RTE_CRYPTO_AUTH_OP_VERIFY,
3377 tdata->plaintext.len,
3382 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3383 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3384 ut_params->op, 0, 1, 1, 0);
3386 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3388 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3389 ut_params->obuf = ut_params->op->sym->m_src;
3390 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3391 + plaintext_pad_len;
3394 if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
3403 test_snow3g_hash_generate_test_case_1(void)
3405 return test_snow3g_authentication(&snow3g_hash_test_case_1);
3409 test_snow3g_hash_generate_test_case_2(void)
3411 return test_snow3g_authentication(&snow3g_hash_test_case_2);
3415 test_snow3g_hash_generate_test_case_3(void)
3417 return test_snow3g_authentication(&snow3g_hash_test_case_3);
3421 test_snow3g_hash_generate_test_case_4(void)
3423 return test_snow3g_authentication(&snow3g_hash_test_case_4);
3427 test_snow3g_hash_generate_test_case_5(void)
3429 return test_snow3g_authentication(&snow3g_hash_test_case_5);
3433 test_snow3g_hash_generate_test_case_6(void)
3435 return test_snow3g_authentication(&snow3g_hash_test_case_6);
3439 test_snow3g_hash_verify_test_case_1(void)
3441 return test_snow3g_authentication_verify(&snow3g_hash_test_case_1);
3446 test_snow3g_hash_verify_test_case_2(void)
3448 return test_snow3g_authentication_verify(&snow3g_hash_test_case_2);
3452 test_snow3g_hash_verify_test_case_3(void)
3454 return test_snow3g_authentication_verify(&snow3g_hash_test_case_3);
3458 test_snow3g_hash_verify_test_case_4(void)
3460 return test_snow3g_authentication_verify(&snow3g_hash_test_case_4);
3464 test_snow3g_hash_verify_test_case_5(void)
3466 return test_snow3g_authentication_verify(&snow3g_hash_test_case_5);
3470 test_snow3g_hash_verify_test_case_6(void)
3472 return test_snow3g_authentication_verify(&snow3g_hash_test_case_6);
3476 test_kasumi_hash_generate_test_case_1(void)
3478 return test_kasumi_authentication(&kasumi_hash_test_case_1);
3482 test_kasumi_hash_generate_test_case_2(void)
3484 return test_kasumi_authentication(&kasumi_hash_test_case_2);
3488 test_kasumi_hash_generate_test_case_3(void)
3490 return test_kasumi_authentication(&kasumi_hash_test_case_3);
3494 test_kasumi_hash_generate_test_case_4(void)
3496 return test_kasumi_authentication(&kasumi_hash_test_case_4);
3500 test_kasumi_hash_generate_test_case_5(void)
3502 return test_kasumi_authentication(&kasumi_hash_test_case_5);
3506 test_kasumi_hash_generate_test_case_6(void)
3508 return test_kasumi_authentication(&kasumi_hash_test_case_6);
3512 test_kasumi_hash_verify_test_case_1(void)
3514 return test_kasumi_authentication_verify(&kasumi_hash_test_case_1);
3518 test_kasumi_hash_verify_test_case_2(void)
3520 return test_kasumi_authentication_verify(&kasumi_hash_test_case_2);
3524 test_kasumi_hash_verify_test_case_3(void)
3526 return test_kasumi_authentication_verify(&kasumi_hash_test_case_3);
3530 test_kasumi_hash_verify_test_case_4(void)
3532 return test_kasumi_authentication_verify(&kasumi_hash_test_case_4);
3536 test_kasumi_hash_verify_test_case_5(void)
3538 return test_kasumi_authentication_verify(&kasumi_hash_test_case_5);
3542 test_kasumi_encryption(const struct kasumi_test_data *tdata)
3544 struct crypto_testsuite_params *ts_params = &testsuite_params;
3545 struct crypto_unittest_params *ut_params = &unittest_params;
3548 uint8_t *plaintext, *ciphertext;
3549 unsigned plaintext_pad_len;
3550 unsigned plaintext_len;
3551 struct rte_cryptodev_info dev_info;
3553 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3554 uint64_t feat_flags = dev_info.feature_flags;
3556 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3557 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3558 printf("Device doesn't support RAW data-path APIs.\n");
3559 return TEST_SKIPPED;
3562 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3563 return TEST_SKIPPED;
3565 /* Verify the capabilities */
3566 struct rte_cryptodev_sym_capability_idx cap_idx;
3567 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3568 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3569 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3571 return TEST_SKIPPED;
3573 /* Create KASUMI session */
3574 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3575 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3576 RTE_CRYPTO_CIPHER_KASUMI_F8,
3577 tdata->key.data, tdata->key.len,
3578 tdata->cipher_iv.len);
3582 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3584 /* Clear mbuf payload */
3585 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3586 rte_pktmbuf_tailroom(ut_params->ibuf));
3588 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3589 /* Append data which is padded to a multiple */
3590 /* of the algorithms block size */
3591 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3592 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3594 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3596 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3598 /* Create KASUMI operation */
3599 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3600 tdata->cipher_iv.len,
3601 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3602 tdata->validCipherOffsetInBits.len);
3606 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3607 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3608 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
3610 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3612 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3614 ut_params->obuf = ut_params->op->sym->m_dst;
3615 if (ut_params->obuf)
3616 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3618 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3620 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3622 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3623 (tdata->validCipherOffsetInBits.len >> 3);
3625 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3627 reference_ciphertext,
3628 tdata->validCipherLenInBits.len,
3629 "KASUMI Ciphertext data not as expected");
3634 test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
3636 struct crypto_testsuite_params *ts_params = &testsuite_params;
3637 struct crypto_unittest_params *ut_params = &unittest_params;
3641 unsigned int plaintext_pad_len;
3642 unsigned int plaintext_len;
3644 uint8_t buffer[10000];
3645 const uint8_t *ciphertext;
3647 struct rte_cryptodev_info dev_info;
3649 /* Verify the capabilities */
3650 struct rte_cryptodev_sym_capability_idx cap_idx;
3651 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3652 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3653 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3655 return TEST_SKIPPED;
3657 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3659 uint64_t feat_flags = dev_info.feature_flags;
3661 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
3662 printf("Device doesn't support in-place scatter-gather. "
3664 return TEST_SKIPPED;
3667 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3668 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3669 printf("Device doesn't support RAW data-path APIs.\n");
3670 return TEST_SKIPPED;
3673 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3674 return TEST_SKIPPED;
3676 /* Create KASUMI session */
3677 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3678 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3679 RTE_CRYPTO_CIPHER_KASUMI_F8,
3680 tdata->key.data, tdata->key.len,
3681 tdata->cipher_iv.len);
3685 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3688 /* Append data which is padded to a multiple */
3689 /* of the algorithms block size */
3690 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3692 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3693 plaintext_pad_len, 10, 0);
3695 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3697 /* Create KASUMI operation */
3698 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3699 tdata->cipher_iv.len,
3700 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3701 tdata->validCipherOffsetInBits.len);
3705 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3706 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3707 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
3709 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3711 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3713 ut_params->obuf = ut_params->op->sym->m_dst;
3715 if (ut_params->obuf)
3716 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3717 plaintext_len, buffer);
3719 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3720 tdata->validCipherOffsetInBits.len >> 3,
3721 plaintext_len, buffer);
3724 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3726 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3727 (tdata->validCipherOffsetInBits.len >> 3);
3729 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3731 reference_ciphertext,
3732 tdata->validCipherLenInBits.len,
3733 "KASUMI Ciphertext data not as expected");
3738 test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
3740 struct crypto_testsuite_params *ts_params = &testsuite_params;
3741 struct crypto_unittest_params *ut_params = &unittest_params;
3744 uint8_t *plaintext, *ciphertext;
3745 unsigned plaintext_pad_len;
3746 unsigned plaintext_len;
3748 /* Verify the capabilities */
3749 struct rte_cryptodev_sym_capability_idx cap_idx;
3750 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3751 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3752 /* Data-path service does not support OOP */
3753 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3755 return TEST_SKIPPED;
3757 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3758 return TEST_SKIPPED;
3760 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3761 return TEST_SKIPPED;
3763 /* Create KASUMI session */
3764 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3765 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3766 RTE_CRYPTO_CIPHER_KASUMI_F8,
3767 tdata->key.data, tdata->key.len,
3768 tdata->cipher_iv.len);
3772 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3773 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3775 /* Clear mbuf payload */
3776 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3777 rte_pktmbuf_tailroom(ut_params->ibuf));
3779 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3780 /* Append data which is padded to a multiple */
3781 /* of the algorithms block size */
3782 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3783 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3785 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3786 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3788 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3790 /* Create KASUMI operation */
3791 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3792 tdata->cipher_iv.len,
3793 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3794 tdata->validCipherOffsetInBits.len);
3798 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3800 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3802 ut_params->obuf = ut_params->op->sym->m_dst;
3803 if (ut_params->obuf)
3804 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3806 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3808 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3810 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3811 (tdata->validCipherOffsetInBits.len >> 3);
3813 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3815 reference_ciphertext,
3816 tdata->validCipherLenInBits.len,
3817 "KASUMI Ciphertext data not as expected");
3822 test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
3824 struct crypto_testsuite_params *ts_params = &testsuite_params;
3825 struct crypto_unittest_params *ut_params = &unittest_params;
3828 unsigned int plaintext_pad_len;
3829 unsigned int plaintext_len;
3831 const uint8_t *ciphertext;
3832 uint8_t buffer[2048];
3834 struct rte_cryptodev_info dev_info;
3836 /* Verify the capabilities */
3837 struct rte_cryptodev_sym_capability_idx cap_idx;
3838 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3839 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3840 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3842 return TEST_SKIPPED;
3844 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3845 return TEST_SKIPPED;
3847 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3848 return TEST_SKIPPED;
3850 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3852 uint64_t feat_flags = dev_info.feature_flags;
3853 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
3854 printf("Device doesn't support out-of-place scatter-gather "
3855 "in both input and output mbufs. "
3857 return TEST_SKIPPED;
3860 /* Create KASUMI session */
3861 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3862 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3863 RTE_CRYPTO_CIPHER_KASUMI_F8,
3864 tdata->key.data, tdata->key.len,
3865 tdata->cipher_iv.len);
3869 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3870 /* Append data which is padded to a multiple */
3871 /* of the algorithms block size */
3872 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3874 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3875 plaintext_pad_len, 10, 0);
3876 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
3877 plaintext_pad_len, 3, 0);
3879 /* Append data which is padded to a multiple */
3880 /* of the algorithms block size */
3881 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3883 /* Create KASUMI operation */
3884 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3885 tdata->cipher_iv.len,
3886 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3887 tdata->validCipherOffsetInBits.len);
3891 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3893 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3895 ut_params->obuf = ut_params->op->sym->m_dst;
3896 if (ut_params->obuf)
3897 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3898 plaintext_pad_len, buffer);
3900 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3901 tdata->validCipherOffsetInBits.len >> 3,
3902 plaintext_pad_len, buffer);
3904 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3905 (tdata->validCipherOffsetInBits.len >> 3);
3907 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3909 reference_ciphertext,
3910 tdata->validCipherLenInBits.len,
3911 "KASUMI Ciphertext data not as expected");
3917 test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
3919 struct crypto_testsuite_params *ts_params = &testsuite_params;
3920 struct crypto_unittest_params *ut_params = &unittest_params;
3923 uint8_t *ciphertext, *plaintext;
3924 unsigned ciphertext_pad_len;
3925 unsigned ciphertext_len;
3927 /* Verify the capabilities */
3928 struct rte_cryptodev_sym_capability_idx cap_idx;
3929 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3930 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3931 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3933 return TEST_SKIPPED;
3935 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3936 return TEST_SKIPPED;
3938 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3939 return TEST_SKIPPED;
3941 /* Create KASUMI session */
3942 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3943 RTE_CRYPTO_CIPHER_OP_DECRYPT,
3944 RTE_CRYPTO_CIPHER_KASUMI_F8,
3945 tdata->key.data, tdata->key.len,
3946 tdata->cipher_iv.len);
3950 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3951 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3953 /* Clear mbuf payload */
3954 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3955 rte_pktmbuf_tailroom(ut_params->ibuf));
3957 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3958 /* Append data which is padded to a multiple */
3959 /* of the algorithms block size */
3960 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
3961 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3962 ciphertext_pad_len);
3963 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
3964 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3966 debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
3968 /* Create KASUMI operation */
3969 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3970 tdata->cipher_iv.len,
3971 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3972 tdata->validCipherOffsetInBits.len);
3976 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3978 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3980 ut_params->obuf = ut_params->op->sym->m_dst;
3981 if (ut_params->obuf)
3982 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3984 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
3986 debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
3988 const uint8_t *reference_plaintext = tdata->plaintext.data +
3989 (tdata->validCipherOffsetInBits.len >> 3);
3991 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3993 reference_plaintext,
3994 tdata->validCipherLenInBits.len,
3995 "KASUMI Plaintext data not as expected");
4000 test_kasumi_decryption(const struct kasumi_test_data *tdata)
4002 struct crypto_testsuite_params *ts_params = &testsuite_params;
4003 struct crypto_unittest_params *ut_params = &unittest_params;
4006 uint8_t *ciphertext, *plaintext;
4007 unsigned ciphertext_pad_len;
4008 unsigned ciphertext_len;
4009 struct rte_cryptodev_info dev_info;
4011 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4012 uint64_t feat_flags = dev_info.feature_flags;
4014 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4015 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4016 printf("Device doesn't support RAW data-path APIs.\n");
4017 return TEST_SKIPPED;
4020 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4021 return TEST_SKIPPED;
4023 /* Verify the capabilities */
4024 struct rte_cryptodev_sym_capability_idx cap_idx;
4025 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4026 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
4027 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4029 return TEST_SKIPPED;
4031 /* Create KASUMI session */
4032 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4033 RTE_CRYPTO_CIPHER_OP_DECRYPT,
4034 RTE_CRYPTO_CIPHER_KASUMI_F8,
4035 tdata->key.data, tdata->key.len,
4036 tdata->cipher_iv.len);
4040 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4042 /* Clear mbuf payload */
4043 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4044 rte_pktmbuf_tailroom(ut_params->ibuf));
4046 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4047 /* Append data which is padded to a multiple */
4048 /* of the algorithms block size */
4049 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
4050 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4051 ciphertext_pad_len);
4052 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4054 debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4056 /* Create KASUMI operation */
4057 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4058 tdata->cipher_iv.len,
4059 tdata->ciphertext.len,
4060 tdata->validCipherOffsetInBits.len);
4064 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4065 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4066 ut_params->op, 1, 0, 1, 0);
4068 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4070 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4072 ut_params->obuf = ut_params->op->sym->m_dst;
4073 if (ut_params->obuf)
4074 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4076 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
4078 debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4080 const uint8_t *reference_plaintext = tdata->plaintext.data +
4081 (tdata->validCipherOffsetInBits.len >> 3);
4083 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4085 reference_plaintext,
4086 tdata->validCipherLenInBits.len,
4087 "KASUMI Plaintext data not as expected");
4092 test_snow3g_encryption(const struct snow3g_test_data *tdata)
4094 struct crypto_testsuite_params *ts_params = &testsuite_params;
4095 struct crypto_unittest_params *ut_params = &unittest_params;
4098 uint8_t *plaintext, *ciphertext;
4099 unsigned plaintext_pad_len;
4100 unsigned plaintext_len;
4101 struct rte_cryptodev_info dev_info;
4103 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4104 uint64_t feat_flags = dev_info.feature_flags;
4106 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4107 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4108 printf("Device doesn't support RAW data-path APIs.\n");
4109 return TEST_SKIPPED;
4112 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4113 return TEST_SKIPPED;
4115 /* Verify the capabilities */
4116 struct rte_cryptodev_sym_capability_idx cap_idx;
4117 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4118 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4119 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4121 return TEST_SKIPPED;
4123 /* Create SNOW 3G session */
4124 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4125 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4126 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4127 tdata->key.data, tdata->key.len,
4128 tdata->cipher_iv.len);
4132 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4134 /* Clear mbuf payload */
4135 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4136 rte_pktmbuf_tailroom(ut_params->ibuf));
4138 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4139 /* Append data which is padded to a multiple of */
4140 /* the algorithms block size */
4141 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4142 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4144 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4146 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4148 /* Create SNOW 3G operation */
4149 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4150 tdata->cipher_iv.len,
4151 tdata->validCipherLenInBits.len,
4156 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4157 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4158 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4160 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4162 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4164 ut_params->obuf = ut_params->op->sym->m_dst;
4165 if (ut_params->obuf)
4166 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4168 ciphertext = plaintext;
4170 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4173 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4175 tdata->ciphertext.data,
4176 tdata->validDataLenInBits.len,
4177 "SNOW 3G Ciphertext data not as expected");
4183 test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
4185 struct crypto_testsuite_params *ts_params = &testsuite_params;
4186 struct crypto_unittest_params *ut_params = &unittest_params;
4187 uint8_t *plaintext, *ciphertext;
4190 unsigned plaintext_pad_len;
4191 unsigned plaintext_len;
4193 /* Verify the capabilities */
4194 struct rte_cryptodev_sym_capability_idx cap_idx;
4195 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4196 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4197 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4199 return TEST_SKIPPED;
4201 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4202 return TEST_SKIPPED;
4204 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4205 return TEST_SKIPPED;
4207 /* Create SNOW 3G session */
4208 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4209 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4210 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4211 tdata->key.data, tdata->key.len,
4212 tdata->cipher_iv.len);
4216 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4217 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4219 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4220 "Failed to allocate input buffer in mempool");
4221 TEST_ASSERT_NOT_NULL(ut_params->obuf,
4222 "Failed to allocate output buffer in mempool");
4224 /* Clear mbuf payload */
4225 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4226 rte_pktmbuf_tailroom(ut_params->ibuf));
4228 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4229 /* Append data which is padded to a multiple of */
4230 /* the algorithms block size */
4231 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4232 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4234 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4235 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4237 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4239 /* Create SNOW 3G operation */
4240 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4241 tdata->cipher_iv.len,
4242 tdata->validCipherLenInBits.len,
4247 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4249 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4251 ut_params->obuf = ut_params->op->sym->m_dst;
4252 if (ut_params->obuf)
4253 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4255 ciphertext = plaintext;
4257 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4260 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4262 tdata->ciphertext.data,
4263 tdata->validDataLenInBits.len,
4264 "SNOW 3G Ciphertext data not as expected");
4269 test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
4271 struct crypto_testsuite_params *ts_params = &testsuite_params;
4272 struct crypto_unittest_params *ut_params = &unittest_params;
4275 unsigned int plaintext_pad_len;
4276 unsigned int plaintext_len;
4277 uint8_t buffer[10000];
4278 const uint8_t *ciphertext;
4280 struct rte_cryptodev_info dev_info;
4282 /* Verify the capabilities */
4283 struct rte_cryptodev_sym_capability_idx cap_idx;
4284 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4285 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4286 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4288 return TEST_SKIPPED;
4290 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4291 return TEST_SKIPPED;
4293 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4294 return TEST_SKIPPED;
4296 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4298 uint64_t feat_flags = dev_info.feature_flags;
4300 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
4301 printf("Device doesn't support out-of-place scatter-gather "
4302 "in both input and output mbufs. "
4304 return TEST_SKIPPED;
4307 /* Create SNOW 3G session */
4308 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4309 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4310 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4311 tdata->key.data, tdata->key.len,
4312 tdata->cipher_iv.len);
4316 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4317 /* Append data which is padded to a multiple of */
4318 /* the algorithms block size */
4319 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4321 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
4322 plaintext_pad_len, 10, 0);
4323 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
4324 plaintext_pad_len, 3, 0);
4326 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4327 "Failed to allocate input buffer in mempool");
4328 TEST_ASSERT_NOT_NULL(ut_params->obuf,
4329 "Failed to allocate output buffer in mempool");
4331 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
4333 /* Create SNOW 3G operation */
4334 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4335 tdata->cipher_iv.len,
4336 tdata->validCipherLenInBits.len,
4341 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4343 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4345 ut_params->obuf = ut_params->op->sym->m_dst;
4346 if (ut_params->obuf)
4347 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
4348 plaintext_len, buffer);
4350 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
4351 plaintext_len, buffer);
4353 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4356 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4358 tdata->ciphertext.data,
4359 tdata->validDataLenInBits.len,
4360 "SNOW 3G Ciphertext data not as expected");
4365 /* Shift right a buffer by "offset" bits, "offset" < 8 */
4367 buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset)
4369 uint8_t curr_byte, prev_byte;
4370 uint32_t length_in_bytes = ceil_byte_length(length + offset);
4371 uint8_t lower_byte_mask = (1 << offset) - 1;
4374 prev_byte = buffer[0];
4375 buffer[0] >>= offset;
4377 for (i = 1; i < length_in_bytes; i++) {
4378 curr_byte = buffer[i];
4379 buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) |
4380 (curr_byte >> offset);
4381 prev_byte = curr_byte;
4386 test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
4388 struct crypto_testsuite_params *ts_params = &testsuite_params;
4389 struct crypto_unittest_params *ut_params = &unittest_params;
4390 uint8_t *plaintext, *ciphertext;
4392 uint32_t plaintext_len;
4393 uint32_t plaintext_pad_len;
4394 uint8_t extra_offset = 4;
4395 uint8_t *expected_ciphertext_shifted;
4396 struct rte_cryptodev_info dev_info;
4398 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4399 uint64_t feat_flags = dev_info.feature_flags;
4401 if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
4402 ((tdata->validDataLenInBits.len % 8) != 0)) {
4403 printf("Device doesn't support NON-Byte Aligned Data.\n");
4404 return TEST_SKIPPED;
4407 /* Verify the capabilities */
4408 struct rte_cryptodev_sym_capability_idx cap_idx;
4409 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4410 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4411 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4413 return TEST_SKIPPED;
4415 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4416 return TEST_SKIPPED;
4418 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4419 return TEST_SKIPPED;
4421 /* Create SNOW 3G session */
4422 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4423 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4424 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4425 tdata->key.data, tdata->key.len,
4426 tdata->cipher_iv.len);
4430 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4431 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4433 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4434 "Failed to allocate input buffer in mempool");
4435 TEST_ASSERT_NOT_NULL(ut_params->obuf,
4436 "Failed to allocate output buffer in mempool");
4438 /* Clear mbuf payload */
4439 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4440 rte_pktmbuf_tailroom(ut_params->ibuf));
4442 plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset);
4444 * Append data which is padded to a
4445 * multiple of the algorithms block size
4447 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4449 plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf,
4452 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4454 memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3));
4455 buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset);
4457 #ifdef RTE_APP_TEST_DEBUG
4458 rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
4460 /* Create SNOW 3G operation */
4461 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4462 tdata->cipher_iv.len,
4463 tdata->validCipherLenInBits.len,
4468 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4470 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4472 ut_params->obuf = ut_params->op->sym->m_dst;
4473 if (ut_params->obuf)
4474 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4476 ciphertext = plaintext;
4478 #ifdef RTE_APP_TEST_DEBUG
4479 rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4482 expected_ciphertext_shifted = rte_malloc(NULL, plaintext_len, 8);
4484 TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted,
4485 "failed to reserve memory for ciphertext shifted\n");
4487 memcpy(expected_ciphertext_shifted, tdata->ciphertext.data,
4488 ceil_byte_length(tdata->ciphertext.len));
4489 buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len,
4492 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
4494 expected_ciphertext_shifted,
4495 tdata->validDataLenInBits.len,
4497 "SNOW 3G Ciphertext data not as expected");
4501 static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
4503 struct crypto_testsuite_params *ts_params = &testsuite_params;
4504 struct crypto_unittest_params *ut_params = &unittest_params;
4508 uint8_t *plaintext, *ciphertext;
4509 unsigned ciphertext_pad_len;
4510 unsigned ciphertext_len;
4511 struct rte_cryptodev_info dev_info;
4513 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4514 uint64_t feat_flags = dev_info.feature_flags;
4516 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4517 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4518 printf("Device doesn't support RAW data-path APIs.\n");
4519 return TEST_SKIPPED;
4522 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4523 return TEST_SKIPPED;
4525 /* Verify the capabilities */
4526 struct rte_cryptodev_sym_capability_idx cap_idx;
4527 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4528 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4529 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4531 return TEST_SKIPPED;
4533 /* Create SNOW 3G session */
4534 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4535 RTE_CRYPTO_CIPHER_OP_DECRYPT,
4536 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4537 tdata->key.data, tdata->key.len,
4538 tdata->cipher_iv.len);
4542 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4544 /* Clear mbuf payload */
4545 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4546 rte_pktmbuf_tailroom(ut_params->ibuf));
4548 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4549 /* Append data which is padded to a multiple of */
4550 /* the algorithms block size */
4551 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4552 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4553 ciphertext_pad_len);
4554 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4556 debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4558 /* Create SNOW 3G operation */
4559 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4560 tdata->cipher_iv.len,
4561 tdata->validCipherLenInBits.len,
4562 tdata->cipher.offset_bits);
4566 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4567 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4568 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4570 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4572 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4573 ut_params->obuf = ut_params->op->sym->m_dst;
4574 if (ut_params->obuf)
4575 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4577 plaintext = ciphertext;
4579 debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4582 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4583 tdata->plaintext.data,
4584 tdata->validDataLenInBits.len,
4585 "SNOW 3G Plaintext data not as expected");
4589 static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
4591 struct crypto_testsuite_params *ts_params = &testsuite_params;
4592 struct crypto_unittest_params *ut_params = &unittest_params;
4596 uint8_t *plaintext, *ciphertext;
4597 unsigned ciphertext_pad_len;
4598 unsigned ciphertext_len;
4600 /* Verify the capabilities */
4601 struct rte_cryptodev_sym_capability_idx cap_idx;
4602 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4603 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4604 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4606 return TEST_SKIPPED;
4608 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4609 return TEST_SKIPPED;
4611 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4612 return TEST_SKIPPED;
4614 /* Create SNOW 3G session */
4615 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4616 RTE_CRYPTO_CIPHER_OP_DECRYPT,
4617 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4618 tdata->key.data, tdata->key.len,
4619 tdata->cipher_iv.len);
4623 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4624 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4626 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4627 "Failed to allocate input buffer");
4628 TEST_ASSERT_NOT_NULL(ut_params->obuf,
4629 "Failed to allocate output buffer");
4631 /* Clear mbuf payload */
4632 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4633 rte_pktmbuf_tailroom(ut_params->ibuf));
4635 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
4636 rte_pktmbuf_tailroom(ut_params->obuf));
4638 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4639 /* Append data which is padded to a multiple of */
4640 /* the algorithms block size */
4641 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4642 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4643 ciphertext_pad_len);
4644 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4645 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4647 debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4649 /* Create SNOW 3G operation */
4650 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4651 tdata->cipher_iv.len,
4652 tdata->validCipherLenInBits.len,
4657 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4659 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4660 ut_params->obuf = ut_params->op->sym->m_dst;
4661 if (ut_params->obuf)
4662 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4664 plaintext = ciphertext;
4666 debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4669 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4670 tdata->plaintext.data,
4671 tdata->validDataLenInBits.len,
4672 "SNOW 3G Plaintext data not as expected");
4677 test_zuc_cipher_auth(const struct wireless_test_data *tdata)
4679 struct crypto_testsuite_params *ts_params = &testsuite_params;
4680 struct crypto_unittest_params *ut_params = &unittest_params;
4684 uint8_t *plaintext, *ciphertext;
4685 unsigned int plaintext_pad_len;
4686 unsigned int plaintext_len;
4688 struct rte_cryptodev_info dev_info;
4689 struct rte_cryptodev_sym_capability_idx cap_idx;
4691 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4692 uint64_t feat_flags = dev_info.feature_flags;
4694 if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
4695 ((tdata->validAuthLenInBits.len % 8 != 0) ||
4696 (tdata->validDataLenInBits.len % 8 != 0))) {
4697 printf("Device doesn't support NON-Byte Aligned Data.\n");
4698 return TEST_SKIPPED;
4701 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4702 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4703 printf("Device doesn't support RAW data-path APIs.\n");
4704 return TEST_SKIPPED;
4707 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4708 return TEST_SKIPPED;
4710 /* Check if device supports ZUC EEA3 */
4711 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4712 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
4714 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4716 return TEST_SKIPPED;
4718 /* Check if device supports ZUC EIA3 */
4719 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4720 cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
4722 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4724 return TEST_SKIPPED;
4726 /* Create ZUC session */
4727 retval = create_zuc_cipher_auth_encrypt_generate_session(
4728 ts_params->valid_devs[0],
4732 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4734 /* clear mbuf payload */
4735 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4736 rte_pktmbuf_tailroom(ut_params->ibuf));
4738 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4739 /* Append data which is padded to a multiple of */
4740 /* the algorithms block size */
4741 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4742 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4744 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4746 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4748 /* Create ZUC operation */
4749 retval = create_zuc_cipher_hash_generate_operation(tdata);
4753 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4754 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4755 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4757 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4759 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4760 ut_params->obuf = ut_params->op->sym->m_src;
4761 if (ut_params->obuf)
4762 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4764 ciphertext = plaintext;
4766 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4768 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4770 tdata->ciphertext.data,
4771 tdata->validDataLenInBits.len,
4772 "ZUC Ciphertext data not as expected");
4774 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4775 + plaintext_pad_len;
4778 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4782 "ZUC Generated auth tag not as expected");
4787 test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
4789 struct crypto_testsuite_params *ts_params = &testsuite_params;
4790 struct crypto_unittest_params *ut_params = &unittest_params;
4794 uint8_t *plaintext, *ciphertext;
4795 unsigned plaintext_pad_len;
4796 unsigned plaintext_len;
4797 struct rte_cryptodev_info dev_info;
4799 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4800 uint64_t feat_flags = dev_info.feature_flags;
4802 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4803 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4804 printf("Device doesn't support RAW data-path APIs.\n");
4805 return TEST_SKIPPED;
4808 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4809 return TEST_SKIPPED;
4811 /* Verify the capabilities */
4812 struct rte_cryptodev_sym_capability_idx cap_idx;
4813 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4814 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
4815 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4817 return TEST_SKIPPED;
4818 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4819 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4820 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4822 return TEST_SKIPPED;
4824 /* Create SNOW 3G session */
4825 retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0],
4826 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4827 RTE_CRYPTO_AUTH_OP_GENERATE,
4828 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4829 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4830 tdata->key.data, tdata->key.len,
4831 tdata->auth_iv.len, tdata->digest.len,
4832 tdata->cipher_iv.len);
4835 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4837 /* clear mbuf payload */
4838 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4839 rte_pktmbuf_tailroom(ut_params->ibuf));
4841 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4842 /* Append data which is padded to a multiple of */
4843 /* the algorithms block size */
4844 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4845 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4847 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4849 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4851 /* Create SNOW 3G operation */
4852 retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
4853 tdata->digest.len, tdata->auth_iv.data,
4855 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
4856 tdata->cipher_iv.data, tdata->cipher_iv.len,
4857 tdata->validCipherLenInBits.len,
4859 tdata->validAuthLenInBits.len,
4865 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4866 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4867 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4869 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4871 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4872 ut_params->obuf = ut_params->op->sym->m_src;
4873 if (ut_params->obuf)
4874 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4876 ciphertext = plaintext;
4878 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4880 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4882 tdata->ciphertext.data,
4883 tdata->validDataLenInBits.len,
4884 "SNOW 3G Ciphertext data not as expected");
4886 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4887 + plaintext_pad_len;
4890 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4893 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4894 "SNOW 3G Generated auth tag not as expected");
4899 test_snow3g_auth_cipher(const struct snow3g_test_data *tdata,
4900 uint8_t op_mode, uint8_t verify)
4902 struct crypto_testsuite_params *ts_params = &testsuite_params;
4903 struct crypto_unittest_params *ut_params = &unittest_params;
4907 uint8_t *plaintext = NULL, *ciphertext = NULL;
4908 unsigned int plaintext_pad_len;
4909 unsigned int plaintext_len;
4910 unsigned int ciphertext_pad_len;
4911 unsigned int ciphertext_len;
4913 struct rte_cryptodev_info dev_info;
4915 /* Verify the capabilities */
4916 struct rte_cryptodev_sym_capability_idx cap_idx;
4917 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4918 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
4919 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4921 return TEST_SKIPPED;
4922 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4923 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4924 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4926 return TEST_SKIPPED;
4928 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4929 return TEST_SKIPPED;
4931 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4933 uint64_t feat_flags = dev_info.feature_flags;
4935 if (op_mode == OUT_OF_PLACE) {
4936 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
4937 printf("Device doesn't support digest encrypted.\n");
4938 return TEST_SKIPPED;
4940 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4941 return TEST_SKIPPED;
4944 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4945 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4946 printf("Device doesn't support RAW data-path APIs.\n");
4947 return TEST_SKIPPED;
4950 /* Create SNOW 3G session */
4951 retval = create_wireless_algo_auth_cipher_session(
4952 ts_params->valid_devs[0],
4953 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
4954 : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
4955 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
4956 : RTE_CRYPTO_AUTH_OP_GENERATE),
4957 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4958 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4959 tdata->key.data, tdata->key.len,
4960 tdata->auth_iv.len, tdata->digest.len,
4961 tdata->cipher_iv.len);
4965 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4966 if (op_mode == OUT_OF_PLACE)
4967 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4969 /* clear mbuf payload */
4970 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4971 rte_pktmbuf_tailroom(ut_params->ibuf));
4972 if (op_mode == OUT_OF_PLACE)
4973 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
4974 rte_pktmbuf_tailroom(ut_params->obuf));
4976 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4977 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4978 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4979 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4982 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4983 ciphertext_pad_len);
4984 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4985 if (op_mode == OUT_OF_PLACE)
4986 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4987 debug_hexdump(stdout, "ciphertext:", ciphertext,
4990 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4992 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4993 if (op_mode == OUT_OF_PLACE)
4994 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4995 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4998 /* Create SNOW 3G operation */
4999 retval = create_wireless_algo_auth_cipher_operation(
5000 tdata->digest.data, tdata->digest.len,
5001 tdata->cipher_iv.data, tdata->cipher_iv.len,
5002 tdata->auth_iv.data, tdata->auth_iv.len,
5003 (tdata->digest.offset_bytes == 0 ?
5004 (verify ? ciphertext_pad_len : plaintext_pad_len)
5005 : tdata->digest.offset_bytes),
5006 tdata->validCipherLenInBits.len,
5007 tdata->cipher.offset_bits,
5008 tdata->validAuthLenInBits.len,
5009 tdata->auth.offset_bits,
5010 op_mode, 0, verify);
5015 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5016 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5017 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5019 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5022 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5024 ut_params->obuf = (op_mode == IN_PLACE ?
5025 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5028 if (ut_params->obuf)
5029 plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5032 plaintext = ciphertext +
5033 (tdata->cipher.offset_bits >> 3);
5035 debug_hexdump(stdout, "plaintext:", plaintext,
5036 (tdata->plaintext.len >> 3) - tdata->digest.len);
5037 debug_hexdump(stdout, "plaintext expected:",
5038 tdata->plaintext.data,
5039 (tdata->plaintext.len >> 3) - tdata->digest.len);
5041 if (ut_params->obuf)
5042 ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5045 ciphertext = plaintext;
5047 debug_hexdump(stdout, "ciphertext:", ciphertext,
5049 debug_hexdump(stdout, "ciphertext expected:",
5050 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5052 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5053 + (tdata->digest.offset_bytes == 0 ?
5054 plaintext_pad_len : tdata->digest.offset_bytes);
5056 debug_hexdump(stdout, "digest:", ut_params->digest,
5058 debug_hexdump(stdout, "digest expected:", tdata->digest.data,
5064 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5066 tdata->plaintext.data,
5067 (tdata->plaintext.len - tdata->cipher.offset_bits -
5068 (tdata->digest.len << 3)),
5069 tdata->cipher.offset_bits,
5070 "SNOW 3G Plaintext data not as expected");
5072 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5074 tdata->ciphertext.data,
5075 (tdata->validDataLenInBits.len -
5076 tdata->cipher.offset_bits),
5077 tdata->cipher.offset_bits,
5078 "SNOW 3G Ciphertext data not as expected");
5080 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5083 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5084 "SNOW 3G Generated auth tag not as expected");
5090 test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata,
5091 uint8_t op_mode, uint8_t verify)
5093 struct crypto_testsuite_params *ts_params = &testsuite_params;
5094 struct crypto_unittest_params *ut_params = &unittest_params;
5098 const uint8_t *plaintext = NULL;
5099 const uint8_t *ciphertext = NULL;
5100 const uint8_t *digest = NULL;
5101 unsigned int plaintext_pad_len;
5102 unsigned int plaintext_len;
5103 unsigned int ciphertext_pad_len;
5104 unsigned int ciphertext_len;
5105 uint8_t buffer[10000];
5106 uint8_t digest_buffer[10000];
5108 struct rte_cryptodev_info dev_info;
5110 /* Verify the capabilities */
5111 struct rte_cryptodev_sym_capability_idx cap_idx;
5112 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5113 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
5114 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5116 return TEST_SKIPPED;
5117 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5118 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
5119 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5121 return TEST_SKIPPED;
5123 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5124 return TEST_SKIPPED;
5126 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5128 uint64_t feat_flags = dev_info.feature_flags;
5130 if (op_mode == IN_PLACE) {
5131 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5132 printf("Device doesn't support in-place scatter-gather "
5133 "in both input and output mbufs.\n");
5134 return TEST_SKIPPED;
5136 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5137 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5138 printf("Device doesn't support RAW data-path APIs.\n");
5139 return TEST_SKIPPED;
5142 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5143 return TEST_SKIPPED;
5144 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5145 printf("Device doesn't support out-of-place scatter-gather "
5146 "in both input and output mbufs.\n");
5147 return TEST_SKIPPED;
5149 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5150 printf("Device doesn't support digest encrypted.\n");
5151 return TEST_SKIPPED;
5155 /* Create SNOW 3G session */
5156 retval = create_wireless_algo_auth_cipher_session(
5157 ts_params->valid_devs[0],
5158 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5159 : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5160 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5161 : RTE_CRYPTO_AUTH_OP_GENERATE),
5162 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
5163 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
5164 tdata->key.data, tdata->key.len,
5165 tdata->auth_iv.len, tdata->digest.len,
5166 tdata->cipher_iv.len);
5171 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5172 plaintext_len = ceil_byte_length(tdata->plaintext.len);
5173 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5174 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5176 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5177 plaintext_pad_len, 15, 0);
5178 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5179 "Failed to allocate input buffer in mempool");
5181 if (op_mode == OUT_OF_PLACE) {
5182 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5183 plaintext_pad_len, 15, 0);
5184 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5185 "Failed to allocate output buffer in mempool");
5189 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
5190 tdata->ciphertext.data);
5191 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5192 ciphertext_len, buffer);
5193 debug_hexdump(stdout, "ciphertext:", ciphertext,
5196 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5197 tdata->plaintext.data);
5198 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5199 plaintext_len, buffer);
5200 debug_hexdump(stdout, "plaintext:", plaintext,
5203 memset(buffer, 0, sizeof(buffer));
5205 /* Create SNOW 3G operation */
5206 retval = create_wireless_algo_auth_cipher_operation(
5207 tdata->digest.data, tdata->digest.len,
5208 tdata->cipher_iv.data, tdata->cipher_iv.len,
5209 tdata->auth_iv.data, tdata->auth_iv.len,
5210 (tdata->digest.offset_bytes == 0 ?
5211 (verify ? ciphertext_pad_len : plaintext_pad_len)
5212 : tdata->digest.offset_bytes),
5213 tdata->validCipherLenInBits.len,
5214 tdata->cipher.offset_bits,
5215 tdata->validAuthLenInBits.len,
5216 tdata->auth.offset_bits,
5217 op_mode, 1, verify);
5222 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5223 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5224 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5226 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5229 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5231 ut_params->obuf = (op_mode == IN_PLACE ?
5232 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5235 if (ut_params->obuf)
5236 plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
5237 plaintext_len, buffer);
5239 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5240 plaintext_len, buffer);
5242 debug_hexdump(stdout, "plaintext:", plaintext,
5243 (tdata->plaintext.len >> 3) - tdata->digest.len);
5244 debug_hexdump(stdout, "plaintext expected:",
5245 tdata->plaintext.data,
5246 (tdata->plaintext.len >> 3) - tdata->digest.len);
5248 if (ut_params->obuf)
5249 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
5250 ciphertext_len, buffer);
5252 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5253 ciphertext_len, buffer);
5255 debug_hexdump(stdout, "ciphertext:", ciphertext,
5257 debug_hexdump(stdout, "ciphertext expected:",
5258 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5260 if (ut_params->obuf)
5261 digest = rte_pktmbuf_read(ut_params->obuf,
5262 (tdata->digest.offset_bytes == 0 ?
5263 plaintext_pad_len : tdata->digest.offset_bytes),
5264 tdata->digest.len, digest_buffer);
5266 digest = rte_pktmbuf_read(ut_params->ibuf,
5267 (tdata->digest.offset_bytes == 0 ?
5268 plaintext_pad_len : tdata->digest.offset_bytes),
5269 tdata->digest.len, digest_buffer);
5271 debug_hexdump(stdout, "digest:", digest,
5273 debug_hexdump(stdout, "digest expected:",
5274 tdata->digest.data, tdata->digest.len);
5279 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5281 tdata->plaintext.data,
5282 (tdata->plaintext.len - tdata->cipher.offset_bits -
5283 (tdata->digest.len << 3)),
5284 tdata->cipher.offset_bits,
5285 "SNOW 3G Plaintext data not as expected");
5287 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5289 tdata->ciphertext.data,
5290 (tdata->validDataLenInBits.len -
5291 tdata->cipher.offset_bits),
5292 tdata->cipher.offset_bits,
5293 "SNOW 3G Ciphertext data not as expected");
5295 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5298 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5299 "SNOW 3G Generated auth tag not as expected");
5305 test_kasumi_auth_cipher(const struct kasumi_test_data *tdata,
5306 uint8_t op_mode, uint8_t verify)
5308 struct crypto_testsuite_params *ts_params = &testsuite_params;
5309 struct crypto_unittest_params *ut_params = &unittest_params;
5313 uint8_t *plaintext = NULL, *ciphertext = NULL;
5314 unsigned int plaintext_pad_len;
5315 unsigned int plaintext_len;
5316 unsigned int ciphertext_pad_len;
5317 unsigned int ciphertext_len;
5319 struct rte_cryptodev_info dev_info;
5321 /* Verify the capabilities */
5322 struct rte_cryptodev_sym_capability_idx cap_idx;
5323 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5324 cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5325 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5327 return TEST_SKIPPED;
5328 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5329 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5330 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5332 return TEST_SKIPPED;
5334 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5336 uint64_t feat_flags = dev_info.feature_flags;
5338 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5339 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5340 printf("Device doesn't support RAW data-path APIs.\n");
5341 return TEST_SKIPPED;
5344 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5345 return TEST_SKIPPED;
5347 if (op_mode == OUT_OF_PLACE) {
5348 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5349 return TEST_SKIPPED;
5350 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5351 printf("Device doesn't support digest encrypted.\n");
5352 return TEST_SKIPPED;
5356 /* Create KASUMI session */
5357 retval = create_wireless_algo_auth_cipher_session(
5358 ts_params->valid_devs[0],
5359 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5360 : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5361 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5362 : RTE_CRYPTO_AUTH_OP_GENERATE),
5363 RTE_CRYPTO_AUTH_KASUMI_F9,
5364 RTE_CRYPTO_CIPHER_KASUMI_F8,
5365 tdata->key.data, tdata->key.len,
5366 0, tdata->digest.len,
5367 tdata->cipher_iv.len);
5372 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5373 if (op_mode == OUT_OF_PLACE)
5374 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5376 /* clear mbuf payload */
5377 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5378 rte_pktmbuf_tailroom(ut_params->ibuf));
5379 if (op_mode == OUT_OF_PLACE)
5380 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5381 rte_pktmbuf_tailroom(ut_params->obuf));
5383 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5384 plaintext_len = ceil_byte_length(tdata->plaintext.len);
5385 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5386 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5389 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5390 ciphertext_pad_len);
5391 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
5392 if (op_mode == OUT_OF_PLACE)
5393 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
5394 debug_hexdump(stdout, "ciphertext:", ciphertext,
5397 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5399 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5400 if (op_mode == OUT_OF_PLACE)
5401 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
5402 debug_hexdump(stdout, "plaintext:", plaintext,
5406 /* Create KASUMI operation */
5407 retval = create_wireless_algo_auth_cipher_operation(
5408 tdata->digest.data, tdata->digest.len,
5409 tdata->cipher_iv.data, tdata->cipher_iv.len,
5411 (tdata->digest.offset_bytes == 0 ?
5412 (verify ? ciphertext_pad_len : plaintext_pad_len)
5413 : tdata->digest.offset_bytes),
5414 tdata->validCipherLenInBits.len,
5415 tdata->validCipherOffsetInBits.len,
5416 tdata->validAuthLenInBits.len,
5418 op_mode, 0, verify);
5423 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5424 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5425 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5427 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5430 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5432 ut_params->obuf = (op_mode == IN_PLACE ?
5433 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5437 if (ut_params->obuf)
5438 plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5441 plaintext = ciphertext;
5443 debug_hexdump(stdout, "plaintext:", plaintext,
5444 (tdata->plaintext.len >> 3) - tdata->digest.len);
5445 debug_hexdump(stdout, "plaintext expected:",
5446 tdata->plaintext.data,
5447 (tdata->plaintext.len >> 3) - tdata->digest.len);
5449 if (ut_params->obuf)
5450 ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5453 ciphertext = plaintext;
5455 debug_hexdump(stdout, "ciphertext:", ciphertext,
5457 debug_hexdump(stdout, "ciphertext expected:",
5458 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5460 ut_params->digest = rte_pktmbuf_mtod(
5461 ut_params->obuf, uint8_t *) +
5462 (tdata->digest.offset_bytes == 0 ?
5463 plaintext_pad_len : tdata->digest.offset_bytes);
5465 debug_hexdump(stdout, "digest:", ut_params->digest,
5467 debug_hexdump(stdout, "digest expected:",
5468 tdata->digest.data, tdata->digest.len);
5473 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5475 tdata->plaintext.data,
5476 tdata->plaintext.len >> 3,
5477 "KASUMI Plaintext data not as expected");
5479 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5481 tdata->ciphertext.data,
5482 tdata->ciphertext.len >> 3,
5483 "KASUMI Ciphertext data not as expected");
5485 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5488 DIGEST_BYTE_LENGTH_KASUMI_F9,
5489 "KASUMI Generated auth tag not as expected");
5495 test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata,
5496 uint8_t op_mode, uint8_t verify)
5498 struct crypto_testsuite_params *ts_params = &testsuite_params;
5499 struct crypto_unittest_params *ut_params = &unittest_params;
5503 const uint8_t *plaintext = NULL;
5504 const uint8_t *ciphertext = NULL;
5505 const uint8_t *digest = NULL;
5506 unsigned int plaintext_pad_len;
5507 unsigned int plaintext_len;
5508 unsigned int ciphertext_pad_len;
5509 unsigned int ciphertext_len;
5510 uint8_t buffer[10000];
5511 uint8_t digest_buffer[10000];
5513 struct rte_cryptodev_info dev_info;
5515 /* Verify the capabilities */
5516 struct rte_cryptodev_sym_capability_idx cap_idx;
5517 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5518 cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5519 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5521 return TEST_SKIPPED;
5522 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5523 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5524 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5526 return TEST_SKIPPED;
5528 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5529 return TEST_SKIPPED;
5531 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5533 uint64_t feat_flags = dev_info.feature_flags;
5535 if (op_mode == IN_PLACE) {
5536 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5537 printf("Device doesn't support in-place scatter-gather "
5538 "in both input and output mbufs.\n");
5539 return TEST_SKIPPED;
5541 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5542 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5543 printf("Device doesn't support RAW data-path APIs.\n");
5544 return TEST_SKIPPED;
5547 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5548 return TEST_SKIPPED;
5549 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5550 printf("Device doesn't support out-of-place scatter-gather "
5551 "in both input and output mbufs.\n");
5552 return TEST_SKIPPED;
5554 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5555 printf("Device doesn't support digest encrypted.\n");
5556 return TEST_SKIPPED;
5560 /* Create KASUMI session */
5561 retval = create_wireless_algo_auth_cipher_session(
5562 ts_params->valid_devs[0],
5563 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5564 : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5565 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5566 : RTE_CRYPTO_AUTH_OP_GENERATE),
5567 RTE_CRYPTO_AUTH_KASUMI_F9,
5568 RTE_CRYPTO_CIPHER_KASUMI_F8,
5569 tdata->key.data, tdata->key.len,
5570 0, tdata->digest.len,
5571 tdata->cipher_iv.len);
5576 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5577 plaintext_len = ceil_byte_length(tdata->plaintext.len);
5578 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5579 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5581 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5582 plaintext_pad_len, 15, 0);
5583 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5584 "Failed to allocate input buffer in mempool");
5586 if (op_mode == OUT_OF_PLACE) {
5587 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5588 plaintext_pad_len, 15, 0);
5589 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5590 "Failed to allocate output buffer in mempool");
5594 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
5595 tdata->ciphertext.data);
5596 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5597 ciphertext_len, buffer);
5598 debug_hexdump(stdout, "ciphertext:", ciphertext,
5601 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5602 tdata->plaintext.data);
5603 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5604 plaintext_len, buffer);
5605 debug_hexdump(stdout, "plaintext:", plaintext,
5608 memset(buffer, 0, sizeof(buffer));
5610 /* Create KASUMI operation */
5611 retval = create_wireless_algo_auth_cipher_operation(
5612 tdata->digest.data, tdata->digest.len,
5613 tdata->cipher_iv.data, tdata->cipher_iv.len,
5615 (tdata->digest.offset_bytes == 0 ?
5616 (verify ? ciphertext_pad_len : plaintext_pad_len)
5617 : tdata->digest.offset_bytes),
5618 tdata->validCipherLenInBits.len,
5619 tdata->validCipherOffsetInBits.len,
5620 tdata->validAuthLenInBits.len,
5622 op_mode, 1, verify);
5627 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5628 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5629 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5631 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5634 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5636 ut_params->obuf = (op_mode == IN_PLACE ?
5637 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5640 if (ut_params->obuf)
5641 plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
5642 plaintext_len, buffer);
5644 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5645 plaintext_len, buffer);
5647 debug_hexdump(stdout, "plaintext:", plaintext,
5648 (tdata->plaintext.len >> 3) - tdata->digest.len);
5649 debug_hexdump(stdout, "plaintext expected:",
5650 tdata->plaintext.data,
5651 (tdata->plaintext.len >> 3) - tdata->digest.len);
5653 if (ut_params->obuf)
5654 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
5655 ciphertext_len, buffer);
5657 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5658 ciphertext_len, buffer);
5660 debug_hexdump(stdout, "ciphertext:", ciphertext,
5662 debug_hexdump(stdout, "ciphertext expected:",
5663 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5665 if (ut_params->obuf)
5666 digest = rte_pktmbuf_read(ut_params->obuf,
5667 (tdata->digest.offset_bytes == 0 ?
5668 plaintext_pad_len : tdata->digest.offset_bytes),
5669 tdata->digest.len, digest_buffer);
5671 digest = rte_pktmbuf_read(ut_params->ibuf,
5672 (tdata->digest.offset_bytes == 0 ?
5673 plaintext_pad_len : tdata->digest.offset_bytes),
5674 tdata->digest.len, digest_buffer);
5676 debug_hexdump(stdout, "digest:", digest,
5678 debug_hexdump(stdout, "digest expected:",
5679 tdata->digest.data, tdata->digest.len);
5684 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5686 tdata->plaintext.data,
5687 tdata->plaintext.len >> 3,
5688 "KASUMI Plaintext data not as expected");
5690 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5692 tdata->ciphertext.data,
5693 tdata->validDataLenInBits.len,
5694 "KASUMI Ciphertext data not as expected");
5696 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5699 DIGEST_BYTE_LENGTH_KASUMI_F9,
5700 "KASUMI Generated auth tag not as expected");
5706 test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
5708 struct crypto_testsuite_params *ts_params = &testsuite_params;
5709 struct crypto_unittest_params *ut_params = &unittest_params;
5713 uint8_t *plaintext, *ciphertext;
5714 unsigned plaintext_pad_len;
5715 unsigned plaintext_len;
5716 struct rte_cryptodev_info dev_info;
5718 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5719 uint64_t feat_flags = dev_info.feature_flags;
5721 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5722 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5723 printf("Device doesn't support RAW data-path APIs.\n");
5724 return TEST_SKIPPED;
5727 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5728 return TEST_SKIPPED;
5730 /* Verify the capabilities */
5731 struct rte_cryptodev_sym_capability_idx cap_idx;
5732 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5733 cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5734 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5736 return TEST_SKIPPED;
5737 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5738 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5739 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5741 return TEST_SKIPPED;
5743 /* Create KASUMI session */
5744 retval = create_wireless_algo_cipher_auth_session(
5745 ts_params->valid_devs[0],
5746 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5747 RTE_CRYPTO_AUTH_OP_GENERATE,
5748 RTE_CRYPTO_AUTH_KASUMI_F9,
5749 RTE_CRYPTO_CIPHER_KASUMI_F8,
5750 tdata->key.data, tdata->key.len,
5751 0, tdata->digest.len,
5752 tdata->cipher_iv.len);
5756 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5758 /* clear mbuf payload */
5759 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5760 rte_pktmbuf_tailroom(ut_params->ibuf));
5762 plaintext_len = ceil_byte_length(tdata->plaintext.len);
5763 /* Append data which is padded to a multiple of */
5764 /* the algorithms block size */
5765 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5766 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5768 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5770 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5772 /* Create KASUMI operation */
5773 retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
5774 tdata->digest.len, NULL, 0,
5775 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
5776 tdata->cipher_iv.data, tdata->cipher_iv.len,
5777 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
5778 tdata->validCipherOffsetInBits.len,
5779 tdata->validAuthLenInBits.len,
5785 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5786 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5787 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5789 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5791 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5793 if (ut_params->op->sym->m_dst)
5794 ut_params->obuf = ut_params->op->sym->m_dst;
5796 ut_params->obuf = ut_params->op->sym->m_src;
5798 ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
5799 tdata->validCipherOffsetInBits.len >> 3);
5801 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5802 + plaintext_pad_len;
5804 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
5805 (tdata->validCipherOffsetInBits.len >> 3);
5807 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5809 reference_ciphertext,
5810 tdata->validCipherLenInBits.len,
5811 "KASUMI Ciphertext data not as expected");
5814 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5817 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5818 "KASUMI Generated auth tag not as expected");
5823 test_zuc_encryption(const struct wireless_test_data *tdata)
5825 struct crypto_testsuite_params *ts_params = &testsuite_params;
5826 struct crypto_unittest_params *ut_params = &unittest_params;
5829 uint8_t *plaintext, *ciphertext;
5830 unsigned plaintext_pad_len;
5831 unsigned plaintext_len;
5832 struct rte_cryptodev_info dev_info;
5834 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5835 uint64_t feat_flags = dev_info.feature_flags;
5837 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5838 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5839 printf("Device doesn't support RAW data-path APIs.\n");
5840 return TEST_SKIPPED;
5843 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5844 return TEST_SKIPPED;
5846 struct rte_cryptodev_sym_capability_idx cap_idx;
5848 /* Check if device supports ZUC EEA3 */
5849 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5850 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
5852 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5854 return TEST_SKIPPED;
5856 /* Create ZUC session */
5857 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
5858 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5859 RTE_CRYPTO_CIPHER_ZUC_EEA3,
5860 tdata->key.data, tdata->key.len,
5861 tdata->cipher_iv.len);
5865 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5867 /* Clear mbuf payload */
5868 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5869 rte_pktmbuf_tailroom(ut_params->ibuf));
5871 plaintext_len = ceil_byte_length(tdata->plaintext.len);
5872 /* Append data which is padded to a multiple */
5873 /* of the algorithms block size */
5874 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
5875 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5877 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5879 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5881 /* Create ZUC operation */
5882 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
5883 tdata->cipher_iv.len,
5884 tdata->plaintext.len,
5889 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5890 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5891 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
5893 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5895 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5897 ut_params->obuf = ut_params->op->sym->m_dst;
5898 if (ut_params->obuf)
5899 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
5901 ciphertext = plaintext;
5903 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
5906 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5908 tdata->ciphertext.data,
5909 tdata->validCipherLenInBits.len,
5910 "ZUC Ciphertext data not as expected");
5915 test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
5917 struct crypto_testsuite_params *ts_params = &testsuite_params;
5918 struct crypto_unittest_params *ut_params = &unittest_params;
5922 unsigned int plaintext_pad_len;
5923 unsigned int plaintext_len;
5924 const uint8_t *ciphertext;
5925 uint8_t ciphertext_buffer[2048];
5926 struct rte_cryptodev_info dev_info;
5928 struct rte_cryptodev_sym_capability_idx cap_idx;
5930 /* Check if device supports ZUC EEA3 */
5931 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5932 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
5934 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5936 return TEST_SKIPPED;
5938 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5939 return TEST_SKIPPED;
5941 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5943 uint64_t feat_flags = dev_info.feature_flags;
5945 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5946 printf("Device doesn't support in-place scatter-gather. "
5948 return TEST_SKIPPED;
5951 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5952 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5953 printf("Device doesn't support RAW data-path APIs.\n");
5954 return TEST_SKIPPED;
5957 plaintext_len = ceil_byte_length(tdata->plaintext.len);
5959 /* Append data which is padded to a multiple */
5960 /* of the algorithms block size */
5961 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
5963 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5964 plaintext_pad_len, 10, 0);
5966 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5967 tdata->plaintext.data);
5969 /* Create ZUC session */
5970 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
5971 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5972 RTE_CRYPTO_CIPHER_ZUC_EEA3,
5973 tdata->key.data, tdata->key.len,
5974 tdata->cipher_iv.len);
5978 /* Clear mbuf payload */
5980 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
5982 /* Create ZUC operation */
5983 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
5984 tdata->cipher_iv.len, tdata->plaintext.len,
5989 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5990 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5991 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
5993 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5995 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5997 ut_params->obuf = ut_params->op->sym->m_dst;
5998 if (ut_params->obuf)
5999 ciphertext = rte_pktmbuf_read(ut_params->obuf,
6000 0, plaintext_len, ciphertext_buffer);
6002 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
6003 0, plaintext_len, ciphertext_buffer);
6006 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
6009 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6011 tdata->ciphertext.data,
6012 tdata->validCipherLenInBits.len,
6013 "ZUC Ciphertext data not as expected");
6019 test_zuc_authentication(const struct wireless_test_data *tdata)
6021 struct crypto_testsuite_params *ts_params = &testsuite_params;
6022 struct crypto_unittest_params *ut_params = &unittest_params;
6025 unsigned plaintext_pad_len;
6026 unsigned plaintext_len;
6029 struct rte_cryptodev_sym_capability_idx cap_idx;
6030 struct rte_cryptodev_info dev_info;
6032 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6033 uint64_t feat_flags = dev_info.feature_flags;
6035 if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
6036 (tdata->validAuthLenInBits.len % 8 != 0)) {
6037 printf("Device doesn't support NON-Byte Aligned Data.\n");
6038 return TEST_SKIPPED;
6041 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6042 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6043 printf("Device doesn't support RAW data-path APIs.\n");
6044 return TEST_SKIPPED;
6047 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
6048 return TEST_SKIPPED;
6050 /* Check if device supports ZUC EIA3 */
6051 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6052 cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
6054 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
6056 return TEST_SKIPPED;
6058 /* Create ZUC session */
6059 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
6060 tdata->key.data, tdata->key.len,
6061 tdata->auth_iv.len, tdata->digest.len,
6062 RTE_CRYPTO_AUTH_OP_GENERATE,
6063 RTE_CRYPTO_AUTH_ZUC_EIA3);
6067 /* alloc mbuf and set payload */
6068 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6070 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6071 rte_pktmbuf_tailroom(ut_params->ibuf));
6073 plaintext_len = ceil_byte_length(tdata->plaintext.len);
6074 /* Append data which is padded to a multiple of */
6075 /* the algorithms block size */
6076 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
6077 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6079 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6081 /* Create ZUC operation */
6082 retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
6083 tdata->auth_iv.data, tdata->auth_iv.len,
6084 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
6085 tdata->validAuthLenInBits.len,
6090 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6091 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6092 ut_params->op, 0, 1, 1, 0);
6094 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6096 ut_params->obuf = ut_params->op->sym->m_src;
6097 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6098 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
6099 + plaintext_pad_len;
6102 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6106 "ZUC Generated auth tag not as expected");
6112 test_zuc_auth_cipher(const struct wireless_test_data *tdata,
6113 uint8_t op_mode, uint8_t verify)
6115 struct crypto_testsuite_params *ts_params = &testsuite_params;
6116 struct crypto_unittest_params *ut_params = &unittest_params;
6120 uint8_t *plaintext = NULL, *ciphertext = NULL;
6121 unsigned int plaintext_pad_len;
6122 unsigned int plaintext_len;
6123 unsigned int ciphertext_pad_len;
6124 unsigned int ciphertext_len;
6126 struct rte_cryptodev_info dev_info;
6127 struct rte_cryptodev_sym_capability_idx cap_idx;
6129 /* Check if device supports ZUC EIA3 */
6130 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6131 cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
6133 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
6135 return TEST_SKIPPED;
6137 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6139 uint64_t feat_flags = dev_info.feature_flags;
6141 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6142 printf("Device doesn't support digest encrypted.\n");
6143 return TEST_SKIPPED;
6145 if (op_mode == IN_PLACE) {
6146 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6147 printf("Device doesn't support in-place scatter-gather "
6148 "in both input and output mbufs.\n");
6149 return TEST_SKIPPED;
6152 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6153 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6154 printf("Device doesn't support RAW data-path APIs.\n");
6155 return TEST_SKIPPED;
6158 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6159 return TEST_SKIPPED;
6160 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
6161 printf("Device doesn't support out-of-place scatter-gather "
6162 "in both input and output mbufs.\n");
6163 return TEST_SKIPPED;
6167 /* Create ZUC session */
6168 retval = create_wireless_algo_auth_cipher_session(
6169 ts_params->valid_devs[0],
6170 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
6171 : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
6172 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
6173 : RTE_CRYPTO_AUTH_OP_GENERATE),
6174 RTE_CRYPTO_AUTH_ZUC_EIA3,
6175 RTE_CRYPTO_CIPHER_ZUC_EEA3,
6176 tdata->key.data, tdata->key.len,
6177 tdata->auth_iv.len, tdata->digest.len,
6178 tdata->cipher_iv.len);
6183 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6184 if (op_mode == OUT_OF_PLACE)
6185 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6187 /* clear mbuf payload */
6188 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6189 rte_pktmbuf_tailroom(ut_params->ibuf));
6190 if (op_mode == OUT_OF_PLACE)
6191 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
6192 rte_pktmbuf_tailroom(ut_params->obuf));
6194 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
6195 plaintext_len = ceil_byte_length(tdata->plaintext.len);
6196 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6197 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6200 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6201 ciphertext_pad_len);
6202 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
6203 if (op_mode == OUT_OF_PLACE)
6204 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
6205 debug_hexdump(stdout, "ciphertext:", ciphertext,
6208 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6210 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6211 if (op_mode == OUT_OF_PLACE)
6212 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
6213 debug_hexdump(stdout, "plaintext:", plaintext,
6217 /* Create ZUC operation */
6218 retval = create_wireless_algo_auth_cipher_operation(
6219 tdata->digest.data, tdata->digest.len,
6220 tdata->cipher_iv.data, tdata->cipher_iv.len,
6221 tdata->auth_iv.data, tdata->auth_iv.len,
6222 (tdata->digest.offset_bytes == 0 ?
6223 (verify ? ciphertext_pad_len : plaintext_pad_len)
6224 : tdata->digest.offset_bytes),
6225 tdata->validCipherLenInBits.len,
6226 tdata->validCipherOffsetInBits.len,
6227 tdata->validAuthLenInBits.len,
6229 op_mode, 0, verify);
6234 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6235 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6236 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
6238 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6241 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6243 ut_params->obuf = (op_mode == IN_PLACE ?
6244 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6248 if (ut_params->obuf)
6249 plaintext = rte_pktmbuf_mtod(ut_params->obuf,
6252 plaintext = ciphertext;
6254 debug_hexdump(stdout, "plaintext:", plaintext,
6255 (tdata->plaintext.len >> 3) - tdata->digest.len);
6256 debug_hexdump(stdout, "plaintext expected:",
6257 tdata->plaintext.data,
6258 (tdata->plaintext.len >> 3) - tdata->digest.len);
6260 if (ut_params->obuf)
6261 ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
6264 ciphertext = plaintext;
6266 debug_hexdump(stdout, "ciphertext:", ciphertext,
6268 debug_hexdump(stdout, "ciphertext expected:",
6269 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
6271 ut_params->digest = rte_pktmbuf_mtod(
6272 ut_params->obuf, uint8_t *) +
6273 (tdata->digest.offset_bytes == 0 ?
6274 plaintext_pad_len : tdata->digest.offset_bytes);
6276 debug_hexdump(stdout, "digest:", ut_params->digest,
6278 debug_hexdump(stdout, "digest expected:",
6279 tdata->digest.data, tdata->digest.len);
6284 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6286 tdata->plaintext.data,
6287 tdata->plaintext.len >> 3,
6288 "ZUC Plaintext data not as expected");
6290 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6292 tdata->ciphertext.data,
6293 tdata->ciphertext.len >> 3,
6294 "ZUC Ciphertext data not as expected");
6296 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6299 DIGEST_BYTE_LENGTH_KASUMI_F9,
6300 "ZUC Generated auth tag not as expected");
6306 test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata,
6307 uint8_t op_mode, uint8_t verify)
6309 struct crypto_testsuite_params *ts_params = &testsuite_params;
6310 struct crypto_unittest_params *ut_params = &unittest_params;
6314 const uint8_t *plaintext = NULL;
6315 const uint8_t *ciphertext = NULL;
6316 const uint8_t *digest = NULL;
6317 unsigned int plaintext_pad_len;
6318 unsigned int plaintext_len;
6319 unsigned int ciphertext_pad_len;
6320 unsigned int ciphertext_len;
6321 uint8_t buffer[10000];
6322 uint8_t digest_buffer[10000];
6324 struct rte_cryptodev_info dev_info;
6325 struct rte_cryptodev_sym_capability_idx cap_idx;
6327 /* Check if device supports ZUC EIA3 */
6328 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6329 cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
6331 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
6333 return TEST_SKIPPED;
6335 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6337 uint64_t feat_flags = dev_info.feature_flags;
6339 if (op_mode == IN_PLACE) {
6340 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6341 printf("Device doesn't support in-place scatter-gather "
6342 "in both input and output mbufs.\n");
6343 return TEST_SKIPPED;
6346 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6347 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6348 printf("Device doesn't support RAW data-path APIs.\n");
6349 return TEST_SKIPPED;
6352 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6353 return TEST_SKIPPED;
6354 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
6355 printf("Device doesn't support out-of-place scatter-gather "
6356 "in both input and output mbufs.\n");
6357 return TEST_SKIPPED;
6359 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6360 printf("Device doesn't support digest encrypted.\n");
6361 return TEST_SKIPPED;
6365 /* Create ZUC session */
6366 retval = create_wireless_algo_auth_cipher_session(
6367 ts_params->valid_devs[0],
6368 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
6369 : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
6370 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
6371 : RTE_CRYPTO_AUTH_OP_GENERATE),
6372 RTE_CRYPTO_AUTH_ZUC_EIA3,
6373 RTE_CRYPTO_CIPHER_ZUC_EEA3,
6374 tdata->key.data, tdata->key.len,
6375 tdata->auth_iv.len, tdata->digest.len,
6376 tdata->cipher_iv.len);
6381 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
6382 plaintext_len = ceil_byte_length(tdata->plaintext.len);
6383 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6384 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6386 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
6387 plaintext_pad_len, 15, 0);
6388 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
6389 "Failed to allocate input buffer in mempool");
6391 if (op_mode == OUT_OF_PLACE) {
6392 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
6393 plaintext_pad_len, 15, 0);
6394 TEST_ASSERT_NOT_NULL(ut_params->obuf,
6395 "Failed to allocate output buffer in mempool");
6399 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
6400 tdata->ciphertext.data);
6401 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6402 ciphertext_len, buffer);
6403 debug_hexdump(stdout, "ciphertext:", ciphertext,
6406 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
6407 tdata->plaintext.data);
6408 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6409 plaintext_len, buffer);
6410 debug_hexdump(stdout, "plaintext:", plaintext,
6413 memset(buffer, 0, sizeof(buffer));
6415 /* Create ZUC operation */
6416 retval = create_wireless_algo_auth_cipher_operation(
6417 tdata->digest.data, tdata->digest.len,
6418 tdata->cipher_iv.data, tdata->cipher_iv.len,
6420 (tdata->digest.offset_bytes == 0 ?
6421 (verify ? ciphertext_pad_len : plaintext_pad_len)
6422 : tdata->digest.offset_bytes),
6423 tdata->validCipherLenInBits.len,
6424 tdata->validCipherOffsetInBits.len,
6425 tdata->validAuthLenInBits.len,
6427 op_mode, 1, verify);
6432 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6433 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6434 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
6436 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6439 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6441 ut_params->obuf = (op_mode == IN_PLACE ?
6442 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6445 if (ut_params->obuf)
6446 plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
6447 plaintext_len, buffer);
6449 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6450 plaintext_len, buffer);
6452 debug_hexdump(stdout, "plaintext:", plaintext,
6453 (tdata->plaintext.len >> 3) - tdata->digest.len);
6454 debug_hexdump(stdout, "plaintext expected:",
6455 tdata->plaintext.data,
6456 (tdata->plaintext.len >> 3) - tdata->digest.len);
6458 if (ut_params->obuf)
6459 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
6460 ciphertext_len, buffer);
6462 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6463 ciphertext_len, buffer);
6465 debug_hexdump(stdout, "ciphertext:", ciphertext,
6467 debug_hexdump(stdout, "ciphertext expected:",
6468 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
6470 if (ut_params->obuf)
6471 digest = rte_pktmbuf_read(ut_params->obuf,
6472 (tdata->digest.offset_bytes == 0 ?
6473 plaintext_pad_len : tdata->digest.offset_bytes),
6474 tdata->digest.len, digest_buffer);
6476 digest = rte_pktmbuf_read(ut_params->ibuf,
6477 (tdata->digest.offset_bytes == 0 ?
6478 plaintext_pad_len : tdata->digest.offset_bytes),
6479 tdata->digest.len, digest_buffer);
6481 debug_hexdump(stdout, "digest:", digest,
6483 debug_hexdump(stdout, "digest expected:",
6484 tdata->digest.data, tdata->digest.len);
6489 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6491 tdata->plaintext.data,
6492 tdata->plaintext.len >> 3,
6493 "ZUC Plaintext data not as expected");
6495 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6497 tdata->ciphertext.data,
6498 tdata->validDataLenInBits.len,
6499 "ZUC Ciphertext data not as expected");
6501 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6504 DIGEST_BYTE_LENGTH_KASUMI_F9,
6505 "ZUC Generated auth tag not as expected");
6511 test_kasumi_encryption_test_case_1(void)
6513 return test_kasumi_encryption(&kasumi_test_case_1);
6517 test_kasumi_encryption_test_case_1_sgl(void)
6519 return test_kasumi_encryption_sgl(&kasumi_test_case_1);
6523 test_kasumi_encryption_test_case_1_oop(void)
6525 return test_kasumi_encryption_oop(&kasumi_test_case_1);
6529 test_kasumi_encryption_test_case_1_oop_sgl(void)
6531 return test_kasumi_encryption_oop_sgl(&kasumi_test_case_1);
6535 test_kasumi_encryption_test_case_2(void)
6537 return test_kasumi_encryption(&kasumi_test_case_2);
6541 test_kasumi_encryption_test_case_3(void)
6543 return test_kasumi_encryption(&kasumi_test_case_3);
6547 test_kasumi_encryption_test_case_4(void)
6549 return test_kasumi_encryption(&kasumi_test_case_4);
6553 test_kasumi_encryption_test_case_5(void)
6555 return test_kasumi_encryption(&kasumi_test_case_5);
6559 test_kasumi_decryption_test_case_1(void)
6561 return test_kasumi_decryption(&kasumi_test_case_1);
6565 test_kasumi_decryption_test_case_1_oop(void)
6567 return test_kasumi_decryption_oop(&kasumi_test_case_1);
6571 test_kasumi_decryption_test_case_2(void)
6573 return test_kasumi_decryption(&kasumi_test_case_2);
6577 test_kasumi_decryption_test_case_3(void)
6579 /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6580 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6581 return TEST_SKIPPED;
6582 return test_kasumi_decryption(&kasumi_test_case_3);
6586 test_kasumi_decryption_test_case_4(void)
6588 return test_kasumi_decryption(&kasumi_test_case_4);
6592 test_kasumi_decryption_test_case_5(void)
6594 return test_kasumi_decryption(&kasumi_test_case_5);
6597 test_snow3g_encryption_test_case_1(void)
6599 return test_snow3g_encryption(&snow3g_test_case_1);
6603 test_snow3g_encryption_test_case_1_oop(void)
6605 return test_snow3g_encryption_oop(&snow3g_test_case_1);
6609 test_snow3g_encryption_test_case_1_oop_sgl(void)
6611 return test_snow3g_encryption_oop_sgl(&snow3g_test_case_1);
6616 test_snow3g_encryption_test_case_1_offset_oop(void)
6618 return test_snow3g_encryption_offset_oop(&snow3g_test_case_1);
6622 test_snow3g_encryption_test_case_2(void)
6624 return test_snow3g_encryption(&snow3g_test_case_2);
6628 test_snow3g_encryption_test_case_3(void)
6630 return test_snow3g_encryption(&snow3g_test_case_3);
6634 test_snow3g_encryption_test_case_4(void)
6636 return test_snow3g_encryption(&snow3g_test_case_4);
6640 test_snow3g_encryption_test_case_5(void)
6642 return test_snow3g_encryption(&snow3g_test_case_5);
6646 test_snow3g_decryption_test_case_1(void)
6648 return test_snow3g_decryption(&snow3g_test_case_1);
6652 test_snow3g_decryption_test_case_1_oop(void)
6654 return test_snow3g_decryption_oop(&snow3g_test_case_1);
6658 test_snow3g_decryption_test_case_2(void)
6660 return test_snow3g_decryption(&snow3g_test_case_2);
6664 test_snow3g_decryption_test_case_3(void)
6666 return test_snow3g_decryption(&snow3g_test_case_3);
6670 test_snow3g_decryption_test_case_4(void)
6672 return test_snow3g_decryption(&snow3g_test_case_4);
6676 test_snow3g_decryption_test_case_5(void)
6678 return test_snow3g_decryption(&snow3g_test_case_5);
6682 * Function prepares snow3g_hash_test_data from snow3g_test_data.
6683 * Pattern digest from snow3g_test_data must be allocated as
6684 * 4 last bytes in plaintext.
6687 snow3g_hash_test_vector_setup(const struct snow3g_test_data *pattern,
6688 struct snow3g_hash_test_data *output)
6690 if ((pattern != NULL) && (output != NULL)) {
6691 output->key.len = pattern->key.len;
6693 memcpy(output->key.data,
6694 pattern->key.data, pattern->key.len);
6696 output->auth_iv.len = pattern->auth_iv.len;
6698 memcpy(output->auth_iv.data,
6699 pattern->auth_iv.data, pattern->auth_iv.len);
6701 output->plaintext.len = pattern->plaintext.len;
6703 memcpy(output->plaintext.data,
6704 pattern->plaintext.data, pattern->plaintext.len >> 3);
6706 output->digest.len = pattern->digest.len;
6708 memcpy(output->digest.data,
6709 &pattern->plaintext.data[pattern->digest.offset_bytes],
6710 pattern->digest.len);
6712 output->validAuthLenInBits.len =
6713 pattern->validAuthLenInBits.len;
6718 * Test case verify computed cipher and digest from snow3g_test_case_7 data.
6721 test_snow3g_decryption_with_digest_test_case_1(void)
6723 struct snow3g_hash_test_data snow3g_hash_data;
6724 struct rte_cryptodev_info dev_info;
6725 struct crypto_testsuite_params *ts_params = &testsuite_params;
6727 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6728 uint64_t feat_flags = dev_info.feature_flags;
6730 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6731 printf("Device doesn't support encrypted digest operations.\n");
6732 return TEST_SKIPPED;
6736 * Function prepare data for hash veryfication test case.
6737 * Digest is allocated in 4 last bytes in plaintext, pattern.
6739 snow3g_hash_test_vector_setup(&snow3g_test_case_7, &snow3g_hash_data);
6741 return test_snow3g_decryption(&snow3g_test_case_7) &
6742 test_snow3g_authentication_verify(&snow3g_hash_data);
6746 test_snow3g_cipher_auth_test_case_1(void)
6748 return test_snow3g_cipher_auth(&snow3g_test_case_3);
6752 test_snow3g_auth_cipher_test_case_1(void)
6754 return test_snow3g_auth_cipher(
6755 &snow3g_auth_cipher_test_case_1, IN_PLACE, 0);
6759 test_snow3g_auth_cipher_test_case_2(void)
6761 return test_snow3g_auth_cipher(
6762 &snow3g_auth_cipher_test_case_2, IN_PLACE, 0);
6766 test_snow3g_auth_cipher_test_case_2_oop(void)
6768 return test_snow3g_auth_cipher(
6769 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
6773 test_snow3g_auth_cipher_part_digest_enc(void)
6775 return test_snow3g_auth_cipher(
6776 &snow3g_auth_cipher_partial_digest_encryption,
6781 test_snow3g_auth_cipher_part_digest_enc_oop(void)
6783 return test_snow3g_auth_cipher(
6784 &snow3g_auth_cipher_partial_digest_encryption,
6789 test_snow3g_auth_cipher_test_case_3_sgl(void)
6791 /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6792 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6793 return TEST_SKIPPED;
6794 return test_snow3g_auth_cipher_sgl(
6795 &snow3g_auth_cipher_test_case_3, IN_PLACE, 0);
6799 test_snow3g_auth_cipher_test_case_3_oop_sgl(void)
6801 return test_snow3g_auth_cipher_sgl(
6802 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 0);
6806 test_snow3g_auth_cipher_part_digest_enc_sgl(void)
6808 /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6809 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6810 return TEST_SKIPPED;
6811 return test_snow3g_auth_cipher_sgl(
6812 &snow3g_auth_cipher_partial_digest_encryption,
6817 test_snow3g_auth_cipher_part_digest_enc_oop_sgl(void)
6819 return test_snow3g_auth_cipher_sgl(
6820 &snow3g_auth_cipher_partial_digest_encryption,
6825 test_snow3g_auth_cipher_verify_test_case_1(void)
6827 return test_snow3g_auth_cipher(
6828 &snow3g_auth_cipher_test_case_1, IN_PLACE, 1);
6832 test_snow3g_auth_cipher_verify_test_case_2(void)
6834 return test_snow3g_auth_cipher(
6835 &snow3g_auth_cipher_test_case_2, IN_PLACE, 1);
6839 test_snow3g_auth_cipher_verify_test_case_2_oop(void)
6841 return test_snow3g_auth_cipher(
6842 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
6846 test_snow3g_auth_cipher_verify_part_digest_enc(void)
6848 return test_snow3g_auth_cipher(
6849 &snow3g_auth_cipher_partial_digest_encryption,
6854 test_snow3g_auth_cipher_verify_part_digest_enc_oop(void)
6856 return test_snow3g_auth_cipher(
6857 &snow3g_auth_cipher_partial_digest_encryption,
6862 test_snow3g_auth_cipher_verify_test_case_3_sgl(void)
6864 return test_snow3g_auth_cipher_sgl(
6865 &snow3g_auth_cipher_test_case_3, IN_PLACE, 1);
6869 test_snow3g_auth_cipher_verify_test_case_3_oop_sgl(void)
6871 return test_snow3g_auth_cipher_sgl(
6872 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 1);
6876 test_snow3g_auth_cipher_verify_part_digest_enc_sgl(void)
6878 return test_snow3g_auth_cipher_sgl(
6879 &snow3g_auth_cipher_partial_digest_encryption,
6884 test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl(void)
6886 return test_snow3g_auth_cipher_sgl(
6887 &snow3g_auth_cipher_partial_digest_encryption,
6892 test_snow3g_auth_cipher_with_digest_test_case_1(void)
6894 return test_snow3g_auth_cipher(
6895 &snow3g_test_case_7, IN_PLACE, 0);
6899 test_kasumi_auth_cipher_test_case_1(void)
6901 return test_kasumi_auth_cipher(
6902 &kasumi_test_case_3, IN_PLACE, 0);
6906 test_kasumi_auth_cipher_test_case_2(void)
6908 return test_kasumi_auth_cipher(
6909 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
6913 test_kasumi_auth_cipher_test_case_2_oop(void)
6915 return test_kasumi_auth_cipher(
6916 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
6920 test_kasumi_auth_cipher_test_case_2_sgl(void)
6922 return test_kasumi_auth_cipher_sgl(
6923 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
6927 test_kasumi_auth_cipher_test_case_2_oop_sgl(void)
6929 return test_kasumi_auth_cipher_sgl(
6930 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
6934 test_kasumi_auth_cipher_verify_test_case_1(void)
6936 return test_kasumi_auth_cipher(
6937 &kasumi_test_case_3, IN_PLACE, 1);
6941 test_kasumi_auth_cipher_verify_test_case_2(void)
6943 return test_kasumi_auth_cipher(
6944 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
6948 test_kasumi_auth_cipher_verify_test_case_2_oop(void)
6950 return test_kasumi_auth_cipher(
6951 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
6955 test_kasumi_auth_cipher_verify_test_case_2_sgl(void)
6957 return test_kasumi_auth_cipher_sgl(
6958 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
6962 test_kasumi_auth_cipher_verify_test_case_2_oop_sgl(void)
6964 return test_kasumi_auth_cipher_sgl(
6965 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
6969 test_kasumi_cipher_auth_test_case_1(void)
6971 return test_kasumi_cipher_auth(&kasumi_test_case_6);
6975 test_zuc_encryption_test_case_1(void)
6977 return test_zuc_encryption(&zuc_test_case_cipher_193b);
6981 test_zuc_encryption_test_case_2(void)
6983 return test_zuc_encryption(&zuc_test_case_cipher_800b);
6987 test_zuc_encryption_test_case_3(void)
6989 return test_zuc_encryption(&zuc_test_case_cipher_1570b);
6993 test_zuc_encryption_test_case_4(void)
6995 return test_zuc_encryption(&zuc_test_case_cipher_2798b);
6999 test_zuc_encryption_test_case_5(void)
7001 return test_zuc_encryption(&zuc_test_case_cipher_4019b);
7005 test_zuc_encryption_test_case_6_sgl(void)
7007 return test_zuc_encryption_sgl(&zuc_test_case_cipher_193b);
7011 test_zuc_hash_generate_test_case_1(void)
7013 return test_zuc_authentication(&zuc_test_case_auth_1b);
7017 test_zuc_hash_generate_test_case_2(void)
7019 return test_zuc_authentication(&zuc_test_case_auth_90b);
7023 test_zuc_hash_generate_test_case_3(void)
7025 return test_zuc_authentication(&zuc_test_case_auth_577b);
7029 test_zuc_hash_generate_test_case_4(void)
7031 return test_zuc_authentication(&zuc_test_case_auth_2079b);
7035 test_zuc_hash_generate_test_case_5(void)
7037 return test_zuc_authentication(&zuc_test_auth_5670b);
7041 test_zuc_hash_generate_test_case_6(void)
7043 return test_zuc_authentication(&zuc_test_case_auth_128b);
7047 test_zuc_hash_generate_test_case_7(void)
7049 return test_zuc_authentication(&zuc_test_case_auth_2080b);
7053 test_zuc_hash_generate_test_case_8(void)
7055 return test_zuc_authentication(&zuc_test_case_auth_584b);
7059 test_zuc_cipher_auth_test_case_1(void)
7061 return test_zuc_cipher_auth(&zuc_test_case_cipher_200b_auth_200b);
7065 test_zuc_cipher_auth_test_case_2(void)
7067 return test_zuc_cipher_auth(&zuc_test_case_cipher_800b_auth_120b);
7071 test_zuc_auth_cipher_test_case_1(void)
7073 return test_zuc_auth_cipher(
7074 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
7078 test_zuc_auth_cipher_test_case_1_oop(void)
7080 return test_zuc_auth_cipher(
7081 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
7085 test_zuc_auth_cipher_test_case_1_sgl(void)
7087 return test_zuc_auth_cipher_sgl(
7088 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
7092 test_zuc_auth_cipher_test_case_1_oop_sgl(void)
7094 return test_zuc_auth_cipher_sgl(
7095 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
7099 test_zuc_auth_cipher_verify_test_case_1(void)
7101 return test_zuc_auth_cipher(
7102 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
7106 test_zuc_auth_cipher_verify_test_case_1_oop(void)
7108 return test_zuc_auth_cipher(
7109 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
7113 test_zuc_auth_cipher_verify_test_case_1_sgl(void)
7115 return test_zuc_auth_cipher_sgl(
7116 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
7120 test_zuc_auth_cipher_verify_test_case_1_oop_sgl(void)
7122 return test_zuc_auth_cipher_sgl(
7123 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
7127 test_mixed_check_if_unsupported(const struct mixed_cipher_auth_test_data *tdata)
7129 uint8_t dev_id = testsuite_params.valid_devs[0];
7131 struct rte_cryptodev_sym_capability_idx cap_idx;
7133 /* Check if device supports particular cipher algorithm */
7134 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
7135 cap_idx.algo.cipher = tdata->cipher_algo;
7136 if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
7137 return TEST_SKIPPED;
7139 /* Check if device supports particular hash algorithm */
7140 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
7141 cap_idx.algo.auth = tdata->auth_algo;
7142 if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
7143 return TEST_SKIPPED;
7149 test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata,
7150 uint8_t op_mode, uint8_t verify)
7152 struct crypto_testsuite_params *ts_params = &testsuite_params;
7153 struct crypto_unittest_params *ut_params = &unittest_params;
7157 uint8_t *plaintext = NULL, *ciphertext = NULL;
7158 unsigned int plaintext_pad_len;
7159 unsigned int plaintext_len;
7160 unsigned int ciphertext_pad_len;
7161 unsigned int ciphertext_len;
7163 struct rte_cryptodev_info dev_info;
7164 struct rte_crypto_op *op;
7166 /* Check if device supports particular algorithms separately */
7167 if (test_mixed_check_if_unsupported(tdata))
7168 return TEST_SKIPPED;
7169 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
7170 return TEST_SKIPPED;
7172 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
7174 uint64_t feat_flags = dev_info.feature_flags;
7176 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
7177 printf("Device doesn't support digest encrypted.\n");
7178 return TEST_SKIPPED;
7181 /* Create the session */
7183 retval = create_wireless_algo_cipher_auth_session(
7184 ts_params->valid_devs[0],
7185 RTE_CRYPTO_CIPHER_OP_DECRYPT,
7186 RTE_CRYPTO_AUTH_OP_VERIFY,
7189 tdata->auth_key.data, tdata->auth_key.len,
7190 tdata->auth_iv.len, tdata->digest_enc.len,
7191 tdata->cipher_iv.len);
7193 retval = create_wireless_algo_auth_cipher_session(
7194 ts_params->valid_devs[0],
7195 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7196 RTE_CRYPTO_AUTH_OP_GENERATE,
7199 tdata->auth_key.data, tdata->auth_key.len,
7200 tdata->auth_iv.len, tdata->digest_enc.len,
7201 tdata->cipher_iv.len);
7205 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7206 if (op_mode == OUT_OF_PLACE)
7207 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7209 /* clear mbuf payload */
7210 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7211 rte_pktmbuf_tailroom(ut_params->ibuf));
7212 if (op_mode == OUT_OF_PLACE) {
7214 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
7215 rte_pktmbuf_tailroom(ut_params->obuf));
7218 ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
7219 plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
7220 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
7221 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
7224 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7225 ciphertext_pad_len);
7226 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
7227 if (op_mode == OUT_OF_PLACE)
7228 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
7229 debug_hexdump(stdout, "ciphertext:", ciphertext,
7232 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7234 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
7235 if (op_mode == OUT_OF_PLACE)
7236 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
7237 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
7240 /* Create the operation */
7241 retval = create_wireless_algo_auth_cipher_operation(
7242 tdata->digest_enc.data, tdata->digest_enc.len,
7243 tdata->cipher_iv.data, tdata->cipher_iv.len,
7244 tdata->auth_iv.data, tdata->auth_iv.len,
7245 (tdata->digest_enc.offset == 0 ?
7247 : tdata->digest_enc.offset),
7248 tdata->validCipherLen.len_bits,
7249 tdata->cipher.offset_bits,
7250 tdata->validAuthLen.len_bits,
7251 tdata->auth.offset_bits,
7252 op_mode, 0, verify);
7257 op = process_crypto_request(ts_params->valid_devs[0], ut_params->op);
7259 /* Check if the op failed because the device doesn't */
7260 /* support this particular combination of algorithms */
7261 if (op == NULL && ut_params->op->status ==
7262 RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
7263 printf("Device doesn't support this mixed combination. "
7265 return TEST_SKIPPED;
7269 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
7271 ut_params->obuf = (op_mode == IN_PLACE ?
7272 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
7275 if (ut_params->obuf)
7276 plaintext = rte_pktmbuf_mtod(ut_params->obuf,
7279 plaintext = ciphertext +
7280 (tdata->cipher.offset_bits >> 3);
7282 debug_hexdump(stdout, "plaintext:", plaintext,
7283 tdata->plaintext.len_bits >> 3);
7284 debug_hexdump(stdout, "plaintext expected:",
7285 tdata->plaintext.data,
7286 tdata->plaintext.len_bits >> 3);
7288 if (ut_params->obuf)
7289 ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
7292 ciphertext = plaintext;
7294 debug_hexdump(stdout, "ciphertext:", ciphertext,
7296 debug_hexdump(stdout, "ciphertext expected:",
7297 tdata->ciphertext.data,
7298 tdata->ciphertext.len_bits >> 3);
7300 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
7301 + (tdata->digest_enc.offset == 0 ?
7302 plaintext_pad_len : tdata->digest_enc.offset);
7304 debug_hexdump(stdout, "digest:", ut_params->digest,
7305 tdata->digest_enc.len);
7306 debug_hexdump(stdout, "digest expected:",
7307 tdata->digest_enc.data,
7308 tdata->digest_enc.len);
7313 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7315 tdata->plaintext.data,
7316 tdata->plaintext.len_bits >> 3,
7317 "Plaintext data not as expected");
7319 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7321 tdata->ciphertext.data,
7322 tdata->validDataLen.len_bits,
7323 "Ciphertext data not as expected");
7325 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7327 tdata->digest_enc.data,
7328 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
7329 "Generated auth tag not as expected");
7332 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7333 "crypto op processing failed");
7339 test_mixed_auth_cipher_sgl(const struct mixed_cipher_auth_test_data *tdata,
7340 uint8_t op_mode, uint8_t verify)
7342 struct crypto_testsuite_params *ts_params = &testsuite_params;
7343 struct crypto_unittest_params *ut_params = &unittest_params;
7347 const uint8_t *plaintext = NULL;
7348 const uint8_t *ciphertext = NULL;
7349 const uint8_t *digest = NULL;
7350 unsigned int plaintext_pad_len;
7351 unsigned int plaintext_len;
7352 unsigned int ciphertext_pad_len;
7353 unsigned int ciphertext_len;
7354 uint8_t buffer[10000];
7355 uint8_t digest_buffer[10000];
7357 struct rte_cryptodev_info dev_info;
7358 struct rte_crypto_op *op;
7360 /* Check if device supports particular algorithms */
7361 if (test_mixed_check_if_unsupported(tdata))
7362 return TEST_SKIPPED;
7363 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
7364 return TEST_SKIPPED;
7366 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
7368 uint64_t feat_flags = dev_info.feature_flags;
7370 if (op_mode == IN_PLACE) {
7371 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
7372 printf("Device doesn't support in-place scatter-gather "
7373 "in both input and output mbufs.\n");
7374 return TEST_SKIPPED;
7377 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
7378 printf("Device doesn't support out-of-place scatter-gather "
7379 "in both input and output mbufs.\n");
7380 return TEST_SKIPPED;
7382 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
7383 printf("Device doesn't support digest encrypted.\n");
7384 return TEST_SKIPPED;
7388 /* Create the session */
7390 retval = create_wireless_algo_cipher_auth_session(
7391 ts_params->valid_devs[0],
7392 RTE_CRYPTO_CIPHER_OP_DECRYPT,
7393 RTE_CRYPTO_AUTH_OP_VERIFY,
7396 tdata->auth_key.data, tdata->auth_key.len,
7397 tdata->auth_iv.len, tdata->digest_enc.len,
7398 tdata->cipher_iv.len);
7400 retval = create_wireless_algo_auth_cipher_session(
7401 ts_params->valid_devs[0],
7402 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7403 RTE_CRYPTO_AUTH_OP_GENERATE,
7406 tdata->auth_key.data, tdata->auth_key.len,
7407 tdata->auth_iv.len, tdata->digest_enc.len,
7408 tdata->cipher_iv.len);
7412 ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
7413 plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
7414 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
7415 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
7417 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
7418 ciphertext_pad_len, 15, 0);
7419 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
7420 "Failed to allocate input buffer in mempool");
7422 if (op_mode == OUT_OF_PLACE) {
7423 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
7424 plaintext_pad_len, 15, 0);
7425 TEST_ASSERT_NOT_NULL(ut_params->obuf,
7426 "Failed to allocate output buffer in mempool");
7430 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
7431 tdata->ciphertext.data);
7432 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
7433 ciphertext_len, buffer);
7434 debug_hexdump(stdout, "ciphertext:", ciphertext,
7437 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
7438 tdata->plaintext.data);
7439 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
7440 plaintext_len, buffer);
7441 debug_hexdump(stdout, "plaintext:", plaintext,
7444 memset(buffer, 0, sizeof(buffer));
7446 /* Create the operation */
7447 retval = create_wireless_algo_auth_cipher_operation(
7448 tdata->digest_enc.data, tdata->digest_enc.len,
7449 tdata->cipher_iv.data, tdata->cipher_iv.len,
7450 tdata->auth_iv.data, tdata->auth_iv.len,
7451 (tdata->digest_enc.offset == 0 ?
7453 : tdata->digest_enc.offset),
7454 tdata->validCipherLen.len_bits,
7455 tdata->cipher.offset_bits,
7456 tdata->validAuthLen.len_bits,
7457 tdata->auth.offset_bits,
7458 op_mode, 1, verify);
7463 op = process_crypto_request(ts_params->valid_devs[0], ut_params->op);
7465 /* Check if the op failed because the device doesn't */
7466 /* support this particular combination of algorithms */
7467 if (op == NULL && ut_params->op->status ==
7468 RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
7469 printf("Device doesn't support this mixed combination. "
7471 return TEST_SKIPPED;
7475 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
7477 ut_params->obuf = (op_mode == IN_PLACE ?
7478 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
7481 if (ut_params->obuf)
7482 plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
7483 plaintext_len, buffer);
7485 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
7486 plaintext_len, buffer);
7488 debug_hexdump(stdout, "plaintext:", plaintext,
7489 (tdata->plaintext.len_bits >> 3) -
7490 tdata->digest_enc.len);
7491 debug_hexdump(stdout, "plaintext expected:",
7492 tdata->plaintext.data,
7493 (tdata->plaintext.len_bits >> 3) -
7494 tdata->digest_enc.len);
7496 if (ut_params->obuf)
7497 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
7498 ciphertext_len, buffer);
7500 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
7501 ciphertext_len, buffer);
7503 debug_hexdump(stdout, "ciphertext:", ciphertext,
7505 debug_hexdump(stdout, "ciphertext expected:",
7506 tdata->ciphertext.data,
7507 tdata->ciphertext.len_bits >> 3);
7509 if (ut_params->obuf)
7510 digest = rte_pktmbuf_read(ut_params->obuf,
7511 (tdata->digest_enc.offset == 0 ?
7513 tdata->digest_enc.offset),
7514 tdata->digest_enc.len, digest_buffer);
7516 digest = rte_pktmbuf_read(ut_params->ibuf,
7517 (tdata->digest_enc.offset == 0 ?
7519 tdata->digest_enc.offset),
7520 tdata->digest_enc.len, digest_buffer);
7522 debug_hexdump(stdout, "digest:", digest,
7523 tdata->digest_enc.len);
7524 debug_hexdump(stdout, "digest expected:",
7525 tdata->digest_enc.data, tdata->digest_enc.len);
7530 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7532 tdata->plaintext.data,
7533 tdata->plaintext.len_bits >> 3,
7534 "Plaintext data not as expected");
7536 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7538 tdata->ciphertext.data,
7539 tdata->validDataLen.len_bits,
7540 "Ciphertext data not as expected");
7541 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7543 tdata->digest_enc.data,
7544 tdata->digest_enc.len,
7545 "Generated auth tag not as expected");
7548 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7549 "crypto op processing failed");
7554 /** AUTH AES CMAC + CIPHER AES CTR */
7557 test_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7559 return test_mixed_auth_cipher(
7560 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7564 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7566 return test_mixed_auth_cipher(
7567 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7571 test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7573 return test_mixed_auth_cipher_sgl(
7574 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7578 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7580 return test_mixed_auth_cipher_sgl(
7581 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7585 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7587 return test_mixed_auth_cipher(
7588 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7592 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7594 return test_mixed_auth_cipher(
7595 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7599 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7601 return test_mixed_auth_cipher_sgl(
7602 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7606 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7608 return test_mixed_auth_cipher_sgl(
7609 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7612 /** MIXED AUTH + CIPHER */
7615 test_auth_zuc_cipher_snow_test_case_1(void)
7617 return test_mixed_auth_cipher(
7618 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7622 test_verify_auth_zuc_cipher_snow_test_case_1(void)
7624 return test_mixed_auth_cipher(
7625 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7629 test_auth_aes_cmac_cipher_snow_test_case_1(void)
7631 return test_mixed_auth_cipher(
7632 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7636 test_verify_auth_aes_cmac_cipher_snow_test_case_1(void)
7638 return test_mixed_auth_cipher(
7639 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7643 test_auth_zuc_cipher_aes_ctr_test_case_1(void)
7645 return test_mixed_auth_cipher(
7646 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7650 test_verify_auth_zuc_cipher_aes_ctr_test_case_1(void)
7652 return test_mixed_auth_cipher(
7653 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7657 test_auth_snow_cipher_aes_ctr_test_case_1(void)
7659 return test_mixed_auth_cipher(
7660 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7664 test_verify_auth_snow_cipher_aes_ctr_test_case_1(void)
7666 return test_mixed_auth_cipher(
7667 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7671 test_auth_snow_cipher_zuc_test_case_1(void)
7673 return test_mixed_auth_cipher(
7674 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7678 test_verify_auth_snow_cipher_zuc_test_case_1(void)
7680 return test_mixed_auth_cipher(
7681 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7685 test_auth_aes_cmac_cipher_zuc_test_case_1(void)
7687 return test_mixed_auth_cipher(
7688 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7692 test_verify_auth_aes_cmac_cipher_zuc_test_case_1(void)
7694 return test_mixed_auth_cipher(
7695 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7699 test_auth_null_cipher_snow_test_case_1(void)
7701 return test_mixed_auth_cipher(
7702 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7706 test_verify_auth_null_cipher_snow_test_case_1(void)
7708 return test_mixed_auth_cipher(
7709 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7713 test_auth_null_cipher_zuc_test_case_1(void)
7715 return test_mixed_auth_cipher(
7716 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7720 test_verify_auth_null_cipher_zuc_test_case_1(void)
7722 return test_mixed_auth_cipher(
7723 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7727 test_auth_snow_cipher_null_test_case_1(void)
7729 return test_mixed_auth_cipher(
7730 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7734 test_verify_auth_snow_cipher_null_test_case_1(void)
7736 return test_mixed_auth_cipher(
7737 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7741 test_auth_zuc_cipher_null_test_case_1(void)
7743 return test_mixed_auth_cipher(
7744 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7748 test_verify_auth_zuc_cipher_null_test_case_1(void)
7750 return test_mixed_auth_cipher(
7751 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7755 test_auth_null_cipher_aes_ctr_test_case_1(void)
7757 return test_mixed_auth_cipher(
7758 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7762 test_verify_auth_null_cipher_aes_ctr_test_case_1(void)
7764 return test_mixed_auth_cipher(
7765 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7769 test_auth_aes_cmac_cipher_null_test_case_1(void)
7771 return test_mixed_auth_cipher(
7772 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7776 test_verify_auth_aes_cmac_cipher_null_test_case_1(void)
7778 return test_mixed_auth_cipher(
7779 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7782 /* ***** AEAD algorithm Tests ***** */
7785 create_aead_session(uint8_t dev_id, enum rte_crypto_aead_algorithm algo,
7786 enum rte_crypto_aead_operation op,
7787 const uint8_t *key, const uint8_t key_len,
7788 const uint16_t aad_len, const uint8_t auth_len,
7791 uint8_t aead_key[key_len];
7793 struct crypto_testsuite_params *ts_params = &testsuite_params;
7794 struct crypto_unittest_params *ut_params = &unittest_params;
7796 memcpy(aead_key, key, key_len);
7798 /* Setup AEAD Parameters */
7799 ut_params->aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD;
7800 ut_params->aead_xform.next = NULL;
7801 ut_params->aead_xform.aead.algo = algo;
7802 ut_params->aead_xform.aead.op = op;
7803 ut_params->aead_xform.aead.key.data = aead_key;
7804 ut_params->aead_xform.aead.key.length = key_len;
7805 ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
7806 ut_params->aead_xform.aead.iv.length = iv_len;
7807 ut_params->aead_xform.aead.digest_length = auth_len;
7808 ut_params->aead_xform.aead.aad_length = aad_len;
7810 debug_hexdump(stdout, "key:", key, key_len);
7812 /* Create Crypto session*/
7813 ut_params->sess = rte_cryptodev_sym_session_create(
7814 ts_params->session_mpool);
7816 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
7817 &ut_params->aead_xform,
7818 ts_params->session_priv_mpool);
7820 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
7826 create_aead_xform(struct rte_crypto_op *op,
7827 enum rte_crypto_aead_algorithm algo,
7828 enum rte_crypto_aead_operation aead_op,
7829 uint8_t *key, const uint8_t key_len,
7830 const uint8_t aad_len, const uint8_t auth_len,
7833 TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 1),
7834 "failed to allocate space for crypto transform");
7836 struct rte_crypto_sym_op *sym_op = op->sym;
7838 /* Setup AEAD Parameters */
7839 sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_AEAD;
7840 sym_op->xform->next = NULL;
7841 sym_op->xform->aead.algo = algo;
7842 sym_op->xform->aead.op = aead_op;
7843 sym_op->xform->aead.key.data = key;
7844 sym_op->xform->aead.key.length = key_len;
7845 sym_op->xform->aead.iv.offset = IV_OFFSET;
7846 sym_op->xform->aead.iv.length = iv_len;
7847 sym_op->xform->aead.digest_length = auth_len;
7848 sym_op->xform->aead.aad_length = aad_len;
7850 debug_hexdump(stdout, "key:", key, key_len);
7856 create_aead_operation(enum rte_crypto_aead_operation op,
7857 const struct aead_test_data *tdata)
7859 struct crypto_testsuite_params *ts_params = &testsuite_params;
7860 struct crypto_unittest_params *ut_params = &unittest_params;
7862 uint8_t *plaintext, *ciphertext;
7863 unsigned int aad_pad_len, plaintext_pad_len;
7865 /* Generate Crypto op data structure */
7866 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7867 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7868 TEST_ASSERT_NOT_NULL(ut_params->op,
7869 "Failed to allocate symmetric crypto operation struct");
7871 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
7873 /* Append aad data */
7874 if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
7875 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len + 18, 16);
7876 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7878 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
7879 "no room to append aad");
7881 sym_op->aead.aad.phys_addr =
7882 rte_pktmbuf_iova(ut_params->ibuf);
7883 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
7884 memcpy(sym_op->aead.aad.data + 18, tdata->aad.data, tdata->aad.len);
7885 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
7888 /* Append IV at the end of the crypto operation*/
7889 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
7890 uint8_t *, IV_OFFSET);
7892 /* Copy IV 1 byte after the IV pointer, according to the API */
7893 rte_memcpy(iv_ptr + 1, tdata->iv.data, tdata->iv.len);
7894 debug_hexdump(stdout, "iv:", iv_ptr,
7897 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
7898 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7900 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
7901 "no room to append aad");
7903 sym_op->aead.aad.phys_addr =
7904 rte_pktmbuf_iova(ut_params->ibuf);
7905 memcpy(sym_op->aead.aad.data, tdata->aad.data, tdata->aad.len);
7906 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
7909 /* Append IV at the end of the crypto operation*/
7910 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
7911 uint8_t *, IV_OFFSET);
7913 if (tdata->iv.len == 0) {
7914 rte_memcpy(iv_ptr, tdata->iv.data, AES_GCM_J0_LENGTH);
7915 debug_hexdump(stdout, "iv:", iv_ptr,
7918 rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
7919 debug_hexdump(stdout, "iv:", iv_ptr,
7924 /* Append plaintext/ciphertext */
7925 if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
7926 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
7927 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7929 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
7931 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
7932 debug_hexdump(stdout, "plaintext:", plaintext,
7933 tdata->plaintext.len);
7935 if (ut_params->obuf) {
7936 ciphertext = (uint8_t *)rte_pktmbuf_append(
7938 plaintext_pad_len + aad_pad_len);
7939 TEST_ASSERT_NOT_NULL(ciphertext,
7940 "no room to append ciphertext");
7942 memset(ciphertext + aad_pad_len, 0,
7943 tdata->ciphertext.len);
7946 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16);
7947 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7949 TEST_ASSERT_NOT_NULL(ciphertext,
7950 "no room to append ciphertext");
7952 memcpy(ciphertext, tdata->ciphertext.data,
7953 tdata->ciphertext.len);
7954 debug_hexdump(stdout, "ciphertext:", ciphertext,
7955 tdata->ciphertext.len);
7957 if (ut_params->obuf) {
7958 plaintext = (uint8_t *)rte_pktmbuf_append(
7960 plaintext_pad_len + aad_pad_len);
7961 TEST_ASSERT_NOT_NULL(plaintext,
7962 "no room to append plaintext");
7964 memset(plaintext + aad_pad_len, 0,
7965 tdata->plaintext.len);
7969 /* Append digest data */
7970 if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
7971 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
7972 ut_params->obuf ? ut_params->obuf :
7974 tdata->auth_tag.len);
7975 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
7976 "no room to append digest");
7977 memset(sym_op->aead.digest.data, 0, tdata->auth_tag.len);
7978 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
7979 ut_params->obuf ? ut_params->obuf :
7984 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
7985 ut_params->ibuf, tdata->auth_tag.len);
7986 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
7987 "no room to append digest");
7988 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
7990 plaintext_pad_len + aad_pad_len);
7992 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
7993 tdata->auth_tag.len);
7994 debug_hexdump(stdout, "digest:",
7995 sym_op->aead.digest.data,
7996 tdata->auth_tag.len);
7999 sym_op->aead.data.length = tdata->plaintext.len;
8000 sym_op->aead.data.offset = aad_pad_len;
8006 test_authenticated_encryption(const struct aead_test_data *tdata)
8008 struct crypto_testsuite_params *ts_params = &testsuite_params;
8009 struct crypto_unittest_params *ut_params = &unittest_params;
8012 uint8_t *ciphertext, *auth_tag;
8013 uint16_t plaintext_pad_len;
8015 struct rte_cryptodev_info dev_info;
8017 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8018 uint64_t feat_flags = dev_info.feature_flags;
8020 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
8021 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
8022 printf("Device doesn't support RAW data-path APIs.\n");
8023 return TEST_SKIPPED;
8026 /* Verify the capabilities */
8027 struct rte_cryptodev_sym_capability_idx cap_idx;
8028 const struct rte_cryptodev_symmetric_capability *capability;
8029 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
8030 cap_idx.algo.aead = tdata->algo;
8031 capability = rte_cryptodev_sym_capability_get(
8032 ts_params->valid_devs[0], &cap_idx);
8033 if (capability == NULL)
8034 return TEST_SKIPPED;
8035 if (rte_cryptodev_sym_capability_check_aead(
8036 capability, tdata->key.len, tdata->auth_tag.len,
8037 tdata->aad.len, tdata->iv.len))
8038 return TEST_SKIPPED;
8040 /* Create AEAD session */
8041 retval = create_aead_session(ts_params->valid_devs[0],
8043 RTE_CRYPTO_AEAD_OP_ENCRYPT,
8044 tdata->key.data, tdata->key.len,
8045 tdata->aad.len, tdata->auth_tag.len,
8050 if (tdata->aad.len > MBUF_SIZE) {
8051 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
8052 /* Populate full size of add data */
8053 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
8054 memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
8056 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8058 /* clear mbuf payload */
8059 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8060 rte_pktmbuf_tailroom(ut_params->ibuf));
8062 /* Create AEAD operation */
8063 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
8067 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
8069 ut_params->op->sym->m_src = ut_params->ibuf;
8071 /* Process crypto operation */
8072 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
8073 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
8074 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
8075 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
8076 ut_params->op, 0, 0, 0, 0);
8078 TEST_ASSERT_NOT_NULL(
8079 process_crypto_request(ts_params->valid_devs[0],
8080 ut_params->op), "failed to process sym crypto op");
8082 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8083 "crypto op processing failed");
8085 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
8087 if (ut_params->op->sym->m_dst) {
8088 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8090 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
8091 uint8_t *, plaintext_pad_len);
8093 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
8095 ut_params->op->sym->cipher.data.offset);
8096 auth_tag = ciphertext + plaintext_pad_len;
8099 debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
8100 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
8103 TEST_ASSERT_BUFFERS_ARE_EQUAL(
8105 tdata->ciphertext.data,
8106 tdata->ciphertext.len,
8107 "Ciphertext data not as expected");
8109 TEST_ASSERT_BUFFERS_ARE_EQUAL(
8111 tdata->auth_tag.data,
8112 tdata->auth_tag.len,
8113 "Generated auth tag not as expected");
8119 #ifdef RTE_LIB_SECURITY
8121 security_proto_supported(enum rte_security_session_action_type action,
8122 enum rte_security_session_protocol proto)
8124 struct crypto_testsuite_params *ts_params = &testsuite_params;
8126 const struct rte_security_capability *capabilities;
8127 const struct rte_security_capability *capability;
8130 struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8131 rte_cryptodev_get_sec_ctx(
8132 ts_params->valid_devs[0]);
8135 capabilities = rte_security_capabilities_get(ctx);
8137 if (capabilities == NULL)
8140 while ((capability = &capabilities[i++])->action !=
8141 RTE_SECURITY_ACTION_TYPE_NONE) {
8142 if (capability->action == action &&
8143 capability->protocol == proto)
8150 /* Basic algorithm run function for async inplace mode.
8151 * Creates a session from input parameters and runs one operation
8152 * on input_vec. Checks the output of the crypto operation against
8155 static int test_pdcp_proto(int i, int oop, enum rte_crypto_cipher_operation opc,
8156 enum rte_crypto_auth_operation opa,
8157 const uint8_t *input_vec, unsigned int input_vec_len,
8158 const uint8_t *output_vec,
8159 unsigned int output_vec_len,
8160 enum rte_crypto_cipher_algorithm cipher_alg,
8161 const uint8_t *cipher_key, uint32_t cipher_key_len,
8162 enum rte_crypto_auth_algorithm auth_alg,
8163 const uint8_t *auth_key, uint32_t auth_key_len,
8164 uint8_t bearer, enum rte_security_pdcp_domain domain,
8165 uint8_t packet_direction, uint8_t sn_size,
8166 uint32_t hfn, uint32_t hfn_threshold, uint8_t sdap)
8168 struct crypto_testsuite_params *ts_params = &testsuite_params;
8169 struct crypto_unittest_params *ut_params = &unittest_params;
8171 int ret = TEST_SUCCESS;
8172 struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8173 rte_cryptodev_get_sec_ctx(
8174 ts_params->valid_devs[0]);
8176 /* Verify the capabilities */
8177 struct rte_security_capability_idx sec_cap_idx;
8179 sec_cap_idx.action = ut_params->type;
8180 sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
8181 sec_cap_idx.pdcp.domain = domain;
8182 if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
8183 return TEST_SKIPPED;
8185 /* Generate test mbuf data */
8186 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8188 /* clear mbuf payload */
8189 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8190 rte_pktmbuf_tailroom(ut_params->ibuf));
8192 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8194 memcpy(plaintext, input_vec, input_vec_len);
8196 /* Out of place support */
8199 * For out-op-place we need to alloc another mbuf
8201 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8202 rte_pktmbuf_append(ut_params->obuf, output_vec_len);
8205 /* Setup Cipher Parameters */
8206 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8207 ut_params->cipher_xform.cipher.algo = cipher_alg;
8208 ut_params->cipher_xform.cipher.op = opc;
8209 ut_params->cipher_xform.cipher.key.data = cipher_key;
8210 ut_params->cipher_xform.cipher.key.length = cipher_key_len;
8211 ut_params->cipher_xform.cipher.iv.length =
8212 packet_direction ? 4 : 0;
8213 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
8215 /* Setup HMAC Parameters if ICV header is required */
8216 if (auth_alg != 0) {
8217 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8218 ut_params->auth_xform.next = NULL;
8219 ut_params->auth_xform.auth.algo = auth_alg;
8220 ut_params->auth_xform.auth.op = opa;
8221 ut_params->auth_xform.auth.key.data = auth_key;
8222 ut_params->auth_xform.auth.key.length = auth_key_len;
8224 ut_params->cipher_xform.next = &ut_params->auth_xform;
8226 ut_params->cipher_xform.next = NULL;
8229 struct rte_security_session_conf sess_conf = {
8230 .action_type = ut_params->type,
8231 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
8235 .pkt_dir = packet_direction,
8237 .hfn = packet_direction ? 0 : hfn,
8239 * hfn can be set as pdcp_test_hfn[i]
8240 * if hfn_ovrd is not set. Here, PDCP
8241 * packet direction is just used to
8242 * run half of the cases with session
8243 * HFN and other half with per packet
8246 .hfn_threshold = hfn_threshold,
8247 .hfn_ovrd = packet_direction ? 1 : 0,
8248 .sdap_enabled = sdap,
8250 .crypto_xform = &ut_params->cipher_xform
8253 /* Create security session */
8254 ut_params->sec_session = rte_security_session_create(ctx,
8255 &sess_conf, ts_params->session_mpool,
8256 ts_params->session_priv_mpool);
8258 if (!ut_params->sec_session) {
8259 printf("TestCase %s()-%d line %d failed %s: ",
8260 __func__, i, __LINE__, "Failed to allocate session");
8265 /* Generate crypto op data structure */
8266 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8267 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8268 if (!ut_params->op) {
8269 printf("TestCase %s()-%d line %d failed %s: ",
8270 __func__, i, __LINE__,
8271 "Failed to allocate symmetric crypto operation struct");
8276 uint32_t *per_pkt_hfn = rte_crypto_op_ctod_offset(ut_params->op,
8277 uint32_t *, IV_OFFSET);
8278 *per_pkt_hfn = packet_direction ? hfn : 0;
8280 rte_security_attach_session(ut_params->op, ut_params->sec_session);
8282 /* set crypto operation source mbuf */
8283 ut_params->op->sym->m_src = ut_params->ibuf;
8285 ut_params->op->sym->m_dst = ut_params->obuf;
8287 /* Process crypto operation */
8288 if (process_crypto_request(ts_params->valid_devs[0], ut_params->op)
8290 printf("TestCase %s()-%d line %d failed %s: ",
8291 __func__, i, __LINE__,
8292 "failed to process sym crypto op");
8297 if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8298 printf("TestCase %s()-%d line %d failed %s: ",
8299 __func__, i, __LINE__, "crypto op processing failed");
8305 uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
8308 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8312 if (memcmp(ciphertext, output_vec, output_vec_len)) {
8313 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8314 rte_hexdump(stdout, "encrypted", ciphertext, output_vec_len);
8315 rte_hexdump(stdout, "reference", output_vec, output_vec_len);
8321 rte_crypto_op_free(ut_params->op);
8322 ut_params->op = NULL;
8324 if (ut_params->sec_session)
8325 rte_security_session_destroy(ctx, ut_params->sec_session);
8326 ut_params->sec_session = NULL;
8328 rte_pktmbuf_free(ut_params->ibuf);
8329 ut_params->ibuf = NULL;
8331 rte_pktmbuf_free(ut_params->obuf);
8332 ut_params->obuf = NULL;
8339 test_pdcp_proto_SGL(int i, int oop,
8340 enum rte_crypto_cipher_operation opc,
8341 enum rte_crypto_auth_operation opa,
8343 unsigned int input_vec_len,
8344 uint8_t *output_vec,
8345 unsigned int output_vec_len,
8347 uint32_t fragsz_oop)
8349 struct crypto_testsuite_params *ts_params = &testsuite_params;
8350 struct crypto_unittest_params *ut_params = &unittest_params;
8352 struct rte_mbuf *buf, *buf_oop = NULL;
8353 int ret = TEST_SUCCESS;
8357 unsigned int trn_data = 0;
8358 struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8359 rte_cryptodev_get_sec_ctx(
8360 ts_params->valid_devs[0]);
8362 /* Verify the capabilities */
8363 struct rte_security_capability_idx sec_cap_idx;
8365 sec_cap_idx.action = ut_params->type;
8366 sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
8367 sec_cap_idx.pdcp.domain = pdcp_test_params[i].domain;
8368 if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
8369 return TEST_SKIPPED;
8371 if (fragsz > input_vec_len)
8372 fragsz = input_vec_len;
8374 uint16_t plaintext_len = fragsz;
8375 uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
8377 if (fragsz_oop > output_vec_len)
8378 frag_size_oop = output_vec_len;
8381 if (input_vec_len % fragsz != 0) {
8382 if (input_vec_len / fragsz + 1 > 16)
8384 } else if (input_vec_len / fragsz > 16)
8387 /* Out of place support */
8390 * For out-op-place we need to alloc another mbuf
8392 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8393 rte_pktmbuf_append(ut_params->obuf, frag_size_oop);
8394 buf_oop = ut_params->obuf;
8397 /* Generate test mbuf data */
8398 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8400 /* clear mbuf payload */
8401 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8402 rte_pktmbuf_tailroom(ut_params->ibuf));
8404 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8406 memcpy(plaintext, input_vec, plaintext_len);
8407 trn_data += plaintext_len;
8409 buf = ut_params->ibuf;
8412 * Loop until no more fragments
8415 while (trn_data < input_vec_len) {
8417 to_trn = (input_vec_len - trn_data < fragsz) ?
8418 (input_vec_len - trn_data) : fragsz;
8420 to_trn_tbl[ecx++] = to_trn;
8422 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8425 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
8426 rte_pktmbuf_tailroom(buf));
8429 if (oop && !fragsz_oop) {
8431 rte_pktmbuf_alloc(ts_params->mbuf_pool);
8432 buf_oop = buf_oop->next;
8433 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8434 0, rte_pktmbuf_tailroom(buf_oop));
8435 rte_pktmbuf_append(buf_oop, to_trn);
8438 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
8441 memcpy(plaintext, input_vec + trn_data, to_trn);
8445 ut_params->ibuf->nb_segs = segs;
8448 if (fragsz_oop && oop) {
8452 trn_data = frag_size_oop;
8453 while (trn_data < output_vec_len) {
8456 (output_vec_len - trn_data <
8458 (output_vec_len - trn_data) :
8461 to_trn_tbl[ecx++] = to_trn;
8464 rte_pktmbuf_alloc(ts_params->mbuf_pool);
8465 buf_oop = buf_oop->next;
8466 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8467 0, rte_pktmbuf_tailroom(buf_oop));
8468 rte_pktmbuf_append(buf_oop, to_trn);
8472 ut_params->obuf->nb_segs = segs;
8475 /* Setup Cipher Parameters */
8476 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8477 ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg;
8478 ut_params->cipher_xform.cipher.op = opc;
8479 ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i];
8480 ut_params->cipher_xform.cipher.key.length =
8481 pdcp_test_params[i].cipher_key_len;
8482 ut_params->cipher_xform.cipher.iv.length = 0;
8484 /* Setup HMAC Parameters if ICV header is required */
8485 if (pdcp_test_params[i].auth_alg != 0) {
8486 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8487 ut_params->auth_xform.next = NULL;
8488 ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg;
8489 ut_params->auth_xform.auth.op = opa;
8490 ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i];
8491 ut_params->auth_xform.auth.key.length =
8492 pdcp_test_params[i].auth_key_len;
8494 ut_params->cipher_xform.next = &ut_params->auth_xform;
8496 ut_params->cipher_xform.next = NULL;
8499 struct rte_security_session_conf sess_conf = {
8500 .action_type = ut_params->type,
8501 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
8503 .bearer = pdcp_test_bearer[i],
8504 .domain = pdcp_test_params[i].domain,
8505 .pkt_dir = pdcp_test_packet_direction[i],
8506 .sn_size = pdcp_test_data_sn_size[i],
8507 .hfn = pdcp_test_hfn[i],
8508 .hfn_threshold = pdcp_test_hfn_threshold[i],
8511 .crypto_xform = &ut_params->cipher_xform
8514 /* Create security session */
8515 ut_params->sec_session = rte_security_session_create(ctx,
8516 &sess_conf, ts_params->session_mpool,
8517 ts_params->session_priv_mpool);
8519 if (!ut_params->sec_session) {
8520 printf("TestCase %s()-%d line %d failed %s: ",
8521 __func__, i, __LINE__, "Failed to allocate session");
8526 /* Generate crypto op data structure */
8527 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8528 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8529 if (!ut_params->op) {
8530 printf("TestCase %s()-%d line %d failed %s: ",
8531 __func__, i, __LINE__,
8532 "Failed to allocate symmetric crypto operation struct");
8537 rte_security_attach_session(ut_params->op, ut_params->sec_session);
8539 /* set crypto operation source mbuf */
8540 ut_params->op->sym->m_src = ut_params->ibuf;
8542 ut_params->op->sym->m_dst = ut_params->obuf;
8544 /* Process crypto operation */
8545 if (process_crypto_request(ts_params->valid_devs[0], ut_params->op)
8547 printf("TestCase %s()-%d line %d failed %s: ",
8548 __func__, i, __LINE__,
8549 "failed to process sym crypto op");
8554 if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8555 printf("TestCase %s()-%d line %d failed %s: ",
8556 __func__, i, __LINE__, "crypto op processing failed");
8562 uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
8565 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8569 fragsz = frag_size_oop;
8570 if (memcmp(ciphertext, output_vec, fragsz)) {
8571 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8572 rte_hexdump(stdout, "encrypted", ciphertext, fragsz);
8573 rte_hexdump(stdout, "reference", output_vec, fragsz);
8578 buf = ut_params->op->sym->m_src->next;
8580 buf = ut_params->op->sym->m_dst->next;
8582 unsigned int off = fragsz;
8586 ciphertext = rte_pktmbuf_mtod(buf,
8588 if (memcmp(ciphertext, output_vec + off, to_trn_tbl[ecx])) {
8589 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8590 rte_hexdump(stdout, "encrypted", ciphertext, to_trn_tbl[ecx]);
8591 rte_hexdump(stdout, "reference", output_vec + off,
8596 off += to_trn_tbl[ecx++];
8600 rte_crypto_op_free(ut_params->op);
8601 ut_params->op = NULL;
8603 if (ut_params->sec_session)
8604 rte_security_session_destroy(ctx, ut_params->sec_session);
8605 ut_params->sec_session = NULL;
8607 rte_pktmbuf_free(ut_params->ibuf);
8608 ut_params->ibuf = NULL;
8610 rte_pktmbuf_free(ut_params->obuf);
8611 ut_params->obuf = NULL;
8618 test_pdcp_proto_cplane_encap(int i)
8620 return test_pdcp_proto(
8621 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8622 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8623 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8624 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8625 pdcp_test_params[i].cipher_key_len,
8626 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8627 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8628 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8629 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8630 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8634 test_pdcp_proto_uplane_encap(int i)
8636 return test_pdcp_proto(
8637 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8638 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8639 pdcp_test_data_out[i], pdcp_test_data_in_len[i],
8640 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8641 pdcp_test_params[i].cipher_key_len,
8642 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8643 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8644 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8645 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8646 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8650 test_pdcp_proto_uplane_encap_with_int(int i)
8652 return test_pdcp_proto(
8653 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8654 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8655 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8656 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8657 pdcp_test_params[i].cipher_key_len,
8658 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8659 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8660 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8661 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8662 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8666 test_pdcp_proto_cplane_decap(int i)
8668 return test_pdcp_proto(
8669 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8670 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8671 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8672 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8673 pdcp_test_params[i].cipher_key_len,
8674 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8675 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8676 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8677 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8678 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8682 test_pdcp_proto_uplane_decap(int i)
8684 return test_pdcp_proto(
8685 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8686 pdcp_test_data_out[i], pdcp_test_data_in_len[i],
8687 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8688 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8689 pdcp_test_params[i].cipher_key_len,
8690 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8691 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8692 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8693 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8694 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8698 test_pdcp_proto_uplane_decap_with_int(int i)
8700 return test_pdcp_proto(
8701 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8702 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8703 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8704 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8705 pdcp_test_params[i].cipher_key_len,
8706 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8707 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8708 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8709 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8710 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8714 test_PDCP_PROTO_SGL_in_place_32B(void)
8716 /* i can be used for running any PDCP case
8717 * In this case it is uplane 12-bit AES-SNOW DL encap
8719 int i = PDCP_UPLANE_12BIT_OFFSET + AES_ENC + SNOW_AUTH + DOWNLINK;
8720 return test_pdcp_proto_SGL(i, IN_PLACE,
8721 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8722 RTE_CRYPTO_AUTH_OP_GENERATE,
8723 pdcp_test_data_in[i],
8724 pdcp_test_data_in_len[i],
8725 pdcp_test_data_out[i],
8726 pdcp_test_data_in_len[i]+4,
8730 test_PDCP_PROTO_SGL_oop_32B_128B(void)
8732 /* i can be used for running any PDCP case
8733 * In this case it is uplane 18-bit NULL-NULL DL encap
8735 int i = PDCP_UPLANE_18BIT_OFFSET + NULL_ENC + NULL_AUTH + DOWNLINK;
8736 return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8737 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8738 RTE_CRYPTO_AUTH_OP_GENERATE,
8739 pdcp_test_data_in[i],
8740 pdcp_test_data_in_len[i],
8741 pdcp_test_data_out[i],
8742 pdcp_test_data_in_len[i]+4,
8746 test_PDCP_PROTO_SGL_oop_32B_40B(void)
8748 /* i can be used for running any PDCP case
8749 * In this case it is uplane 18-bit AES DL encap
8751 int i = PDCP_UPLANE_OFFSET + AES_ENC + EIGHTEEN_BIT_SEQ_NUM_OFFSET
8753 return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8754 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8755 RTE_CRYPTO_AUTH_OP_GENERATE,
8756 pdcp_test_data_in[i],
8757 pdcp_test_data_in_len[i],
8758 pdcp_test_data_out[i],
8759 pdcp_test_data_in_len[i],
8763 test_PDCP_PROTO_SGL_oop_128B_32B(void)
8765 /* i can be used for running any PDCP case
8766 * In this case it is cplane 12-bit AES-ZUC DL encap
8768 int i = PDCP_CPLANE_LONG_SN_OFFSET + AES_ENC + ZUC_AUTH + DOWNLINK;
8769 return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8770 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8771 RTE_CRYPTO_AUTH_OP_GENERATE,
8772 pdcp_test_data_in[i],
8773 pdcp_test_data_in_len[i],
8774 pdcp_test_data_out[i],
8775 pdcp_test_data_in_len[i]+4,
8780 test_PDCP_SDAP_PROTO_encap_all(void)
8782 int i = 0, size = 0;
8783 int err, all_err = TEST_SUCCESS;
8784 const struct pdcp_sdap_test *cur_test;
8786 size = RTE_DIM(list_pdcp_sdap_tests);
8788 for (i = 0; i < size; i++) {
8789 cur_test = &list_pdcp_sdap_tests[i];
8790 err = test_pdcp_proto(
8791 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8792 RTE_CRYPTO_AUTH_OP_GENERATE, cur_test->data_in,
8793 cur_test->in_len, cur_test->data_out,
8794 cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
8795 cur_test->param.cipher_alg, cur_test->cipher_key,
8796 cur_test->param.cipher_key_len,
8797 cur_test->param.auth_alg,
8798 cur_test->auth_key, cur_test->param.auth_key_len,
8799 cur_test->bearer, cur_test->param.domain,
8800 cur_test->packet_direction, cur_test->sn_size,
8802 cur_test->hfn_threshold, SDAP_ENABLED);
8804 printf("\t%d) %s: Encapsulation failed\n",
8806 cur_test->param.name);
8809 printf("\t%d) %s: Encap PASS\n", cur_test->test_idx,
8810 cur_test->param.name);
8816 printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
8818 return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
8822 test_PDCP_PROTO_short_mac(void)
8824 int i = 0, size = 0;
8825 int err, all_err = TEST_SUCCESS;
8826 const struct pdcp_short_mac_test *cur_test;
8828 size = RTE_DIM(list_pdcp_smac_tests);
8830 for (i = 0; i < size; i++) {
8831 cur_test = &list_pdcp_smac_tests[i];
8832 err = test_pdcp_proto(
8833 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8834 RTE_CRYPTO_AUTH_OP_GENERATE, cur_test->data_in,
8835 cur_test->in_len, cur_test->data_out,
8836 cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
8837 RTE_CRYPTO_CIPHER_NULL, NULL,
8838 0, cur_test->param.auth_alg,
8839 cur_test->auth_key, cur_test->param.auth_key_len,
8840 0, cur_test->param.domain, 0, 0,
8843 printf("\t%d) %s: Short MAC test failed\n",
8845 cur_test->param.name);
8848 printf("\t%d) %s: Short MAC test PASS\n",
8850 cur_test->param.name);
8851 rte_hexdump(stdout, "MAC I",
8852 cur_test->data_out + cur_test->in_len + 2,
8859 printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
8861 return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
8866 test_PDCP_SDAP_PROTO_decap_all(void)
8868 int i = 0, size = 0;
8869 int err, all_err = TEST_SUCCESS;
8870 const struct pdcp_sdap_test *cur_test;
8872 size = RTE_DIM(list_pdcp_sdap_tests);
8874 for (i = 0; i < size; i++) {
8875 cur_test = &list_pdcp_sdap_tests[i];
8876 err = test_pdcp_proto(
8877 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT,
8878 RTE_CRYPTO_AUTH_OP_VERIFY,
8880 cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
8881 cur_test->data_in, cur_test->in_len,
8882 cur_test->param.cipher_alg,
8883 cur_test->cipher_key, cur_test->param.cipher_key_len,
8884 cur_test->param.auth_alg, cur_test->auth_key,
8885 cur_test->param.auth_key_len, cur_test->bearer,
8886 cur_test->param.domain, cur_test->packet_direction,
8887 cur_test->sn_size, cur_test->hfn,
8888 cur_test->hfn_threshold, SDAP_ENABLED);
8890 printf("\t%d) %s: Decapsulation failed\n",
8892 cur_test->param.name);
8895 printf("\t%d) %s: Decap PASS\n", cur_test->test_idx,
8896 cur_test->param.name);
8902 printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
8904 return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
8908 test_ipsec_proto_process(const struct ipsec_test_data td[],
8909 struct ipsec_test_data res_d[],
8912 const struct ipsec_test_flags *flags)
8914 struct crypto_testsuite_params *ts_params = &testsuite_params;
8915 struct crypto_unittest_params *ut_params = &unittest_params;
8916 struct rte_security_capability_idx sec_cap_idx;
8917 const struct rte_security_capability *sec_cap;
8918 struct rte_security_ipsec_xform ipsec_xform;
8919 uint8_t dev_id = ts_params->valid_devs[0];
8920 enum rte_security_ipsec_sa_direction dir;
8921 struct ipsec_test_data *res_d_tmp = NULL;
8922 uint32_t src = RTE_IPV4(192, 168, 1, 0);
8923 uint32_t dst = RTE_IPV4(192, 168, 1, 1);
8924 int salt_len, i, ret = TEST_SUCCESS;
8925 struct rte_security_ctx *ctx;
8926 uint8_t *input_text;
8928 ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
8929 gbl_action_type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
8931 /* Use first test data to create session */
8933 /* Copy IPsec xform */
8934 memcpy(&ipsec_xform, &td[0].ipsec_xform, sizeof(ipsec_xform));
8936 memcpy(&ipsec_xform.tunnel.ipv4.src_ip, &src, sizeof(src));
8937 memcpy(&ipsec_xform.tunnel.ipv4.dst_ip, &dst, sizeof(dst));
8939 dir = ipsec_xform.direction;
8941 ctx = rte_cryptodev_get_sec_ctx(dev_id);
8943 sec_cap_idx.action = ut_params->type;
8944 sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_IPSEC;
8945 sec_cap_idx.ipsec.proto = ipsec_xform.proto;
8946 sec_cap_idx.ipsec.mode = ipsec_xform.mode;
8947 sec_cap_idx.ipsec.direction = ipsec_xform.direction;
8949 sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
8950 if (sec_cap == NULL)
8951 return TEST_SKIPPED;
8953 /* Copy cipher session parameters */
8955 memcpy(&ut_params->aead_xform, &td[0].xform.aead,
8956 sizeof(ut_params->aead_xform));
8957 ut_params->aead_xform.aead.key.data = td[0].key.data;
8958 ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
8960 /* Verify crypto capabilities */
8961 if (test_ipsec_crypto_caps_aead_verify(
8963 &ut_params->aead_xform) != 0) {
8965 RTE_LOG(INFO, USER1,
8966 "Crypto capabilities not supported\n");
8967 return TEST_SKIPPED;
8970 /* Only AEAD supported now */
8971 return TEST_SKIPPED;
8974 if (test_ipsec_sec_caps_verify(&ipsec_xform, sec_cap, silent) != 0)
8975 return TEST_SKIPPED;
8977 salt_len = RTE_MIN(sizeof(ipsec_xform.salt), td[0].salt.len);
8978 memcpy(&ipsec_xform.salt, td[0].salt.data, salt_len);
8980 struct rte_security_session_conf sess_conf = {
8981 .action_type = ut_params->type,
8982 .protocol = RTE_SECURITY_PROTOCOL_IPSEC,
8983 .ipsec = ipsec_xform,
8984 .crypto_xform = &ut_params->aead_xform,
8987 /* Create security session */
8988 ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
8989 ts_params->session_mpool,
8990 ts_params->session_priv_mpool);
8992 if (ut_params->sec_session == NULL)
8993 return TEST_SKIPPED;
8995 for (i = 0; i < nb_td; i++) {
8996 /* Setup source mbuf payload */
8997 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8998 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8999 rte_pktmbuf_tailroom(ut_params->ibuf));
9001 input_text = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9002 td[i].input_text.len);
9004 memcpy(input_text, td[i].input_text.data,
9005 td[i].input_text.len);
9007 /* Generate crypto op data structure */
9008 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9009 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9010 if (!ut_params->op) {
9011 printf("TestCase %s line %d: %s\n",
9013 "failed to allocate crypto op");
9015 goto crypto_op_free;
9018 /* Attach session to operation */
9019 rte_security_attach_session(ut_params->op,
9020 ut_params->sec_session);
9022 /* Set crypto operation mbufs */
9023 ut_params->op->sym->m_src = ut_params->ibuf;
9024 ut_params->op->sym->m_dst = NULL;
9026 /* Process crypto operation */
9027 process_crypto_request(dev_id, ut_params->op);
9029 ret = test_ipsec_status_check(ut_params->op, flags, dir);
9030 if (ret != TEST_SUCCESS)
9031 goto crypto_op_free;
9034 res_d_tmp = &res_d[i];
9036 ret = test_ipsec_post_process(ut_params->ibuf, &td[i],
9037 res_d_tmp, silent, flags);
9038 if (ret != TEST_SUCCESS)
9039 goto crypto_op_free;
9041 rte_crypto_op_free(ut_params->op);
9042 ut_params->op = NULL;
9044 rte_pktmbuf_free(ut_params->ibuf);
9045 ut_params->ibuf = NULL;
9049 rte_crypto_op_free(ut_params->op);
9050 ut_params->op = NULL;
9052 rte_pktmbuf_free(ut_params->ibuf);
9053 ut_params->ibuf = NULL;
9055 if (ut_params->sec_session)
9056 rte_security_session_destroy(ctx, ut_params->sec_session);
9057 ut_params->sec_session = NULL;
9063 test_ipsec_proto_known_vec_inb(const void *td_outb)
9065 struct ipsec_test_flags flags;
9066 struct ipsec_test_data td_inb;
9068 memset(&flags, 0, sizeof(flags));
9070 test_ipsec_td_in_from_out(td_outb, &td_inb);
9072 return test_ipsec_proto_process(&td_inb, NULL, 1, false, &flags);
9076 test_ipsec_proto_all(const struct ipsec_test_flags *flags)
9078 struct ipsec_test_data td_outb[IPSEC_TEST_PACKETS_MAX];
9079 struct ipsec_test_data td_inb[IPSEC_TEST_PACKETS_MAX];
9080 unsigned int i, nb_pkts = 1, pass_cnt = 0;
9084 nb_pkts = IPSEC_TEST_PACKETS_MAX;
9086 for (i = 0; i < RTE_DIM(aead_list); i++) {
9087 test_ipsec_td_prepare(&aead_list[i],
9093 ret = test_ipsec_proto_process(td_outb, td_inb, nb_pkts, true,
9095 if (ret == TEST_SKIPPED)
9098 if (ret == TEST_FAILED)
9101 test_ipsec_td_update(td_inb, td_outb, nb_pkts, flags);
9103 ret = test_ipsec_proto_process(td_inb, NULL, nb_pkts, true,
9105 if (ret == TEST_SKIPPED)
9108 if (ret == TEST_FAILED)
9111 if (flags->display_alg)
9112 test_ipsec_display_alg(&aead_list[i], NULL);
9118 return TEST_SUCCESS;
9120 return TEST_SKIPPED;
9124 test_ipsec_proto_display_list(const void *data __rte_unused)
9126 struct ipsec_test_flags flags;
9128 memset(&flags, 0, sizeof(flags));
9130 flags.display_alg = true;
9132 return test_ipsec_proto_all(&flags);
9136 test_ipsec_proto_iv_gen(const void *data __rte_unused)
9138 struct ipsec_test_flags flags;
9140 memset(&flags, 0, sizeof(flags));
9142 flags.iv_gen = true;
9144 return test_ipsec_proto_all(&flags);
9148 test_ipsec_proto_err_icv_corrupt(const void *data __rte_unused)
9150 struct ipsec_test_flags flags;
9152 memset(&flags, 0, sizeof(flags));
9154 flags.icv_corrupt = true;
9156 return test_ipsec_proto_all(&flags);
9160 test_PDCP_PROTO_all(void)
9162 struct crypto_testsuite_params *ts_params = &testsuite_params;
9163 struct crypto_unittest_params *ut_params = &unittest_params;
9164 struct rte_cryptodev_info dev_info;
9167 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
9168 uint64_t feat_flags = dev_info.feature_flags;
9170 if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY))
9171 return TEST_SKIPPED;
9173 /* Set action type */
9174 ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
9175 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
9178 if (security_proto_supported(ut_params->type,
9179 RTE_SECURITY_PROTOCOL_PDCP) < 0)
9180 return TEST_SKIPPED;
9182 status = test_PDCP_PROTO_cplane_encap_all();
9183 status += test_PDCP_PROTO_cplane_decap_all();
9184 status += test_PDCP_PROTO_uplane_encap_all();
9185 status += test_PDCP_PROTO_uplane_decap_all();
9186 status += test_PDCP_PROTO_SGL_in_place_32B();
9187 status += test_PDCP_PROTO_SGL_oop_32B_128B();
9188 status += test_PDCP_PROTO_SGL_oop_32B_40B();
9189 status += test_PDCP_PROTO_SGL_oop_128B_32B();
9190 status += test_PDCP_SDAP_PROTO_encap_all();
9191 status += test_PDCP_SDAP_PROTO_decap_all();
9192 status += test_PDCP_PROTO_short_mac();
9197 return TEST_SUCCESS;
9201 test_docsis_proto_uplink(int i, struct docsis_test_data *d_td)
9203 struct crypto_testsuite_params *ts_params = &testsuite_params;
9204 struct crypto_unittest_params *ut_params = &unittest_params;
9205 uint8_t *plaintext, *ciphertext;
9207 int32_t cipher_len, crc_len;
9208 uint32_t crc_data_len;
9209 int ret = TEST_SUCCESS;
9211 struct rte_security_ctx *ctx = (struct rte_security_ctx *)
9212 rte_cryptodev_get_sec_ctx(
9213 ts_params->valid_devs[0]);
9215 /* Verify the capabilities */
9216 struct rte_security_capability_idx sec_cap_idx;
9217 const struct rte_security_capability *sec_cap;
9218 const struct rte_cryptodev_capabilities *crypto_cap;
9219 const struct rte_cryptodev_symmetric_capability *sym_cap;
9222 sec_cap_idx.action = ut_params->type;
9223 sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
9224 sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_UPLINK;
9226 sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
9227 if (sec_cap == NULL)
9228 return TEST_SKIPPED;
9230 while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
9231 RTE_CRYPTO_OP_TYPE_UNDEFINED) {
9232 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
9233 crypto_cap->sym.xform_type ==
9234 RTE_CRYPTO_SYM_XFORM_CIPHER &&
9235 crypto_cap->sym.cipher.algo ==
9236 RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
9237 sym_cap = &crypto_cap->sym;
9238 if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
9245 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
9246 return TEST_SKIPPED;
9248 /* Setup source mbuf payload */
9249 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9250 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9251 rte_pktmbuf_tailroom(ut_params->ibuf));
9253 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9254 d_td->ciphertext.len);
9256 memcpy(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len);
9258 /* Setup cipher session parameters */
9259 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
9260 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
9261 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
9262 ut_params->cipher_xform.cipher.key.data = d_td->key.data;
9263 ut_params->cipher_xform.cipher.key.length = d_td->key.len;
9264 ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
9265 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
9266 ut_params->cipher_xform.next = NULL;
9268 /* Setup DOCSIS session parameters */
9269 ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_UPLINK;
9271 struct rte_security_session_conf sess_conf = {
9272 .action_type = ut_params->type,
9273 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
9274 .docsis = ut_params->docsis_xform,
9275 .crypto_xform = &ut_params->cipher_xform,
9278 /* Create security session */
9279 ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
9280 ts_params->session_mpool,
9281 ts_params->session_priv_mpool);
9283 if (!ut_params->sec_session) {
9284 printf("TestCase %s(%d) line %d: %s\n",
9285 __func__, i, __LINE__, "failed to allocate session");
9290 /* Generate crypto op data structure */
9291 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9292 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9293 if (!ut_params->op) {
9294 printf("TestCase %s(%d) line %d: %s\n",
9295 __func__, i, __LINE__,
9296 "failed to allocate symmetric crypto operation");
9301 /* Setup CRC operation parameters */
9302 crc_len = d_td->ciphertext.no_crc == false ?
9303 (d_td->ciphertext.len -
9304 d_td->ciphertext.crc_offset -
9305 RTE_ETHER_CRC_LEN) :
9307 crc_len = crc_len > 0 ? crc_len : 0;
9308 crc_data_len = crc_len == 0 ? 0 : RTE_ETHER_CRC_LEN;
9309 ut_params->op->sym->auth.data.length = crc_len;
9310 ut_params->op->sym->auth.data.offset = d_td->ciphertext.crc_offset;
9312 /* Setup cipher operation parameters */
9313 cipher_len = d_td->ciphertext.no_cipher == false ?
9314 (d_td->ciphertext.len -
9315 d_td->ciphertext.cipher_offset) :
9317 cipher_len = cipher_len > 0 ? cipher_len : 0;
9318 ut_params->op->sym->cipher.data.length = cipher_len;
9319 ut_params->op->sym->cipher.data.offset = d_td->ciphertext.cipher_offset;
9321 /* Setup cipher IV */
9322 iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
9323 rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
9325 /* Attach session to operation */
9326 rte_security_attach_session(ut_params->op, ut_params->sec_session);
9328 /* Set crypto operation mbufs */
9329 ut_params->op->sym->m_src = ut_params->ibuf;
9330 ut_params->op->sym->m_dst = NULL;
9332 /* Process crypto operation */
9333 if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
9335 printf("TestCase %s(%d) line %d: %s\n",
9336 __func__, i, __LINE__,
9337 "failed to process security crypto op");
9342 if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
9343 printf("TestCase %s(%d) line %d: %s\n",
9344 __func__, i, __LINE__, "crypto op processing failed");
9349 /* Validate plaintext */
9350 plaintext = ciphertext;
9352 if (memcmp(plaintext, d_td->plaintext.data,
9353 d_td->plaintext.len - crc_data_len)) {
9354 printf("TestCase %s(%d) line %d: %s\n",
9355 __func__, i, __LINE__, "plaintext not as expected\n");
9356 rte_hexdump(stdout, "expected", d_td->plaintext.data,
9357 d_td->plaintext.len);
9358 rte_hexdump(stdout, "actual", plaintext, d_td->plaintext.len);
9364 rte_crypto_op_free(ut_params->op);
9365 ut_params->op = NULL;
9367 if (ut_params->sec_session)
9368 rte_security_session_destroy(ctx, ut_params->sec_session);
9369 ut_params->sec_session = NULL;
9371 rte_pktmbuf_free(ut_params->ibuf);
9372 ut_params->ibuf = NULL;
9378 test_docsis_proto_downlink(int i, struct docsis_test_data *d_td)
9380 struct crypto_testsuite_params *ts_params = &testsuite_params;
9381 struct crypto_unittest_params *ut_params = &unittest_params;
9382 uint8_t *plaintext, *ciphertext;
9384 int32_t cipher_len, crc_len;
9385 int ret = TEST_SUCCESS;
9387 struct rte_security_ctx *ctx = (struct rte_security_ctx *)
9388 rte_cryptodev_get_sec_ctx(
9389 ts_params->valid_devs[0]);
9391 /* Verify the capabilities */
9392 struct rte_security_capability_idx sec_cap_idx;
9393 const struct rte_security_capability *sec_cap;
9394 const struct rte_cryptodev_capabilities *crypto_cap;
9395 const struct rte_cryptodev_symmetric_capability *sym_cap;
9398 sec_cap_idx.action = ut_params->type;
9399 sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
9400 sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
9402 sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
9403 if (sec_cap == NULL)
9404 return TEST_SKIPPED;
9406 while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
9407 RTE_CRYPTO_OP_TYPE_UNDEFINED) {
9408 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
9409 crypto_cap->sym.xform_type ==
9410 RTE_CRYPTO_SYM_XFORM_CIPHER &&
9411 crypto_cap->sym.cipher.algo ==
9412 RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
9413 sym_cap = &crypto_cap->sym;
9414 if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
9421 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
9422 return TEST_SKIPPED;
9424 /* Setup source mbuf payload */
9425 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9426 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9427 rte_pktmbuf_tailroom(ut_params->ibuf));
9429 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9430 d_td->plaintext.len);
9432 memcpy(plaintext, d_td->plaintext.data, d_td->plaintext.len);
9434 /* Setup cipher session parameters */
9435 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
9436 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
9437 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
9438 ut_params->cipher_xform.cipher.key.data = d_td->key.data;
9439 ut_params->cipher_xform.cipher.key.length = d_td->key.len;
9440 ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
9441 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
9442 ut_params->cipher_xform.next = NULL;
9444 /* Setup DOCSIS session parameters */
9445 ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
9447 struct rte_security_session_conf sess_conf = {
9448 .action_type = ut_params->type,
9449 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
9450 .docsis = ut_params->docsis_xform,
9451 .crypto_xform = &ut_params->cipher_xform,
9454 /* Create security session */
9455 ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
9456 ts_params->session_mpool,
9457 ts_params->session_priv_mpool);
9459 if (!ut_params->sec_session) {
9460 printf("TestCase %s(%d) line %d: %s\n",
9461 __func__, i, __LINE__, "failed to allocate session");
9466 /* Generate crypto op data structure */
9467 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9468 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9469 if (!ut_params->op) {
9470 printf("TestCase %s(%d) line %d: %s\n",
9471 __func__, i, __LINE__,
9472 "failed to allocate security crypto operation");
9477 /* Setup CRC operation parameters */
9478 crc_len = d_td->plaintext.no_crc == false ?
9479 (d_td->plaintext.len -
9480 d_td->plaintext.crc_offset -
9481 RTE_ETHER_CRC_LEN) :
9483 crc_len = crc_len > 0 ? crc_len : 0;
9484 ut_params->op->sym->auth.data.length = crc_len;
9485 ut_params->op->sym->auth.data.offset = d_td->plaintext.crc_offset;
9487 /* Setup cipher operation parameters */
9488 cipher_len = d_td->plaintext.no_cipher == false ?
9489 (d_td->plaintext.len -
9490 d_td->plaintext.cipher_offset) :
9492 cipher_len = cipher_len > 0 ? cipher_len : 0;
9493 ut_params->op->sym->cipher.data.length = cipher_len;
9494 ut_params->op->sym->cipher.data.offset = d_td->plaintext.cipher_offset;
9496 /* Setup cipher IV */
9497 iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
9498 rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
9500 /* Attach session to operation */
9501 rte_security_attach_session(ut_params->op, ut_params->sec_session);
9503 /* Set crypto operation mbufs */
9504 ut_params->op->sym->m_src = ut_params->ibuf;
9505 ut_params->op->sym->m_dst = NULL;
9507 /* Process crypto operation */
9508 if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
9510 printf("TestCase %s(%d) line %d: %s\n",
9511 __func__, i, __LINE__,
9512 "failed to process security crypto op");
9517 if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
9518 printf("TestCase %s(%d) line %d: %s\n",
9519 __func__, i, __LINE__, "crypto op processing failed");
9524 /* Validate ciphertext */
9525 ciphertext = plaintext;
9527 if (memcmp(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len)) {
9528 printf("TestCase %s(%d) line %d: %s\n",
9529 __func__, i, __LINE__, "ciphertext not as expected\n");
9530 rte_hexdump(stdout, "expected", d_td->ciphertext.data,
9531 d_td->ciphertext.len);
9532 rte_hexdump(stdout, "actual", ciphertext, d_td->ciphertext.len);
9538 rte_crypto_op_free(ut_params->op);
9539 ut_params->op = NULL;
9541 if (ut_params->sec_session)
9542 rte_security_session_destroy(ctx, ut_params->sec_session);
9543 ut_params->sec_session = NULL;
9545 rte_pktmbuf_free(ut_params->ibuf);
9546 ut_params->ibuf = NULL;
9551 #define TEST_DOCSIS_COUNT(func) do { \
9553 if (ret == TEST_SUCCESS) { \
9554 printf("\t%2d)", n++); \
9555 printf("+++++ PASSED:" #func"\n"); \
9557 } else if (ret == TEST_SKIPPED) { \
9558 printf("\t%2d)", n++); \
9559 printf("~~~~~ SKIPPED:" #func"\n"); \
9562 printf("\t%2d)", n++); \
9563 printf("----- FAILED:" #func"\n"); \
9569 test_DOCSIS_PROTO_uplink_all(void)
9571 int p = 0, s = 0, f = 0, n = 0;
9573 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(1, &docsis_test_case_1));
9574 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(2, &docsis_test_case_2));
9575 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(3, &docsis_test_case_3));
9576 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(4, &docsis_test_case_4));
9577 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(5, &docsis_test_case_5));
9578 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(6, &docsis_test_case_6));
9579 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(7, &docsis_test_case_7));
9580 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(8, &docsis_test_case_8));
9581 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(9, &docsis_test_case_9));
9582 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(10, &docsis_test_case_10));
9583 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(11, &docsis_test_case_11));
9584 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(12, &docsis_test_case_12));
9585 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(13, &docsis_test_case_13));
9586 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(14, &docsis_test_case_14));
9587 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(15, &docsis_test_case_15));
9588 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(16, &docsis_test_case_16));
9589 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(17, &docsis_test_case_17));
9590 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(18, &docsis_test_case_18));
9591 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(19, &docsis_test_case_19));
9592 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(20, &docsis_test_case_20));
9593 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(21, &docsis_test_case_21));
9594 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(22, &docsis_test_case_22));
9595 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(23, &docsis_test_case_23));
9596 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(24, &docsis_test_case_24));
9597 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(25, &docsis_test_case_25));
9598 TEST_DOCSIS_COUNT(test_docsis_proto_uplink(26, &docsis_test_case_26));
9601 printf("## %s: %d passed out of %d (%d skipped)\n",
9608 test_DOCSIS_PROTO_downlink_all(void)
9610 int p = 0, s = 0, f = 0, n = 0;
9612 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(1, &docsis_test_case_1));
9613 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(2, &docsis_test_case_2));
9614 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(3, &docsis_test_case_3));
9615 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(4, &docsis_test_case_4));
9616 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(5, &docsis_test_case_5));
9617 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(6, &docsis_test_case_6));
9618 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(7, &docsis_test_case_7));
9619 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(8, &docsis_test_case_8));
9620 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(9, &docsis_test_case_9));
9621 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(10, &docsis_test_case_10));
9622 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(11, &docsis_test_case_11));
9623 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(12, &docsis_test_case_12));
9624 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(13, &docsis_test_case_13));
9625 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(14, &docsis_test_case_14));
9626 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(15, &docsis_test_case_15));
9627 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(16, &docsis_test_case_16));
9628 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(17, &docsis_test_case_17));
9629 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(18, &docsis_test_case_18));
9630 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(19, &docsis_test_case_19));
9631 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(20, &docsis_test_case_20));
9632 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(21, &docsis_test_case_21));
9633 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(22, &docsis_test_case_22));
9634 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(23, &docsis_test_case_23));
9635 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(24, &docsis_test_case_24));
9636 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(25, &docsis_test_case_25));
9637 TEST_DOCSIS_COUNT(test_docsis_proto_downlink(26, &docsis_test_case_26));
9640 printf("## %s: %d passed out of %d (%d skipped)\n",
9647 test_DOCSIS_PROTO_all(void)
9649 struct crypto_testsuite_params *ts_params = &testsuite_params;
9650 struct crypto_unittest_params *ut_params = &unittest_params;
9651 struct rte_cryptodev_info dev_info;
9654 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
9655 uint64_t feat_flags = dev_info.feature_flags;
9657 if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY))
9658 return TEST_SKIPPED;
9660 /* Set action type */
9661 ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
9662 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
9665 if (security_proto_supported(ut_params->type,
9666 RTE_SECURITY_PROTOCOL_DOCSIS) < 0)
9667 return TEST_SKIPPED;
9669 status = test_DOCSIS_PROTO_uplink_all();
9670 status += test_DOCSIS_PROTO_downlink_all();
9675 return TEST_SUCCESS;
9680 test_AES_GCM_authenticated_encryption_test_case_1(void)
9682 return test_authenticated_encryption(&gcm_test_case_1);
9686 test_AES_GCM_authenticated_encryption_test_case_2(void)
9688 return test_authenticated_encryption(&gcm_test_case_2);
9692 test_AES_GCM_authenticated_encryption_test_case_3(void)
9694 return test_authenticated_encryption(&gcm_test_case_3);
9698 test_AES_GCM_authenticated_encryption_test_case_4(void)
9700 return test_authenticated_encryption(&gcm_test_case_4);
9704 test_AES_GCM_authenticated_encryption_test_case_5(void)
9706 return test_authenticated_encryption(&gcm_test_case_5);
9710 test_AES_GCM_authenticated_encryption_test_case_6(void)
9712 return test_authenticated_encryption(&gcm_test_case_6);
9716 test_AES_GCM_authenticated_encryption_test_case_7(void)
9718 return test_authenticated_encryption(&gcm_test_case_7);
9722 test_AES_GCM_authenticated_encryption_test_case_8(void)
9724 return test_authenticated_encryption(&gcm_test_case_8);
9728 test_AES_GCM_J0_authenticated_encryption_test_case_1(void)
9730 return test_authenticated_encryption(&gcm_J0_test_case_1);
9734 test_AES_GCM_auth_encryption_test_case_192_1(void)
9736 return test_authenticated_encryption(&gcm_test_case_192_1);
9740 test_AES_GCM_auth_encryption_test_case_192_2(void)
9742 return test_authenticated_encryption(&gcm_test_case_192_2);
9746 test_AES_GCM_auth_encryption_test_case_192_3(void)
9748 return test_authenticated_encryption(&gcm_test_case_192_3);
9752 test_AES_GCM_auth_encryption_test_case_192_4(void)
9754 return test_authenticated_encryption(&gcm_test_case_192_4);
9758 test_AES_GCM_auth_encryption_test_case_192_5(void)
9760 return test_authenticated_encryption(&gcm_test_case_192_5);
9764 test_AES_GCM_auth_encryption_test_case_192_6(void)
9766 return test_authenticated_encryption(&gcm_test_case_192_6);
9770 test_AES_GCM_auth_encryption_test_case_192_7(void)
9772 return test_authenticated_encryption(&gcm_test_case_192_7);
9776 test_AES_GCM_auth_encryption_test_case_256_1(void)
9778 return test_authenticated_encryption(&gcm_test_case_256_1);
9782 test_AES_GCM_auth_encryption_test_case_256_2(void)
9784 return test_authenticated_encryption(&gcm_test_case_256_2);
9788 test_AES_GCM_auth_encryption_test_case_256_3(void)
9790 return test_authenticated_encryption(&gcm_test_case_256_3);
9794 test_AES_GCM_auth_encryption_test_case_256_4(void)
9796 return test_authenticated_encryption(&gcm_test_case_256_4);
9800 test_AES_GCM_auth_encryption_test_case_256_5(void)
9802 return test_authenticated_encryption(&gcm_test_case_256_5);
9806 test_AES_GCM_auth_encryption_test_case_256_6(void)
9808 return test_authenticated_encryption(&gcm_test_case_256_6);
9812 test_AES_GCM_auth_encryption_test_case_256_7(void)
9814 return test_authenticated_encryption(&gcm_test_case_256_7);
9818 test_AES_GCM_auth_encryption_test_case_aad_1(void)
9820 return test_authenticated_encryption(&gcm_test_case_aad_1);
9824 test_AES_GCM_auth_encryption_test_case_aad_2(void)
9826 return test_authenticated_encryption(&gcm_test_case_aad_2);
9830 test_AES_GCM_auth_encryption_fail_iv_corrupt(void)
9832 struct aead_test_data tdata;
9835 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9836 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9837 tdata.iv.data[0] += 1;
9838 res = test_authenticated_encryption(&tdata);
9839 if (res == TEST_SKIPPED)
9841 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9842 return TEST_SUCCESS;
9846 test_AES_GCM_auth_encryption_fail_in_data_corrupt(void)
9848 struct aead_test_data tdata;
9851 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9852 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9853 tdata.plaintext.data[0] += 1;
9854 res = test_authenticated_encryption(&tdata);
9855 if (res == TEST_SKIPPED)
9857 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9858 return TEST_SUCCESS;
9862 test_AES_GCM_auth_encryption_fail_out_data_corrupt(void)
9864 struct aead_test_data tdata;
9867 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9868 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9869 tdata.ciphertext.data[0] += 1;
9870 res = test_authenticated_encryption(&tdata);
9871 if (res == TEST_SKIPPED)
9873 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9874 return TEST_SUCCESS;
9878 test_AES_GCM_auth_encryption_fail_aad_len_corrupt(void)
9880 struct aead_test_data tdata;
9883 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9884 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9886 res = test_authenticated_encryption(&tdata);
9887 if (res == TEST_SKIPPED)
9889 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9890 return TEST_SUCCESS;
9894 test_AES_GCM_auth_encryption_fail_aad_corrupt(void)
9896 struct aead_test_data tdata;
9897 uint8_t aad[gcm_test_case_7.aad.len];
9900 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9901 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9902 memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
9904 tdata.aad.data = aad;
9905 res = test_authenticated_encryption(&tdata);
9906 if (res == TEST_SKIPPED)
9908 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9909 return TEST_SUCCESS;
9913 test_AES_GCM_auth_encryption_fail_tag_corrupt(void)
9915 struct aead_test_data tdata;
9918 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9919 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9920 tdata.auth_tag.data[0] += 1;
9921 res = test_authenticated_encryption(&tdata);
9922 if (res == TEST_SKIPPED)
9924 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9925 return TEST_SUCCESS;
9929 test_authenticated_decryption(const struct aead_test_data *tdata)
9931 struct crypto_testsuite_params *ts_params = &testsuite_params;
9932 struct crypto_unittest_params *ut_params = &unittest_params;
9937 struct rte_cryptodev_info dev_info;
9939 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
9940 uint64_t feat_flags = dev_info.feature_flags;
9942 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
9943 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
9944 printf("Device doesn't support RAW data-path APIs.\n");
9945 return TEST_SKIPPED;
9948 /* Verify the capabilities */
9949 struct rte_cryptodev_sym_capability_idx cap_idx;
9950 const struct rte_cryptodev_symmetric_capability *capability;
9951 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
9952 cap_idx.algo.aead = tdata->algo;
9953 capability = rte_cryptodev_sym_capability_get(
9954 ts_params->valid_devs[0], &cap_idx);
9955 if (capability == NULL)
9956 return TEST_SKIPPED;
9957 if (rte_cryptodev_sym_capability_check_aead(
9958 capability, tdata->key.len, tdata->auth_tag.len,
9959 tdata->aad.len, tdata->iv.len))
9960 return TEST_SKIPPED;
9962 /* Create AEAD session */
9963 retval = create_aead_session(ts_params->valid_devs[0],
9965 RTE_CRYPTO_AEAD_OP_DECRYPT,
9966 tdata->key.data, tdata->key.len,
9967 tdata->aad.len, tdata->auth_tag.len,
9972 /* alloc mbuf and set payload */
9973 if (tdata->aad.len > MBUF_SIZE) {
9974 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
9975 /* Populate full size of add data */
9976 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
9977 memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
9979 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9981 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9982 rte_pktmbuf_tailroom(ut_params->ibuf));
9984 /* Create AEAD operation */
9985 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
9989 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9991 ut_params->op->sym->m_src = ut_params->ibuf;
9993 /* Process crypto operation */
9994 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
9995 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
9996 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
9997 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
9998 ut_params->op, 0, 0, 0, 0);
10000 TEST_ASSERT_NOT_NULL(
10001 process_crypto_request(ts_params->valid_devs[0],
10002 ut_params->op), "failed to process sym crypto op");
10004 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10005 "crypto op processing failed");
10007 if (ut_params->op->sym->m_dst)
10008 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
10011 plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
10013 ut_params->op->sym->cipher.data.offset);
10015 debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
10017 /* Validate obuf */
10018 TEST_ASSERT_BUFFERS_ARE_EQUAL(
10020 tdata->plaintext.data,
10021 tdata->plaintext.len,
10022 "Plaintext data not as expected");
10024 TEST_ASSERT_EQUAL(ut_params->op->status,
10025 RTE_CRYPTO_OP_STATUS_SUCCESS,
10026 "Authentication failed");
10032 test_AES_GCM_authenticated_decryption_test_case_1(void)
10034 return test_authenticated_decryption(&gcm_test_case_1);
10038 test_AES_GCM_authenticated_decryption_test_case_2(void)
10040 return test_authenticated_decryption(&gcm_test_case_2);
10044 test_AES_GCM_authenticated_decryption_test_case_3(void)
10046 return test_authenticated_decryption(&gcm_test_case_3);
10050 test_AES_GCM_authenticated_decryption_test_case_4(void)
10052 return test_authenticated_decryption(&gcm_test_case_4);
10056 test_AES_GCM_authenticated_decryption_test_case_5(void)
10058 return test_authenticated_decryption(&gcm_test_case_5);
10062 test_AES_GCM_authenticated_decryption_test_case_6(void)
10064 return test_authenticated_decryption(&gcm_test_case_6);
10068 test_AES_GCM_authenticated_decryption_test_case_7(void)
10070 return test_authenticated_decryption(&gcm_test_case_7);
10074 test_AES_GCM_authenticated_decryption_test_case_8(void)
10076 return test_authenticated_decryption(&gcm_test_case_8);
10080 test_AES_GCM_J0_authenticated_decryption_test_case_1(void)
10082 return test_authenticated_decryption(&gcm_J0_test_case_1);
10086 test_AES_GCM_auth_decryption_test_case_192_1(void)
10088 return test_authenticated_decryption(&gcm_test_case_192_1);
10092 test_AES_GCM_auth_decryption_test_case_192_2(void)
10094 return test_authenticated_decryption(&gcm_test_case_192_2);
10098 test_AES_GCM_auth_decryption_test_case_192_3(void)
10100 return test_authenticated_decryption(&gcm_test_case_192_3);
10104 test_AES_GCM_auth_decryption_test_case_192_4(void)
10106 return test_authenticated_decryption(&gcm_test_case_192_4);
10110 test_AES_GCM_auth_decryption_test_case_192_5(void)
10112 return test_authenticated_decryption(&gcm_test_case_192_5);
10116 test_AES_GCM_auth_decryption_test_case_192_6(void)
10118 return test_authenticated_decryption(&gcm_test_case_192_6);
10122 test_AES_GCM_auth_decryption_test_case_192_7(void)
10124 return test_authenticated_decryption(&gcm_test_case_192_7);
10128 test_AES_GCM_auth_decryption_test_case_256_1(void)
10130 return test_authenticated_decryption(&gcm_test_case_256_1);
10134 test_AES_GCM_auth_decryption_test_case_256_2(void)
10136 return test_authenticated_decryption(&gcm_test_case_256_2);
10140 test_AES_GCM_auth_decryption_test_case_256_3(void)
10142 return test_authenticated_decryption(&gcm_test_case_256_3);
10146 test_AES_GCM_auth_decryption_test_case_256_4(void)
10148 return test_authenticated_decryption(&gcm_test_case_256_4);
10152 test_AES_GCM_auth_decryption_test_case_256_5(void)
10154 return test_authenticated_decryption(&gcm_test_case_256_5);
10158 test_AES_GCM_auth_decryption_test_case_256_6(void)
10160 return test_authenticated_decryption(&gcm_test_case_256_6);
10164 test_AES_GCM_auth_decryption_test_case_256_7(void)
10166 return test_authenticated_decryption(&gcm_test_case_256_7);
10170 test_AES_GCM_auth_decryption_test_case_aad_1(void)
10172 return test_authenticated_decryption(&gcm_test_case_aad_1);
10176 test_AES_GCM_auth_decryption_test_case_aad_2(void)
10178 return test_authenticated_decryption(&gcm_test_case_aad_2);
10182 test_AES_GCM_auth_decryption_fail_iv_corrupt(void)
10184 struct aead_test_data tdata;
10187 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10188 tdata.iv.data[0] += 1;
10189 res = test_authenticated_decryption(&tdata);
10190 if (res == TEST_SKIPPED)
10192 TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10193 return TEST_SUCCESS;
10197 test_AES_GCM_auth_decryption_fail_in_data_corrupt(void)
10199 struct aead_test_data tdata;
10202 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10203 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10204 tdata.plaintext.data[0] += 1;
10205 res = test_authenticated_decryption(&tdata);
10206 if (res == TEST_SKIPPED)
10208 TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10209 return TEST_SUCCESS;
10213 test_AES_GCM_auth_decryption_fail_out_data_corrupt(void)
10215 struct aead_test_data tdata;
10218 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10219 tdata.ciphertext.data[0] += 1;
10220 res = test_authenticated_decryption(&tdata);
10221 if (res == TEST_SKIPPED)
10223 TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10224 return TEST_SUCCESS;
10228 test_AES_GCM_auth_decryption_fail_aad_len_corrupt(void)
10230 struct aead_test_data tdata;
10233 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10234 tdata.aad.len += 1;
10235 res = test_authenticated_decryption(&tdata);
10236 if (res == TEST_SKIPPED)
10238 TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10239 return TEST_SUCCESS;
10243 test_AES_GCM_auth_decryption_fail_aad_corrupt(void)
10245 struct aead_test_data tdata;
10246 uint8_t aad[gcm_test_case_7.aad.len];
10249 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10250 memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
10252 tdata.aad.data = aad;
10253 res = test_authenticated_decryption(&tdata);
10254 if (res == TEST_SKIPPED)
10256 TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10257 return TEST_SUCCESS;
10261 test_AES_GCM_auth_decryption_fail_tag_corrupt(void)
10263 struct aead_test_data tdata;
10266 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10267 tdata.auth_tag.data[0] += 1;
10268 res = test_authenticated_decryption(&tdata);
10269 if (res == TEST_SKIPPED)
10271 TEST_ASSERT_EQUAL(res, TEST_FAILED, "authentication not failed");
10272 return TEST_SUCCESS;
10276 test_authenticated_encryption_oop(const struct aead_test_data *tdata)
10278 struct crypto_testsuite_params *ts_params = &testsuite_params;
10279 struct crypto_unittest_params *ut_params = &unittest_params;
10282 uint8_t *ciphertext, *auth_tag;
10283 uint16_t plaintext_pad_len;
10285 /* Verify the capabilities */
10286 struct rte_cryptodev_sym_capability_idx cap_idx;
10287 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10288 cap_idx.algo.aead = tdata->algo;
10289 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10291 return TEST_SKIPPED;
10293 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10294 return TEST_SKIPPED;
10296 /* not supported with CPU crypto */
10297 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10298 return TEST_SKIPPED;
10300 /* Create AEAD session */
10301 retval = create_aead_session(ts_params->valid_devs[0],
10303 RTE_CRYPTO_AEAD_OP_ENCRYPT,
10304 tdata->key.data, tdata->key.len,
10305 tdata->aad.len, tdata->auth_tag.len,
10310 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10311 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10313 /* clear mbuf payload */
10314 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10315 rte_pktmbuf_tailroom(ut_params->ibuf));
10316 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
10317 rte_pktmbuf_tailroom(ut_params->obuf));
10319 /* Create AEAD operation */
10320 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
10324 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10326 ut_params->op->sym->m_src = ut_params->ibuf;
10327 ut_params->op->sym->m_dst = ut_params->obuf;
10329 /* Process crypto operation */
10330 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
10331 ut_params->op), "failed to process sym crypto op");
10333 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10334 "crypto op processing failed");
10336 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
10338 ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
10339 ut_params->op->sym->cipher.data.offset);
10340 auth_tag = ciphertext + plaintext_pad_len;
10342 debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
10343 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
10345 /* Validate obuf */
10346 TEST_ASSERT_BUFFERS_ARE_EQUAL(
10348 tdata->ciphertext.data,
10349 tdata->ciphertext.len,
10350 "Ciphertext data not as expected");
10352 TEST_ASSERT_BUFFERS_ARE_EQUAL(
10354 tdata->auth_tag.data,
10355 tdata->auth_tag.len,
10356 "Generated auth tag not as expected");
10363 test_AES_GCM_authenticated_encryption_oop_test_case_1(void)
10365 return test_authenticated_encryption_oop(&gcm_test_case_5);
10369 test_authenticated_decryption_oop(const struct aead_test_data *tdata)
10371 struct crypto_testsuite_params *ts_params = &testsuite_params;
10372 struct crypto_unittest_params *ut_params = &unittest_params;
10375 uint8_t *plaintext;
10377 /* Verify the capabilities */
10378 struct rte_cryptodev_sym_capability_idx cap_idx;
10379 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10380 cap_idx.algo.aead = tdata->algo;
10381 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10383 return TEST_SKIPPED;
10385 /* not supported with CPU crypto and raw data-path APIs*/
10386 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO ||
10387 global_api_test_type == CRYPTODEV_RAW_API_TEST)
10388 return TEST_SKIPPED;
10390 /* Create AEAD session */
10391 retval = create_aead_session(ts_params->valid_devs[0],
10393 RTE_CRYPTO_AEAD_OP_DECRYPT,
10394 tdata->key.data, tdata->key.len,
10395 tdata->aad.len, tdata->auth_tag.len,
10400 /* alloc mbuf and set payload */
10401 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10402 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10404 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10405 rte_pktmbuf_tailroom(ut_params->ibuf));
10406 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
10407 rte_pktmbuf_tailroom(ut_params->obuf));
10409 /* Create AEAD operation */
10410 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
10414 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10416 ut_params->op->sym->m_src = ut_params->ibuf;
10417 ut_params->op->sym->m_dst = ut_params->obuf;
10419 /* Process crypto operation */
10420 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
10421 ut_params->op), "failed to process sym crypto op");
10423 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10424 "crypto op processing failed");
10426 plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
10427 ut_params->op->sym->cipher.data.offset);
10429 debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
10431 /* Validate obuf */
10432 TEST_ASSERT_BUFFERS_ARE_EQUAL(
10434 tdata->plaintext.data,
10435 tdata->plaintext.len,
10436 "Plaintext data not as expected");
10438 TEST_ASSERT_EQUAL(ut_params->op->status,
10439 RTE_CRYPTO_OP_STATUS_SUCCESS,
10440 "Authentication failed");
10445 test_AES_GCM_authenticated_decryption_oop_test_case_1(void)
10447 return test_authenticated_decryption_oop(&gcm_test_case_5);
10451 test_authenticated_encryption_sessionless(
10452 const struct aead_test_data *tdata)
10454 struct crypto_testsuite_params *ts_params = &testsuite_params;
10455 struct crypto_unittest_params *ut_params = &unittest_params;
10458 uint8_t *ciphertext, *auth_tag;
10459 uint16_t plaintext_pad_len;
10460 uint8_t key[tdata->key.len + 1];
10461 struct rte_cryptodev_info dev_info;
10463 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10464 uint64_t feat_flags = dev_info.feature_flags;
10466 if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
10467 printf("Device doesn't support Sessionless ops.\n");
10468 return TEST_SKIPPED;
10471 /* not supported with CPU crypto */
10472 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10473 return TEST_SKIPPED;
10475 /* Verify the capabilities */
10476 struct rte_cryptodev_sym_capability_idx cap_idx;
10477 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10478 cap_idx.algo.aead = tdata->algo;
10479 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10481 return TEST_SKIPPED;
10483 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10485 /* clear mbuf payload */
10486 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10487 rte_pktmbuf_tailroom(ut_params->ibuf));
10489 /* Create AEAD operation */
10490 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
10494 /* Create GCM xform */
10495 memcpy(key, tdata->key.data, tdata->key.len);
10496 retval = create_aead_xform(ut_params->op,
10498 RTE_CRYPTO_AEAD_OP_ENCRYPT,
10499 key, tdata->key.len,
10500 tdata->aad.len, tdata->auth_tag.len,
10505 ut_params->op->sym->m_src = ut_params->ibuf;
10507 TEST_ASSERT_EQUAL(ut_params->op->sess_type,
10508 RTE_CRYPTO_OP_SESSIONLESS,
10509 "crypto op session type not sessionless");
10511 /* Process crypto operation */
10512 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
10513 ut_params->op), "failed to process sym crypto op");
10515 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
10517 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10518 "crypto op status not success");
10520 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
10522 ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
10523 ut_params->op->sym->cipher.data.offset);
10524 auth_tag = ciphertext + plaintext_pad_len;
10526 debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
10527 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
10529 /* Validate obuf */
10530 TEST_ASSERT_BUFFERS_ARE_EQUAL(
10532 tdata->ciphertext.data,
10533 tdata->ciphertext.len,
10534 "Ciphertext data not as expected");
10536 TEST_ASSERT_BUFFERS_ARE_EQUAL(
10538 tdata->auth_tag.data,
10539 tdata->auth_tag.len,
10540 "Generated auth tag not as expected");
10547 test_AES_GCM_authenticated_encryption_sessionless_test_case_1(void)
10549 return test_authenticated_encryption_sessionless(
10554 test_authenticated_decryption_sessionless(
10555 const struct aead_test_data *tdata)
10557 struct crypto_testsuite_params *ts_params = &testsuite_params;
10558 struct crypto_unittest_params *ut_params = &unittest_params;
10561 uint8_t *plaintext;
10562 uint8_t key[tdata->key.len + 1];
10563 struct rte_cryptodev_info dev_info;
10565 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10566 uint64_t feat_flags = dev_info.feature_flags;
10568 if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
10569 printf("Device doesn't support Sessionless ops.\n");
10570 return TEST_SKIPPED;
10573 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10574 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10575 printf("Device doesn't support RAW data-path APIs.\n");
10576 return TEST_SKIPPED;
10579 /* not supported with CPU crypto */
10580 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10581 return TEST_SKIPPED;
10583 /* Verify the capabilities */
10584 struct rte_cryptodev_sym_capability_idx cap_idx;
10585 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10586 cap_idx.algo.aead = tdata->algo;
10587 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10589 return TEST_SKIPPED;
10591 /* alloc mbuf and set payload */
10592 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10594 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10595 rte_pktmbuf_tailroom(ut_params->ibuf));
10597 /* Create AEAD operation */
10598 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
10602 /* Create AEAD xform */
10603 memcpy(key, tdata->key.data, tdata->key.len);
10604 retval = create_aead_xform(ut_params->op,
10606 RTE_CRYPTO_AEAD_OP_DECRYPT,
10607 key, tdata->key.len,
10608 tdata->aad.len, tdata->auth_tag.len,
10613 ut_params->op->sym->m_src = ut_params->ibuf;
10615 TEST_ASSERT_EQUAL(ut_params->op->sess_type,
10616 RTE_CRYPTO_OP_SESSIONLESS,
10617 "crypto op session type not sessionless");
10619 /* Process crypto operation */
10620 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10621 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10622 ut_params->op, 0, 0, 0, 0);
10624 TEST_ASSERT_NOT_NULL(process_crypto_request(
10625 ts_params->valid_devs[0], ut_params->op),
10626 "failed to process sym crypto op");
10628 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
10630 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10631 "crypto op status not success");
10633 plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
10634 ut_params->op->sym->cipher.data.offset);
10636 debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
10638 /* Validate obuf */
10639 TEST_ASSERT_BUFFERS_ARE_EQUAL(
10641 tdata->plaintext.data,
10642 tdata->plaintext.len,
10643 "Plaintext data not as expected");
10645 TEST_ASSERT_EQUAL(ut_params->op->status,
10646 RTE_CRYPTO_OP_STATUS_SUCCESS,
10647 "Authentication failed");
10652 test_AES_GCM_authenticated_decryption_sessionless_test_case_1(void)
10654 return test_authenticated_decryption_sessionless(
10659 test_AES_CCM_authenticated_encryption_test_case_128_1(void)
10661 return test_authenticated_encryption(&ccm_test_case_128_1);
10665 test_AES_CCM_authenticated_encryption_test_case_128_2(void)
10667 return test_authenticated_encryption(&ccm_test_case_128_2);
10671 test_AES_CCM_authenticated_encryption_test_case_128_3(void)
10673 return test_authenticated_encryption(&ccm_test_case_128_3);
10677 test_AES_CCM_authenticated_decryption_test_case_128_1(void)
10679 return test_authenticated_decryption(&ccm_test_case_128_1);
10683 test_AES_CCM_authenticated_decryption_test_case_128_2(void)
10685 return test_authenticated_decryption(&ccm_test_case_128_2);
10689 test_AES_CCM_authenticated_decryption_test_case_128_3(void)
10691 return test_authenticated_decryption(&ccm_test_case_128_3);
10695 test_AES_CCM_authenticated_encryption_test_case_192_1(void)
10697 return test_authenticated_encryption(&ccm_test_case_192_1);
10701 test_AES_CCM_authenticated_encryption_test_case_192_2(void)
10703 return test_authenticated_encryption(&ccm_test_case_192_2);
10707 test_AES_CCM_authenticated_encryption_test_case_192_3(void)
10709 return test_authenticated_encryption(&ccm_test_case_192_3);
10713 test_AES_CCM_authenticated_decryption_test_case_192_1(void)
10715 return test_authenticated_decryption(&ccm_test_case_192_1);
10719 test_AES_CCM_authenticated_decryption_test_case_192_2(void)
10721 return test_authenticated_decryption(&ccm_test_case_192_2);
10725 test_AES_CCM_authenticated_decryption_test_case_192_3(void)
10727 return test_authenticated_decryption(&ccm_test_case_192_3);
10731 test_AES_CCM_authenticated_encryption_test_case_256_1(void)
10733 return test_authenticated_encryption(&ccm_test_case_256_1);
10737 test_AES_CCM_authenticated_encryption_test_case_256_2(void)
10739 return test_authenticated_encryption(&ccm_test_case_256_2);
10743 test_AES_CCM_authenticated_encryption_test_case_256_3(void)
10745 return test_authenticated_encryption(&ccm_test_case_256_3);
10749 test_AES_CCM_authenticated_decryption_test_case_256_1(void)
10751 return test_authenticated_decryption(&ccm_test_case_256_1);
10755 test_AES_CCM_authenticated_decryption_test_case_256_2(void)
10757 return test_authenticated_decryption(&ccm_test_case_256_2);
10761 test_AES_CCM_authenticated_decryption_test_case_256_3(void)
10763 return test_authenticated_decryption(&ccm_test_case_256_3);
10769 struct crypto_testsuite_params *ts_params = &testsuite_params;
10770 struct rte_cryptodev_stats stats;
10772 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10773 return TEST_SKIPPED;
10775 /* Verify the capabilities */
10776 struct rte_cryptodev_sym_capability_idx cap_idx;
10777 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10778 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
10779 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10781 return TEST_SKIPPED;
10782 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10783 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
10784 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10786 return TEST_SKIPPED;
10788 if (rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
10790 return TEST_SKIPPED;
10792 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
10793 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
10794 &stats) == -ENODEV),
10795 "rte_cryptodev_stats_get invalid dev failed");
10796 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
10797 "rte_cryptodev_stats_get invalid Param failed");
10799 /* Test expected values */
10800 test_AES_CBC_HMAC_SHA1_encrypt_digest();
10801 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
10803 "rte_cryptodev_stats_get failed");
10804 TEST_ASSERT((stats.enqueued_count == 1),
10805 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10806 TEST_ASSERT((stats.dequeued_count == 1),
10807 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10808 TEST_ASSERT((stats.enqueue_err_count == 0),
10809 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10810 TEST_ASSERT((stats.dequeue_err_count == 0),
10811 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10813 /* invalid device but should ignore and not reset device stats*/
10814 rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
10815 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
10817 "rte_cryptodev_stats_get failed");
10818 TEST_ASSERT((stats.enqueued_count == 1),
10819 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10821 /* check that a valid reset clears stats */
10822 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
10823 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
10825 "rte_cryptodev_stats_get failed");
10826 TEST_ASSERT((stats.enqueued_count == 0),
10827 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10828 TEST_ASSERT((stats.dequeued_count == 0),
10829 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10831 return TEST_SUCCESS;
10834 static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
10835 struct crypto_unittest_params *ut_params,
10836 enum rte_crypto_auth_operation op,
10837 const struct HMAC_MD5_vector *test_case)
10841 memcpy(key, test_case->key.data, test_case->key.len);
10843 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10844 ut_params->auth_xform.next = NULL;
10845 ut_params->auth_xform.auth.op = op;
10847 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC;
10849 ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN;
10850 ut_params->auth_xform.auth.key.length = test_case->key.len;
10851 ut_params->auth_xform.auth.key.data = key;
10853 ut_params->sess = rte_cryptodev_sym_session_create(
10854 ts_params->session_mpool);
10856 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10857 ut_params->sess, &ut_params->auth_xform,
10858 ts_params->session_priv_mpool);
10860 if (ut_params->sess == NULL)
10861 return TEST_FAILED;
10863 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10865 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10866 rte_pktmbuf_tailroom(ut_params->ibuf));
10871 static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
10872 const struct HMAC_MD5_vector *test_case,
10873 uint8_t **plaintext)
10875 uint16_t plaintext_pad_len;
10877 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
10879 plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
10882 *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
10883 plaintext_pad_len);
10884 memcpy(*plaintext, test_case->plaintext.data,
10885 test_case->plaintext.len);
10887 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
10888 ut_params->ibuf, MD5_DIGEST_LEN);
10889 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
10890 "no room to append digest");
10891 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
10892 ut_params->ibuf, plaintext_pad_len);
10894 if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
10895 rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data,
10896 test_case->auth_tag.len);
10899 sym_op->auth.data.offset = 0;
10900 sym_op->auth.data.length = test_case->plaintext.len;
10902 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10903 ut_params->op->sym->m_src = ut_params->ibuf;
10909 test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
10911 uint16_t plaintext_pad_len;
10912 uint8_t *plaintext, *auth_tag;
10914 struct crypto_testsuite_params *ts_params = &testsuite_params;
10915 struct crypto_unittest_params *ut_params = &unittest_params;
10916 struct rte_cryptodev_info dev_info;
10918 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10919 uint64_t feat_flags = dev_info.feature_flags;
10921 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10922 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10923 printf("Device doesn't support RAW data-path APIs.\n");
10924 return TEST_SKIPPED;
10927 /* Verify the capabilities */
10928 struct rte_cryptodev_sym_capability_idx cap_idx;
10929 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10930 cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
10931 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10933 return TEST_SKIPPED;
10935 if (MD5_HMAC_create_session(ts_params, ut_params,
10936 RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
10937 return TEST_FAILED;
10939 /* Generate Crypto op data structure */
10940 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10941 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10942 TEST_ASSERT_NOT_NULL(ut_params->op,
10943 "Failed to allocate symmetric crypto operation struct");
10945 plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
10948 if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
10949 return TEST_FAILED;
10951 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10952 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
10954 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10955 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10956 ut_params->op, 0, 1, 0, 0);
10958 TEST_ASSERT_NOT_NULL(
10959 process_crypto_request(ts_params->valid_devs[0],
10961 "failed to process sym crypto op");
10963 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10964 "crypto op processing failed");
10966 if (ut_params->op->sym->m_dst) {
10967 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
10968 uint8_t *, plaintext_pad_len);
10970 auth_tag = plaintext + plaintext_pad_len;
10973 TEST_ASSERT_BUFFERS_ARE_EQUAL(
10975 test_case->auth_tag.data,
10976 test_case->auth_tag.len,
10977 "HMAC_MD5 generated tag not as expected");
10979 return TEST_SUCCESS;
10983 test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
10985 uint8_t *plaintext;
10987 struct crypto_testsuite_params *ts_params = &testsuite_params;
10988 struct crypto_unittest_params *ut_params = &unittest_params;
10989 struct rte_cryptodev_info dev_info;
10991 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10992 uint64_t feat_flags = dev_info.feature_flags;
10994 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10995 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10996 printf("Device doesn't support RAW data-path APIs.\n");
10997 return TEST_SKIPPED;
11000 /* Verify the capabilities */
11001 struct rte_cryptodev_sym_capability_idx cap_idx;
11002 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11003 cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
11004 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11006 return TEST_SKIPPED;
11008 if (MD5_HMAC_create_session(ts_params, ut_params,
11009 RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
11010 return TEST_FAILED;
11013 /* Generate Crypto op data structure */
11014 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11015 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11016 TEST_ASSERT_NOT_NULL(ut_params->op,
11017 "Failed to allocate symmetric crypto operation struct");
11019 if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
11020 return TEST_FAILED;
11022 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11023 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11025 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11026 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11027 ut_params->op, 0, 1, 0, 0);
11029 TEST_ASSERT_NOT_NULL(
11030 process_crypto_request(ts_params->valid_devs[0],
11032 "failed to process sym crypto op");
11034 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11035 "HMAC_MD5 crypto op processing failed");
11037 return TEST_SUCCESS;
11041 test_MD5_HMAC_generate_case_1(void)
11043 return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1);
11047 test_MD5_HMAC_verify_case_1(void)
11049 return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1);
11053 test_MD5_HMAC_generate_case_2(void)
11055 return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2);
11059 test_MD5_HMAC_verify_case_2(void)
11061 return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2);
11065 test_multi_session(void)
11067 struct crypto_testsuite_params *ts_params = &testsuite_params;
11068 struct crypto_unittest_params *ut_params = &unittest_params;
11070 struct rte_cryptodev_info dev_info;
11071 struct rte_cryptodev_sym_session **sessions;
11075 /* Verify the capabilities */
11076 struct rte_cryptodev_sym_capability_idx cap_idx;
11077 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11078 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
11079 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11081 return TEST_SKIPPED;
11082 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11083 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
11084 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11086 return TEST_SKIPPED;
11088 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
11089 aes_cbc_key, hmac_sha512_key);
11092 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11094 sessions = rte_malloc(NULL,
11095 sizeof(struct rte_cryptodev_sym_session *) *
11096 (MAX_NB_SESSIONS + 1), 0);
11098 /* Create multiple crypto sessions*/
11099 for (i = 0; i < MAX_NB_SESSIONS; i++) {
11101 sessions[i] = rte_cryptodev_sym_session_create(
11102 ts_params->session_mpool);
11104 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11105 sessions[i], &ut_params->auth_xform,
11106 ts_params->session_priv_mpool);
11107 TEST_ASSERT_NOT_NULL(sessions[i],
11108 "Session creation failed at session number %u",
11111 /* Attempt to send a request on each session */
11112 TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform(
11116 catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
11117 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
11119 "Failed to perform decrypt on request number %u.", i);
11120 /* free crypto operation structure */
11122 rte_crypto_op_free(ut_params->op);
11125 * free mbuf - both obuf and ibuf are usually the same,
11126 * so check if they point at the same address is necessary,
11127 * to avoid freeing the mbuf twice.
11129 if (ut_params->obuf) {
11130 rte_pktmbuf_free(ut_params->obuf);
11131 if (ut_params->ibuf == ut_params->obuf)
11132 ut_params->ibuf = 0;
11133 ut_params->obuf = 0;
11135 if (ut_params->ibuf) {
11136 rte_pktmbuf_free(ut_params->ibuf);
11137 ut_params->ibuf = 0;
11141 sessions[i] = NULL;
11142 /* Next session create should fail */
11143 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11144 sessions[i], &ut_params->auth_xform,
11145 ts_params->session_priv_mpool);
11146 TEST_ASSERT_NULL(sessions[i],
11147 "Session creation succeeded unexpectedly!");
11149 for (i = 0; i < MAX_NB_SESSIONS; i++) {
11150 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
11152 rte_cryptodev_sym_session_free(sessions[i]);
11155 rte_free(sessions);
11157 return TEST_SUCCESS;
11160 struct multi_session_params {
11161 struct crypto_unittest_params ut_params;
11162 uint8_t *cipher_key;
11164 const uint8_t *cipher;
11165 const uint8_t *digest;
11169 #define MB_SESSION_NUMBER 3
11172 test_multi_session_random_usage(void)
11174 struct crypto_testsuite_params *ts_params = &testsuite_params;
11175 struct rte_cryptodev_info dev_info;
11176 struct rte_cryptodev_sym_session **sessions;
11178 struct multi_session_params ut_paramz[] = {
11181 .cipher_key = ms_aes_cbc_key0,
11182 .hmac_key = ms_hmac_key0,
11183 .cipher = ms_aes_cbc_cipher0,
11184 .digest = ms_hmac_digest0,
11185 .iv = ms_aes_cbc_iv0
11188 .cipher_key = ms_aes_cbc_key1,
11189 .hmac_key = ms_hmac_key1,
11190 .cipher = ms_aes_cbc_cipher1,
11191 .digest = ms_hmac_digest1,
11192 .iv = ms_aes_cbc_iv1
11195 .cipher_key = ms_aes_cbc_key2,
11196 .hmac_key = ms_hmac_key2,
11197 .cipher = ms_aes_cbc_cipher2,
11198 .digest = ms_hmac_digest2,
11199 .iv = ms_aes_cbc_iv2
11204 /* Verify the capabilities */
11205 struct rte_cryptodev_sym_capability_idx cap_idx;
11206 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11207 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
11208 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11210 return TEST_SKIPPED;
11211 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11212 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
11213 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11215 return TEST_SKIPPED;
11217 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11219 sessions = rte_malloc(NULL,
11220 (sizeof(struct rte_cryptodev_sym_session *)
11221 * MAX_NB_SESSIONS) + 1, 0);
11223 for (i = 0; i < MB_SESSION_NUMBER; i++) {
11224 sessions[i] = rte_cryptodev_sym_session_create(
11225 ts_params->session_mpool);
11227 rte_memcpy(&ut_paramz[i].ut_params, &unittest_params,
11228 sizeof(struct crypto_unittest_params));
11230 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
11231 &ut_paramz[i].ut_params,
11232 ut_paramz[i].cipher_key, ut_paramz[i].hmac_key);
11234 /* Create multiple crypto sessions*/
11235 rte_cryptodev_sym_session_init(
11236 ts_params->valid_devs[0],
11238 &ut_paramz[i].ut_params.auth_xform,
11239 ts_params->session_priv_mpool);
11241 TEST_ASSERT_NOT_NULL(sessions[i],
11242 "Session creation failed at session number %u",
11248 for (i = 0; i < 40000; i++) {
11250 j = rand() % MB_SESSION_NUMBER;
11252 TEST_ASSERT_SUCCESS(
11253 test_AES_CBC_HMAC_SHA512_decrypt_perform(
11255 &ut_paramz[j].ut_params,
11256 ts_params, ut_paramz[j].cipher,
11257 ut_paramz[j].digest,
11259 "Failed to perform decrypt on request number %u.", i);
11261 if (ut_paramz[j].ut_params.op)
11262 rte_crypto_op_free(ut_paramz[j].ut_params.op);
11265 * free mbuf - both obuf and ibuf are usually the same,
11266 * so check if they point at the same address is necessary,
11267 * to avoid freeing the mbuf twice.
11269 if (ut_paramz[j].ut_params.obuf) {
11270 rte_pktmbuf_free(ut_paramz[j].ut_params.obuf);
11271 if (ut_paramz[j].ut_params.ibuf
11272 == ut_paramz[j].ut_params.obuf)
11273 ut_paramz[j].ut_params.ibuf = 0;
11274 ut_paramz[j].ut_params.obuf = 0;
11276 if (ut_paramz[j].ut_params.ibuf) {
11277 rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf);
11278 ut_paramz[j].ut_params.ibuf = 0;
11282 for (i = 0; i < MB_SESSION_NUMBER; i++) {
11283 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
11285 rte_cryptodev_sym_session_free(sessions[i]);
11288 rte_free(sessions);
11290 return TEST_SUCCESS;
11293 uint8_t orig_data[] = {0xab, 0xab, 0xab, 0xab,
11294 0xab, 0xab, 0xab, 0xab,
11295 0xab, 0xab, 0xab, 0xab,
11296 0xab, 0xab, 0xab, 0xab};
11299 test_null_invalid_operation(void)
11301 struct crypto_testsuite_params *ts_params = &testsuite_params;
11302 struct crypto_unittest_params *ut_params = &unittest_params;
11305 /* This test is for NULL PMD only */
11306 if (gbl_driver_id != rte_cryptodev_driver_id_get(
11307 RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
11308 return TEST_SKIPPED;
11310 /* Setup Cipher Parameters */
11311 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11312 ut_params->cipher_xform.next = NULL;
11314 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
11315 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
11317 ut_params->sess = rte_cryptodev_sym_session_create(
11318 ts_params->session_mpool);
11320 /* Create Crypto session*/
11321 ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11322 ut_params->sess, &ut_params->cipher_xform,
11323 ts_params->session_priv_mpool);
11324 TEST_ASSERT(ret < 0,
11325 "Session creation succeeded unexpectedly");
11328 /* Setup HMAC Parameters */
11329 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11330 ut_params->auth_xform.next = NULL;
11332 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
11333 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
11335 ut_params->sess = rte_cryptodev_sym_session_create(
11336 ts_params->session_mpool);
11338 /* Create Crypto session*/
11339 ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11340 ut_params->sess, &ut_params->auth_xform,
11341 ts_params->session_priv_mpool);
11342 TEST_ASSERT(ret < 0,
11343 "Session creation succeeded unexpectedly");
11345 return TEST_SUCCESS;
11349 #define NULL_BURST_LENGTH (32)
11352 test_null_burst_operation(void)
11354 struct crypto_testsuite_params *ts_params = &testsuite_params;
11355 struct crypto_unittest_params *ut_params = &unittest_params;
11357 unsigned i, burst_len = NULL_BURST_LENGTH;
11359 struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
11360 struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
11362 /* This test is for NULL PMD only */
11363 if (gbl_driver_id != rte_cryptodev_driver_id_get(
11364 RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
11365 return TEST_SKIPPED;
11367 /* Setup Cipher Parameters */
11368 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11369 ut_params->cipher_xform.next = &ut_params->auth_xform;
11371 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
11372 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
11374 /* Setup HMAC Parameters */
11375 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11376 ut_params->auth_xform.next = NULL;
11378 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
11379 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
11381 ut_params->sess = rte_cryptodev_sym_session_create(
11382 ts_params->session_mpool);
11384 /* Create Crypto session*/
11385 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11386 ut_params->sess, &ut_params->cipher_xform,
11387 ts_params->session_priv_mpool);
11388 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
11390 TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
11391 RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
11392 burst_len, "failed to generate burst of crypto ops");
11394 /* Generate an operation for each mbuf in burst */
11395 for (i = 0; i < burst_len; i++) {
11396 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11398 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
11400 unsigned *data = (unsigned *)rte_pktmbuf_append(m,
11404 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
11406 burst[i]->sym->m_src = m;
11409 /* Process crypto operation */
11410 TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
11411 0, burst, burst_len),
11413 "Error enqueuing burst");
11415 TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
11416 0, burst_dequeued, burst_len),
11418 "Error dequeuing burst");
11421 for (i = 0; i < burst_len; i++) {
11423 *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
11424 *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
11426 "data not as expected");
11428 rte_pktmbuf_free(burst[i]->sym->m_src);
11429 rte_crypto_op_free(burst[i]);
11432 return TEST_SUCCESS;
11436 test_enq_callback(uint16_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops,
11437 uint16_t nb_ops, void *user_param)
11439 RTE_SET_USED(dev_id);
11440 RTE_SET_USED(qp_id);
11442 RTE_SET_USED(user_param);
11444 printf("crypto enqueue callback called\n");
11449 test_deq_callback(uint16_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops,
11450 uint16_t nb_ops, void *user_param)
11452 RTE_SET_USED(dev_id);
11453 RTE_SET_USED(qp_id);
11455 RTE_SET_USED(user_param);
11457 printf("crypto dequeue callback called\n");
11462 * Thread using enqueue/dequeue callback with RCU.
11465 test_enqdeq_callback_thread(void *arg)
11468 /* DP thread calls rte_cryptodev_enqueue_burst()/
11469 * rte_cryptodev_dequeue_burst() and invokes callback.
11471 test_null_burst_operation();
11476 test_enq_callback_setup(void)
11478 struct crypto_testsuite_params *ts_params = &testsuite_params;
11479 struct rte_cryptodev_info dev_info;
11480 struct rte_cryptodev_qp_conf qp_conf = {
11481 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
11484 struct rte_cryptodev_cb *cb;
11485 uint16_t qp_id = 0;
11487 /* Stop the device in case it's started so it can be configured */
11488 rte_cryptodev_stop(ts_params->valid_devs[0]);
11490 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11492 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
11494 "Failed to configure cryptodev %u",
11495 ts_params->valid_devs[0]);
11497 qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
11498 qp_conf.mp_session = ts_params->session_mpool;
11499 qp_conf.mp_session_private = ts_params->session_priv_mpool;
11501 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
11502 ts_params->valid_devs[0], qp_id, &qp_conf,
11503 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
11505 "rte_cryptodev_queue_pair_setup: num_inflights "
11506 "%u on qp %u on cryptodev %u",
11507 qp_conf.nb_descriptors, qp_id,
11508 ts_params->valid_devs[0]);
11510 /* Test with invalid crypto device */
11511 cb = rte_cryptodev_add_enq_callback(RTE_CRYPTO_MAX_DEVS,
11512 qp_id, test_enq_callback, NULL);
11513 TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11514 "cryptodev %u did not fail",
11515 qp_id, RTE_CRYPTO_MAX_DEVS);
11517 /* Test with invalid queue pair */
11518 cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
11519 dev_info.max_nb_queue_pairs + 1,
11520 test_enq_callback, NULL);
11521 TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11522 "cryptodev %u did not fail",
11523 dev_info.max_nb_queue_pairs + 1,
11524 ts_params->valid_devs[0]);
11526 /* Test with NULL callback */
11527 cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
11528 qp_id, NULL, NULL);
11529 TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11530 "cryptodev %u did not fail",
11531 qp_id, ts_params->valid_devs[0]);
11533 /* Test with valid configuration */
11534 cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
11535 qp_id, test_enq_callback, NULL);
11536 TEST_ASSERT_NOT_NULL(cb, "Failed test to add callback on "
11537 "qp %u on cryptodev %u",
11538 qp_id, ts_params->valid_devs[0]);
11540 rte_cryptodev_start(ts_params->valid_devs[0]);
11542 /* Launch a thread */
11543 rte_eal_remote_launch(test_enqdeq_callback_thread, NULL,
11544 rte_get_next_lcore(-1, 1, 0));
11546 /* Wait until reader exited. */
11547 rte_eal_mp_wait_lcore();
11549 /* Test with invalid crypto device */
11550 TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
11551 RTE_CRYPTO_MAX_DEVS, qp_id, cb),
11552 "Expected call to fail as crypto device is invalid");
11554 /* Test with invalid queue pair */
11555 TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
11556 ts_params->valid_devs[0],
11557 dev_info.max_nb_queue_pairs + 1, cb),
11558 "Expected call to fail as queue pair is invalid");
11560 /* Test with NULL callback */
11561 TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
11562 ts_params->valid_devs[0], qp_id, NULL),
11563 "Expected call to fail as callback is NULL");
11565 /* Test with valid configuration */
11566 TEST_ASSERT_SUCCESS(rte_cryptodev_remove_enq_callback(
11567 ts_params->valid_devs[0], qp_id, cb),
11568 "Failed test to remove callback on "
11569 "qp %u on cryptodev %u",
11570 qp_id, ts_params->valid_devs[0]);
11572 return TEST_SUCCESS;
11576 test_deq_callback_setup(void)
11578 struct crypto_testsuite_params *ts_params = &testsuite_params;
11579 struct rte_cryptodev_info dev_info;
11580 struct rte_cryptodev_qp_conf qp_conf = {
11581 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
11584 struct rte_cryptodev_cb *cb;
11585 uint16_t qp_id = 0;
11587 /* Stop the device in case it's started so it can be configured */
11588 rte_cryptodev_stop(ts_params->valid_devs[0]);
11590 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11592 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
11594 "Failed to configure cryptodev %u",
11595 ts_params->valid_devs[0]);
11597 qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
11598 qp_conf.mp_session = ts_params->session_mpool;
11599 qp_conf.mp_session_private = ts_params->session_priv_mpool;
11601 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
11602 ts_params->valid_devs[0], qp_id, &qp_conf,
11603 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
11605 "rte_cryptodev_queue_pair_setup: num_inflights "
11606 "%u on qp %u on cryptodev %u",
11607 qp_conf.nb_descriptors, qp_id,
11608 ts_params->valid_devs[0]);
11610 /* Test with invalid crypto device */
11611 cb = rte_cryptodev_add_deq_callback(RTE_CRYPTO_MAX_DEVS,
11612 qp_id, test_deq_callback, NULL);
11613 TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11614 "cryptodev %u did not fail",
11615 qp_id, RTE_CRYPTO_MAX_DEVS);
11617 /* Test with invalid queue pair */
11618 cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
11619 dev_info.max_nb_queue_pairs + 1,
11620 test_deq_callback, NULL);
11621 TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11622 "cryptodev %u did not fail",
11623 dev_info.max_nb_queue_pairs + 1,
11624 ts_params->valid_devs[0]);
11626 /* Test with NULL callback */
11627 cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
11628 qp_id, NULL, NULL);
11629 TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11630 "cryptodev %u did not fail",
11631 qp_id, ts_params->valid_devs[0]);
11633 /* Test with valid configuration */
11634 cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
11635 qp_id, test_deq_callback, NULL);
11636 TEST_ASSERT_NOT_NULL(cb, "Failed test to add callback on "
11637 "qp %u on cryptodev %u",
11638 qp_id, ts_params->valid_devs[0]);
11640 rte_cryptodev_start(ts_params->valid_devs[0]);
11642 /* Launch a thread */
11643 rte_eal_remote_launch(test_enqdeq_callback_thread, NULL,
11644 rte_get_next_lcore(-1, 1, 0));
11646 /* Wait until reader exited. */
11647 rte_eal_mp_wait_lcore();
11649 /* Test with invalid crypto device */
11650 TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
11651 RTE_CRYPTO_MAX_DEVS, qp_id, cb),
11652 "Expected call to fail as crypto device is invalid");
11654 /* Test with invalid queue pair */
11655 TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
11656 ts_params->valid_devs[0],
11657 dev_info.max_nb_queue_pairs + 1, cb),
11658 "Expected call to fail as queue pair is invalid");
11660 /* Test with NULL callback */
11661 TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
11662 ts_params->valid_devs[0], qp_id, NULL),
11663 "Expected call to fail as callback is NULL");
11665 /* Test with valid configuration */
11666 TEST_ASSERT_SUCCESS(rte_cryptodev_remove_deq_callback(
11667 ts_params->valid_devs[0], qp_id, cb),
11668 "Failed test to remove callback on "
11669 "qp %u on cryptodev %u",
11670 qp_id, ts_params->valid_devs[0]);
11672 return TEST_SUCCESS;
11676 generate_gmac_large_plaintext(uint8_t *data)
11680 for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32)
11681 memcpy(&data[i], &data[0], 32);
11685 create_gmac_operation(enum rte_crypto_auth_operation op,
11686 const struct gmac_test_data *tdata)
11688 struct crypto_testsuite_params *ts_params = &testsuite_params;
11689 struct crypto_unittest_params *ut_params = &unittest_params;
11690 struct rte_crypto_sym_op *sym_op;
11692 uint32_t plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
11694 /* Generate Crypto op data structure */
11695 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11696 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11697 TEST_ASSERT_NOT_NULL(ut_params->op,
11698 "Failed to allocate symmetric crypto operation struct");
11700 sym_op = ut_params->op->sym;
11702 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
11703 ut_params->ibuf, tdata->gmac_tag.len);
11704 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
11705 "no room to append digest");
11707 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
11708 ut_params->ibuf, plaintext_pad_len);
11710 if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
11711 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
11712 tdata->gmac_tag.len);
11713 debug_hexdump(stdout, "digest:",
11714 sym_op->auth.digest.data,
11715 tdata->gmac_tag.len);
11718 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
11719 uint8_t *, IV_OFFSET);
11721 rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
11723 debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
11725 sym_op->cipher.data.length = 0;
11726 sym_op->cipher.data.offset = 0;
11728 sym_op->auth.data.offset = 0;
11729 sym_op->auth.data.length = tdata->plaintext.len;
11735 create_gmac_operation_sgl(enum rte_crypto_auth_operation op,
11736 const struct gmac_test_data *tdata,
11737 void *digest_mem, uint64_t digest_phys)
11739 struct crypto_testsuite_params *ts_params = &testsuite_params;
11740 struct crypto_unittest_params *ut_params = &unittest_params;
11741 struct rte_crypto_sym_op *sym_op;
11743 /* Generate Crypto op data structure */
11744 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11745 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11746 TEST_ASSERT_NOT_NULL(ut_params->op,
11747 "Failed to allocate symmetric crypto operation struct");
11749 sym_op = ut_params->op->sym;
11751 sym_op->auth.digest.data = digest_mem;
11752 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
11753 "no room to append digest");
11755 sym_op->auth.digest.phys_addr = digest_phys;
11757 if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
11758 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
11759 tdata->gmac_tag.len);
11760 debug_hexdump(stdout, "digest:",
11761 sym_op->auth.digest.data,
11762 tdata->gmac_tag.len);
11765 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
11766 uint8_t *, IV_OFFSET);
11768 rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
11770 debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
11772 sym_op->cipher.data.length = 0;
11773 sym_op->cipher.data.offset = 0;
11775 sym_op->auth.data.offset = 0;
11776 sym_op->auth.data.length = tdata->plaintext.len;
11781 static int create_gmac_session(uint8_t dev_id,
11782 const struct gmac_test_data *tdata,
11783 enum rte_crypto_auth_operation auth_op)
11785 uint8_t auth_key[tdata->key.len];
11787 struct crypto_testsuite_params *ts_params = &testsuite_params;
11788 struct crypto_unittest_params *ut_params = &unittest_params;
11790 memcpy(auth_key, tdata->key.data, tdata->key.len);
11792 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11793 ut_params->auth_xform.next = NULL;
11795 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
11796 ut_params->auth_xform.auth.op = auth_op;
11797 ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
11798 ut_params->auth_xform.auth.key.length = tdata->key.len;
11799 ut_params->auth_xform.auth.key.data = auth_key;
11800 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
11801 ut_params->auth_xform.auth.iv.length = tdata->iv.len;
11804 ut_params->sess = rte_cryptodev_sym_session_create(
11805 ts_params->session_mpool);
11807 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
11808 &ut_params->auth_xform,
11809 ts_params->session_priv_mpool);
11811 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
11817 test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
11819 struct crypto_testsuite_params *ts_params = &testsuite_params;
11820 struct crypto_unittest_params *ut_params = &unittest_params;
11821 struct rte_cryptodev_info dev_info;
11823 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11824 uint64_t feat_flags = dev_info.feature_flags;
11826 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11827 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11828 printf("Device doesn't support RAW data-path APIs.\n");
11829 return TEST_SKIPPED;
11834 uint8_t *auth_tag, *plaintext;
11835 uint16_t plaintext_pad_len;
11837 TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
11838 "No GMAC length in the source data");
11840 /* Verify the capabilities */
11841 struct rte_cryptodev_sym_capability_idx cap_idx;
11842 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11843 cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
11844 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11846 return TEST_SKIPPED;
11848 retval = create_gmac_session(ts_params->valid_devs[0],
11849 tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
11854 if (tdata->plaintext.len > MBUF_SIZE)
11855 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
11857 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11858 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
11859 "Failed to allocate input buffer in mempool");
11861 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11862 rte_pktmbuf_tailroom(ut_params->ibuf));
11864 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
11866 * Runtime generate the large plain text instead of use hard code
11867 * plain text vector. It is done to avoid create huge source file
11868 * with the test vector.
11870 if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
11871 generate_gmac_large_plaintext(tdata->plaintext.data);
11873 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11874 plaintext_pad_len);
11875 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
11877 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
11878 debug_hexdump(stdout, "plaintext:", plaintext,
11879 tdata->plaintext.len);
11881 retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
11887 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11889 ut_params->op->sym->m_src = ut_params->ibuf;
11891 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11892 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11894 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11895 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11896 ut_params->op, 0, 1, 0, 0);
11898 TEST_ASSERT_NOT_NULL(
11899 process_crypto_request(ts_params->valid_devs[0],
11900 ut_params->op), "failed to process sym crypto op");
11902 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11903 "crypto op processing failed");
11905 if (ut_params->op->sym->m_dst) {
11906 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
11907 uint8_t *, plaintext_pad_len);
11909 auth_tag = plaintext + plaintext_pad_len;
11912 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
11914 TEST_ASSERT_BUFFERS_ARE_EQUAL(
11916 tdata->gmac_tag.data,
11917 tdata->gmac_tag.len,
11918 "GMAC Generated auth tag not as expected");
11924 test_AES_GMAC_authentication_test_case_1(void)
11926 return test_AES_GMAC_authentication(&gmac_test_case_1);
11930 test_AES_GMAC_authentication_test_case_2(void)
11932 return test_AES_GMAC_authentication(&gmac_test_case_2);
11936 test_AES_GMAC_authentication_test_case_3(void)
11938 return test_AES_GMAC_authentication(&gmac_test_case_3);
11942 test_AES_GMAC_authentication_test_case_4(void)
11944 return test_AES_GMAC_authentication(&gmac_test_case_4);
11948 test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
11950 struct crypto_testsuite_params *ts_params = &testsuite_params;
11951 struct crypto_unittest_params *ut_params = &unittest_params;
11953 uint32_t plaintext_pad_len;
11954 uint8_t *plaintext;
11955 struct rte_cryptodev_info dev_info;
11957 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11958 uint64_t feat_flags = dev_info.feature_flags;
11960 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11961 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11962 printf("Device doesn't support RAW data-path APIs.\n");
11963 return TEST_SKIPPED;
11966 TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
11967 "No GMAC length in the source data");
11969 /* Verify the capabilities */
11970 struct rte_cryptodev_sym_capability_idx cap_idx;
11971 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11972 cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
11973 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11975 return TEST_SKIPPED;
11977 retval = create_gmac_session(ts_params->valid_devs[0],
11978 tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
11983 if (tdata->plaintext.len > MBUF_SIZE)
11984 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
11986 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11987 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
11988 "Failed to allocate input buffer in mempool");
11990 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11991 rte_pktmbuf_tailroom(ut_params->ibuf));
11993 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
11996 * Runtime generate the large plain text instead of use hard code
11997 * plain text vector. It is done to avoid create huge source file
11998 * with the test vector.
12000 if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
12001 generate_gmac_large_plaintext(tdata->plaintext.data);
12003 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12004 plaintext_pad_len);
12005 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12007 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
12008 debug_hexdump(stdout, "plaintext:", plaintext,
12009 tdata->plaintext.len);
12011 retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
12017 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12019 ut_params->op->sym->m_src = ut_params->ibuf;
12021 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12022 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12024 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12025 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12026 ut_params->op, 0, 1, 0, 0);
12028 TEST_ASSERT_NOT_NULL(
12029 process_crypto_request(ts_params->valid_devs[0],
12030 ut_params->op), "failed to process sym crypto op");
12032 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12033 "crypto op processing failed");
12040 test_AES_GMAC_authentication_verify_test_case_1(void)
12042 return test_AES_GMAC_authentication_verify(&gmac_test_case_1);
12046 test_AES_GMAC_authentication_verify_test_case_2(void)
12048 return test_AES_GMAC_authentication_verify(&gmac_test_case_2);
12052 test_AES_GMAC_authentication_verify_test_case_3(void)
12054 return test_AES_GMAC_authentication_verify(&gmac_test_case_3);
12058 test_AES_GMAC_authentication_verify_test_case_4(void)
12060 return test_AES_GMAC_authentication_verify(&gmac_test_case_4);
12064 test_AES_GMAC_authentication_SGL(const struct gmac_test_data *tdata,
12067 struct crypto_testsuite_params *ts_params = &testsuite_params;
12068 struct crypto_unittest_params *ut_params = &unittest_params;
12069 struct rte_cryptodev_info dev_info;
12070 uint64_t feature_flags;
12071 unsigned int trn_data = 0;
12072 void *digest_mem = NULL;
12074 unsigned int to_trn = 0;
12075 struct rte_mbuf *buf = NULL;
12076 uint8_t *auth_tag, *plaintext;
12079 TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
12080 "No GMAC length in the source data");
12082 /* Verify the capabilities */
12083 struct rte_cryptodev_sym_capability_idx cap_idx;
12084 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12085 cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
12086 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12088 return TEST_SKIPPED;
12090 /* Check for any input SGL support */
12091 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12092 feature_flags = dev_info.feature_flags;
12094 if ((!(feature_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) ||
12095 (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT)) ||
12096 (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)))
12097 return TEST_SKIPPED;
12099 if (fragsz > tdata->plaintext.len)
12100 fragsz = tdata->plaintext.len;
12102 uint16_t plaintext_len = fragsz;
12104 retval = create_gmac_session(ts_params->valid_devs[0],
12105 tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
12110 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12111 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12112 "Failed to allocate input buffer in mempool");
12114 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12115 rte_pktmbuf_tailroom(ut_params->ibuf));
12117 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12119 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12121 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
12123 trn_data += plaintext_len;
12125 buf = ut_params->ibuf;
12128 * Loop until no more fragments
12131 while (trn_data < tdata->plaintext.len) {
12133 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
12134 (tdata->plaintext.len - trn_data) : fragsz;
12136 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12139 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
12140 rte_pktmbuf_tailroom(buf));
12142 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
12145 memcpy(plaintext, tdata->plaintext.data + trn_data,
12147 trn_data += to_trn;
12148 if (trn_data == tdata->plaintext.len)
12149 digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
12150 tdata->gmac_tag.len);
12152 ut_params->ibuf->nb_segs = segs;
12155 * Place digest at the end of the last buffer
12157 uint64_t digest_phys = rte_pktmbuf_iova(buf) + to_trn;
12160 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12161 + tdata->gmac_tag.len);
12162 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
12163 tdata->plaintext.len);
12166 retval = create_gmac_operation_sgl(RTE_CRYPTO_AUTH_OP_GENERATE,
12167 tdata, digest_mem, digest_phys);
12172 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12174 ut_params->op->sym->m_src = ut_params->ibuf;
12176 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12177 return TEST_SKIPPED;
12179 TEST_ASSERT_NOT_NULL(
12180 process_crypto_request(ts_params->valid_devs[0],
12181 ut_params->op), "failed to process sym crypto op");
12183 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12184 "crypto op processing failed");
12186 auth_tag = digest_mem;
12187 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
12188 TEST_ASSERT_BUFFERS_ARE_EQUAL(
12190 tdata->gmac_tag.data,
12191 tdata->gmac_tag.len,
12192 "GMAC Generated auth tag not as expected");
12197 /* Segment size not multiple of block size (16B) */
12199 test_AES_GMAC_authentication_SGL_40B(void)
12201 return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 40);
12205 test_AES_GMAC_authentication_SGL_80B(void)
12207 return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 80);
12211 test_AES_GMAC_authentication_SGL_2048B(void)
12213 return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2048);
12216 /* Segment size not multiple of block size (16B) */
12218 test_AES_GMAC_authentication_SGL_2047B(void)
12220 return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2047);
12223 struct test_crypto_vector {
12224 enum rte_crypto_cipher_algorithm crypto_algo;
12225 unsigned int cipher_offset;
12226 unsigned int cipher_len;
12239 const uint8_t *data;
12244 const uint8_t *data;
12248 enum rte_crypto_auth_algorithm auth_algo;
12249 unsigned int auth_offset;
12257 const uint8_t *data;
12267 static const struct test_crypto_vector
12268 hmac_sha1_test_crypto_vector = {
12269 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
12271 .data = plaintext_hash,
12276 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
12277 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
12278 0xDE, 0xF4, 0xDE, 0xAD
12284 0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
12285 0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
12286 0x3F, 0x91, 0x64, 0x59
12292 static const struct test_crypto_vector
12293 aes128_gmac_test_vector = {
12294 .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
12296 .data = plaintext_hash,
12301 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
12302 0x08, 0x09, 0x0A, 0x0B
12308 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
12309 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
12315 0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56,
12316 0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A
12322 static const struct test_crypto_vector
12323 aes128cbc_hmac_sha1_test_vector = {
12324 .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
12325 .cipher_offset = 0,
12329 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
12330 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
12336 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
12337 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
12342 .data = plaintext_hash,
12346 .data = ciphertext512_aes128cbc,
12349 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
12353 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
12354 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
12355 0xDE, 0xF4, 0xDE, 0xAD
12361 0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
12362 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
12363 0x18, 0x8C, 0x1D, 0x32
12369 static const struct test_crypto_vector
12370 aes128cbc_hmac_sha1_aad_test_vector = {
12371 .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
12372 .cipher_offset = 8,
12376 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
12377 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
12383 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
12384 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
12389 .data = plaintext_hash,
12393 .data = ciphertext512_aes128cbc_aad,
12396 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
12400 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
12401 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
12402 0xDE, 0xF4, 0xDE, 0xAD
12408 0x6D, 0xF3, 0x50, 0x79, 0x7A, 0x2A, 0xAC, 0x7F,
12409 0xA6, 0xF0, 0xC6, 0x38, 0x1F, 0xA4, 0xDD, 0x9B,
12410 0x62, 0x0F, 0xFB, 0x10
12417 data_corruption(uint8_t *data)
12423 tag_corruption(uint8_t *data, unsigned int tag_offset)
12425 data[tag_offset] += 1;
12429 create_auth_session(struct crypto_unittest_params *ut_params,
12431 const struct test_crypto_vector *reference,
12432 enum rte_crypto_auth_operation auth_op)
12434 struct crypto_testsuite_params *ts_params = &testsuite_params;
12435 uint8_t auth_key[reference->auth_key.len + 1];
12437 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
12439 /* Setup Authentication Parameters */
12440 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12441 ut_params->auth_xform.auth.op = auth_op;
12442 ut_params->auth_xform.next = NULL;
12443 ut_params->auth_xform.auth.algo = reference->auth_algo;
12444 ut_params->auth_xform.auth.key.length = reference->auth_key.len;
12445 ut_params->auth_xform.auth.key.data = auth_key;
12446 ut_params->auth_xform.auth.digest_length = reference->digest.len;
12448 /* Create Crypto session*/
12449 ut_params->sess = rte_cryptodev_sym_session_create(
12450 ts_params->session_mpool);
12452 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
12453 &ut_params->auth_xform,
12454 ts_params->session_priv_mpool);
12456 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12462 create_auth_cipher_session(struct crypto_unittest_params *ut_params,
12464 const struct test_crypto_vector *reference,
12465 enum rte_crypto_auth_operation auth_op,
12466 enum rte_crypto_cipher_operation cipher_op)
12468 struct crypto_testsuite_params *ts_params = &testsuite_params;
12469 uint8_t cipher_key[reference->cipher_key.len + 1];
12470 uint8_t auth_key[reference->auth_key.len + 1];
12472 memcpy(cipher_key, reference->cipher_key.data,
12473 reference->cipher_key.len);
12474 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
12476 /* Setup Authentication Parameters */
12477 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12478 ut_params->auth_xform.auth.op = auth_op;
12479 ut_params->auth_xform.auth.algo = reference->auth_algo;
12480 ut_params->auth_xform.auth.key.length = reference->auth_key.len;
12481 ut_params->auth_xform.auth.key.data = auth_key;
12482 ut_params->auth_xform.auth.digest_length = reference->digest.len;
12484 if (reference->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) {
12485 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
12486 ut_params->auth_xform.auth.iv.length = reference->iv.len;
12488 ut_params->auth_xform.next = &ut_params->cipher_xform;
12490 /* Setup Cipher Parameters */
12491 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12492 ut_params->cipher_xform.next = NULL;
12493 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
12494 ut_params->cipher_xform.cipher.op = cipher_op;
12495 ut_params->cipher_xform.cipher.key.data = cipher_key;
12496 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
12497 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
12498 ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
12501 /* Create Crypto session*/
12502 ut_params->sess = rte_cryptodev_sym_session_create(
12503 ts_params->session_mpool);
12505 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
12506 &ut_params->auth_xform,
12507 ts_params->session_priv_mpool);
12509 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12515 create_auth_operation(struct crypto_testsuite_params *ts_params,
12516 struct crypto_unittest_params *ut_params,
12517 const struct test_crypto_vector *reference,
12518 unsigned int auth_generate)
12520 /* Generate Crypto op data structure */
12521 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12522 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12523 TEST_ASSERT_NOT_NULL(ut_params->op,
12524 "Failed to allocate pktmbuf offload");
12526 /* Set crypto operation data parameters */
12527 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12529 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
12531 /* set crypto operation source mbuf */
12532 sym_op->m_src = ut_params->ibuf;
12535 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
12536 ut_params->ibuf, reference->digest.len);
12538 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
12539 "no room to append auth tag");
12541 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
12542 ut_params->ibuf, reference->plaintext.len);
12545 memset(sym_op->auth.digest.data, 0, reference->digest.len);
12547 memcpy(sym_op->auth.digest.data,
12548 reference->digest.data,
12549 reference->digest.len);
12551 debug_hexdump(stdout, "digest:",
12552 sym_op->auth.digest.data,
12553 reference->digest.len);
12555 sym_op->auth.data.length = reference->plaintext.len;
12556 sym_op->auth.data.offset = 0;
12562 create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
12563 struct crypto_unittest_params *ut_params,
12564 const struct test_crypto_vector *reference,
12565 unsigned int auth_generate)
12567 /* Generate Crypto op data structure */
12568 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12569 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12570 TEST_ASSERT_NOT_NULL(ut_params->op,
12571 "Failed to allocate pktmbuf offload");
12573 /* Set crypto operation data parameters */
12574 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12576 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
12578 /* set crypto operation source mbuf */
12579 sym_op->m_src = ut_params->ibuf;
12582 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
12583 ut_params->ibuf, reference->digest.len);
12585 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
12586 "no room to append auth tag");
12588 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
12589 ut_params->ibuf, reference->ciphertext.len);
12592 memset(sym_op->auth.digest.data, 0, reference->digest.len);
12594 memcpy(sym_op->auth.digest.data,
12595 reference->digest.data,
12596 reference->digest.len);
12598 debug_hexdump(stdout, "digest:",
12599 sym_op->auth.digest.data,
12600 reference->digest.len);
12602 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
12603 reference->iv.data, reference->iv.len);
12605 sym_op->cipher.data.length = 0;
12606 sym_op->cipher.data.offset = 0;
12608 sym_op->auth.data.length = reference->plaintext.len;
12609 sym_op->auth.data.offset = 0;
12615 create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
12616 struct crypto_unittest_params *ut_params,
12617 const struct test_crypto_vector *reference,
12618 unsigned int auth_generate)
12620 /* Generate Crypto op data structure */
12621 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12622 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12623 TEST_ASSERT_NOT_NULL(ut_params->op,
12624 "Failed to allocate pktmbuf offload");
12626 /* Set crypto operation data parameters */
12627 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12629 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
12631 /* set crypto operation source mbuf */
12632 sym_op->m_src = ut_params->ibuf;
12635 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
12636 ut_params->ibuf, reference->digest.len);
12638 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
12639 "no room to append auth tag");
12641 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
12642 ut_params->ibuf, reference->ciphertext.len);
12645 memset(sym_op->auth.digest.data, 0, reference->digest.len);
12647 memcpy(sym_op->auth.digest.data,
12648 reference->digest.data,
12649 reference->digest.len);
12651 debug_hexdump(stdout, "digest:",
12652 sym_op->auth.digest.data,
12653 reference->digest.len);
12655 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
12656 reference->iv.data, reference->iv.len);
12658 sym_op->cipher.data.length = reference->cipher_len;
12659 sym_op->cipher.data.offset = reference->cipher_offset;
12661 sym_op->auth.data.length = reference->plaintext.len;
12662 sym_op->auth.data.offset = reference->auth_offset;
12668 create_auth_verify_operation(struct crypto_testsuite_params *ts_params,
12669 struct crypto_unittest_params *ut_params,
12670 const struct test_crypto_vector *reference)
12672 return create_auth_operation(ts_params, ut_params, reference, 0);
12676 create_auth_verify_GMAC_operation(
12677 struct crypto_testsuite_params *ts_params,
12678 struct crypto_unittest_params *ut_params,
12679 const struct test_crypto_vector *reference)
12681 return create_auth_GMAC_operation(ts_params, ut_params, reference, 0);
12685 create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params,
12686 struct crypto_unittest_params *ut_params,
12687 const struct test_crypto_vector *reference)
12689 return create_cipher_auth_operation(ts_params, ut_params, reference, 0);
12693 test_authentication_verify_fail_when_data_corruption(
12694 struct crypto_testsuite_params *ts_params,
12695 struct crypto_unittest_params *ut_params,
12696 const struct test_crypto_vector *reference,
12697 unsigned int data_corrupted)
12701 uint8_t *plaintext;
12702 struct rte_cryptodev_info dev_info;
12704 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12705 uint64_t feat_flags = dev_info.feature_flags;
12707 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12708 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12709 printf("Device doesn't support RAW data-path APIs.\n");
12710 return TEST_SKIPPED;
12713 /* Verify the capabilities */
12714 struct rte_cryptodev_sym_capability_idx cap_idx;
12715 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12716 cap_idx.algo.auth = reference->auth_algo;
12717 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12719 return TEST_SKIPPED;
12722 /* Create session */
12723 retval = create_auth_session(ut_params,
12724 ts_params->valid_devs[0],
12726 RTE_CRYPTO_AUTH_OP_VERIFY);
12730 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12731 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12732 "Failed to allocate input buffer in mempool");
12734 /* clear mbuf payload */
12735 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12736 rte_pktmbuf_tailroom(ut_params->ibuf));
12738 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12739 reference->plaintext.len);
12740 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12741 memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
12743 debug_hexdump(stdout, "plaintext:", plaintext,
12744 reference->plaintext.len);
12746 /* Create operation */
12747 retval = create_auth_verify_operation(ts_params, ut_params, reference);
12752 if (data_corrupted)
12753 data_corruption(plaintext);
12755 tag_corruption(plaintext, reference->plaintext.len);
12757 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
12758 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12760 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
12761 RTE_CRYPTO_OP_STATUS_SUCCESS,
12762 "authentication not failed");
12763 } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12764 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12765 ut_params->op, 0, 1, 0, 0);
12767 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
12769 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
12776 test_authentication_verify_GMAC_fail_when_corruption(
12777 struct crypto_testsuite_params *ts_params,
12778 struct crypto_unittest_params *ut_params,
12779 const struct test_crypto_vector *reference,
12780 unsigned int data_corrupted)
12783 uint8_t *plaintext;
12784 struct rte_cryptodev_info dev_info;
12786 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12787 uint64_t feat_flags = dev_info.feature_flags;
12789 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12790 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12791 printf("Device doesn't support RAW data-path APIs.\n");
12792 return TEST_SKIPPED;
12795 /* Verify the capabilities */
12796 struct rte_cryptodev_sym_capability_idx cap_idx;
12797 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12798 cap_idx.algo.auth = reference->auth_algo;
12799 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12801 return TEST_SKIPPED;
12803 /* Create session */
12804 retval = create_auth_cipher_session(ut_params,
12805 ts_params->valid_devs[0],
12807 RTE_CRYPTO_AUTH_OP_VERIFY,
12808 RTE_CRYPTO_CIPHER_OP_DECRYPT);
12812 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12813 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12814 "Failed to allocate input buffer in mempool");
12816 /* clear mbuf payload */
12817 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12818 rte_pktmbuf_tailroom(ut_params->ibuf));
12820 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12821 reference->plaintext.len);
12822 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12823 memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
12825 debug_hexdump(stdout, "plaintext:", plaintext,
12826 reference->plaintext.len);
12828 /* Create operation */
12829 retval = create_auth_verify_GMAC_operation(ts_params,
12836 if (data_corrupted)
12837 data_corruption(plaintext);
12839 tag_corruption(plaintext, reference->aad.len);
12841 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
12842 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12844 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
12845 RTE_CRYPTO_OP_STATUS_SUCCESS,
12846 "authentication not failed");
12847 } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12848 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12849 ut_params->op, 0, 1, 0, 0);
12851 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
12853 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
12860 test_authenticated_decryption_fail_when_corruption(
12861 struct crypto_testsuite_params *ts_params,
12862 struct crypto_unittest_params *ut_params,
12863 const struct test_crypto_vector *reference,
12864 unsigned int data_corrupted)
12868 uint8_t *ciphertext;
12869 struct rte_cryptodev_info dev_info;
12871 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12872 uint64_t feat_flags = dev_info.feature_flags;
12874 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12875 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12876 printf("Device doesn't support RAW data-path APIs.\n");
12877 return TEST_SKIPPED;
12880 /* Verify the capabilities */
12881 struct rte_cryptodev_sym_capability_idx cap_idx;
12882 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12883 cap_idx.algo.auth = reference->auth_algo;
12884 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12886 return TEST_SKIPPED;
12887 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12888 cap_idx.algo.cipher = reference->crypto_algo;
12889 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12891 return TEST_SKIPPED;
12893 /* Create session */
12894 retval = create_auth_cipher_session(ut_params,
12895 ts_params->valid_devs[0],
12897 RTE_CRYPTO_AUTH_OP_VERIFY,
12898 RTE_CRYPTO_CIPHER_OP_DECRYPT);
12902 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12903 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12904 "Failed to allocate input buffer in mempool");
12906 /* clear mbuf payload */
12907 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12908 rte_pktmbuf_tailroom(ut_params->ibuf));
12910 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12911 reference->ciphertext.len);
12912 TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
12913 memcpy(ciphertext, reference->ciphertext.data,
12914 reference->ciphertext.len);
12916 /* Create operation */
12917 retval = create_cipher_auth_verify_operation(ts_params,
12924 if (data_corrupted)
12925 data_corruption(ciphertext);
12927 tag_corruption(ciphertext, reference->ciphertext.len);
12929 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
12930 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12932 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
12933 RTE_CRYPTO_OP_STATUS_SUCCESS,
12934 "authentication not failed");
12935 } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12936 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12937 ut_params->op, 1, 1, 0, 0);
12939 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
12941 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
12948 test_authenticated_encrypt_with_esn(
12949 struct crypto_testsuite_params *ts_params,
12950 struct crypto_unittest_params *ut_params,
12951 const struct test_crypto_vector *reference)
12955 uint8_t *authciphertext, *plaintext, *auth_tag;
12956 uint16_t plaintext_pad_len;
12957 uint8_t cipher_key[reference->cipher_key.len + 1];
12958 uint8_t auth_key[reference->auth_key.len + 1];
12959 struct rte_cryptodev_info dev_info;
12961 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12962 uint64_t feat_flags = dev_info.feature_flags;
12964 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12965 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12966 printf("Device doesn't support RAW data-path APIs.\n");
12967 return TEST_SKIPPED;
12970 /* Verify the capabilities */
12971 struct rte_cryptodev_sym_capability_idx cap_idx;
12972 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12973 cap_idx.algo.auth = reference->auth_algo;
12974 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12976 return TEST_SKIPPED;
12977 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12978 cap_idx.algo.cipher = reference->crypto_algo;
12979 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12981 return TEST_SKIPPED;
12983 /* Create session */
12984 memcpy(cipher_key, reference->cipher_key.data,
12985 reference->cipher_key.len);
12986 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
12988 /* Setup Cipher Parameters */
12989 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12990 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
12991 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
12992 ut_params->cipher_xform.cipher.key.data = cipher_key;
12993 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
12994 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
12995 ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
12997 ut_params->cipher_xform.next = &ut_params->auth_xform;
12999 /* Setup Authentication Parameters */
13000 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13001 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
13002 ut_params->auth_xform.auth.algo = reference->auth_algo;
13003 ut_params->auth_xform.auth.key.length = reference->auth_key.len;
13004 ut_params->auth_xform.auth.key.data = auth_key;
13005 ut_params->auth_xform.auth.digest_length = reference->digest.len;
13006 ut_params->auth_xform.next = NULL;
13008 /* Create Crypto session*/
13009 ut_params->sess = rte_cryptodev_sym_session_create(
13010 ts_params->session_mpool);
13012 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
13014 &ut_params->cipher_xform,
13015 ts_params->session_priv_mpool);
13017 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
13019 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13020 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13021 "Failed to allocate input buffer in mempool");
13023 /* clear mbuf payload */
13024 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13025 rte_pktmbuf_tailroom(ut_params->ibuf));
13027 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13028 reference->plaintext.len);
13029 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
13030 memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
13032 /* Create operation */
13033 retval = create_cipher_auth_operation(ts_params,
13040 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13041 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13043 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13044 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13045 ut_params->op, 1, 1, 0, 0);
13047 ut_params->op = process_crypto_request(
13048 ts_params->valid_devs[0], ut_params->op);
13050 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
13052 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
13053 "crypto op processing failed");
13055 plaintext_pad_len = RTE_ALIGN_CEIL(reference->plaintext.len, 16);
13057 authciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
13058 ut_params->op->sym->auth.data.offset);
13059 auth_tag = authciphertext + plaintext_pad_len;
13060 debug_hexdump(stdout, "ciphertext:", authciphertext,
13061 reference->ciphertext.len);
13062 debug_hexdump(stdout, "auth tag:", auth_tag, reference->digest.len);
13064 /* Validate obuf */
13065 TEST_ASSERT_BUFFERS_ARE_EQUAL(
13067 reference->ciphertext.data,
13068 reference->ciphertext.len,
13069 "Ciphertext data not as expected");
13071 TEST_ASSERT_BUFFERS_ARE_EQUAL(
13073 reference->digest.data,
13074 reference->digest.len,
13075 "Generated digest not as expected");
13077 return TEST_SUCCESS;
13082 test_authenticated_decrypt_with_esn(
13083 struct crypto_testsuite_params *ts_params,
13084 struct crypto_unittest_params *ut_params,
13085 const struct test_crypto_vector *reference)
13089 uint8_t *ciphertext;
13090 uint8_t cipher_key[reference->cipher_key.len + 1];
13091 uint8_t auth_key[reference->auth_key.len + 1];
13092 struct rte_cryptodev_info dev_info;
13094 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13095 uint64_t feat_flags = dev_info.feature_flags;
13097 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13098 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13099 printf("Device doesn't support RAW data-path APIs.\n");
13100 return TEST_SKIPPED;
13103 /* Verify the capabilities */
13104 struct rte_cryptodev_sym_capability_idx cap_idx;
13105 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13106 cap_idx.algo.auth = reference->auth_algo;
13107 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13109 return TEST_SKIPPED;
13110 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13111 cap_idx.algo.cipher = reference->crypto_algo;
13112 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13114 return TEST_SKIPPED;
13116 /* Create session */
13117 memcpy(cipher_key, reference->cipher_key.data,
13118 reference->cipher_key.len);
13119 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
13121 /* Setup Authentication Parameters */
13122 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13123 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
13124 ut_params->auth_xform.auth.algo = reference->auth_algo;
13125 ut_params->auth_xform.auth.key.length = reference->auth_key.len;
13126 ut_params->auth_xform.auth.key.data = auth_key;
13127 ut_params->auth_xform.auth.digest_length = reference->digest.len;
13128 ut_params->auth_xform.next = &ut_params->cipher_xform;
13130 /* Setup Cipher Parameters */
13131 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13132 ut_params->cipher_xform.next = NULL;
13133 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
13134 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
13135 ut_params->cipher_xform.cipher.key.data = cipher_key;
13136 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
13137 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
13138 ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
13140 /* Create Crypto session*/
13141 ut_params->sess = rte_cryptodev_sym_session_create(
13142 ts_params->session_mpool);
13144 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
13146 &ut_params->auth_xform,
13147 ts_params->session_priv_mpool);
13149 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
13151 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13152 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13153 "Failed to allocate input buffer in mempool");
13155 /* clear mbuf payload */
13156 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13157 rte_pktmbuf_tailroom(ut_params->ibuf));
13159 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13160 reference->ciphertext.len);
13161 TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
13162 memcpy(ciphertext, reference->ciphertext.data,
13163 reference->ciphertext.len);
13165 /* Create operation */
13166 retval = create_cipher_auth_verify_operation(ts_params,
13173 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13174 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13176 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13177 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13178 ut_params->op, 1, 1, 0, 0);
13180 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13183 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
13184 TEST_ASSERT_EQUAL(ut_params->op->status,
13185 RTE_CRYPTO_OP_STATUS_SUCCESS,
13186 "crypto op processing passed");
13188 ut_params->obuf = ut_params->op->sym->m_src;
13189 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
13195 create_aead_operation_SGL(enum rte_crypto_aead_operation op,
13196 const struct aead_test_data *tdata,
13197 void *digest_mem, uint64_t digest_phys)
13199 struct crypto_testsuite_params *ts_params = &testsuite_params;
13200 struct crypto_unittest_params *ut_params = &unittest_params;
13202 const unsigned int auth_tag_len = tdata->auth_tag.len;
13203 const unsigned int iv_len = tdata->iv.len;
13204 unsigned int aad_len = tdata->aad.len;
13205 unsigned int aad_len_pad = 0;
13207 /* Generate Crypto op data structure */
13208 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
13209 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
13210 TEST_ASSERT_NOT_NULL(ut_params->op,
13211 "Failed to allocate symmetric crypto operation struct");
13213 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
13215 sym_op->aead.digest.data = digest_mem;
13217 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
13218 "no room to append digest");
13220 sym_op->aead.digest.phys_addr = digest_phys;
13222 if (op == RTE_CRYPTO_AEAD_OP_DECRYPT) {
13223 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
13225 debug_hexdump(stdout, "digest:",
13226 sym_op->aead.digest.data,
13230 /* Append aad data */
13231 if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
13232 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
13233 uint8_t *, IV_OFFSET);
13235 /* Copy IV 1 byte after the IV pointer, according to the API */
13236 rte_memcpy(iv_ptr + 1, tdata->iv.data, iv_len);
13238 aad_len = RTE_ALIGN_CEIL(aad_len + 18, 16);
13240 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
13241 ut_params->ibuf, aad_len);
13242 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
13243 "no room to prepend aad");
13244 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
13247 memset(sym_op->aead.aad.data, 0, aad_len);
13248 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
13249 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
13251 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
13252 debug_hexdump(stdout, "aad:",
13253 sym_op->aead.aad.data, aad_len);
13255 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
13256 uint8_t *, IV_OFFSET);
13258 rte_memcpy(iv_ptr, tdata->iv.data, iv_len);
13260 aad_len_pad = RTE_ALIGN_CEIL(aad_len, 16);
13262 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
13263 ut_params->ibuf, aad_len_pad);
13264 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
13265 "no room to prepend aad");
13266 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
13269 memset(sym_op->aead.aad.data, 0, aad_len);
13270 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
13272 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
13273 debug_hexdump(stdout, "aad:",
13274 sym_op->aead.aad.data, aad_len);
13277 sym_op->aead.data.length = tdata->plaintext.len;
13278 sym_op->aead.data.offset = aad_len_pad;
13283 #define SGL_MAX_NO 16
13286 test_authenticated_encryption_SGL(const struct aead_test_data *tdata,
13287 const int oop, uint32_t fragsz, uint32_t fragsz_oop)
13289 struct crypto_testsuite_params *ts_params = &testsuite_params;
13290 struct crypto_unittest_params *ut_params = &unittest_params;
13291 struct rte_mbuf *buf, *buf_oop = NULL, *buf_last_oop = NULL;
13294 int to_trn_tbl[SGL_MAX_NO];
13296 unsigned int trn_data = 0;
13297 uint8_t *plaintext, *ciphertext, *auth_tag;
13298 struct rte_cryptodev_info dev_info;
13300 /* Verify the capabilities */
13301 struct rte_cryptodev_sym_capability_idx cap_idx;
13302 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
13303 cap_idx.algo.aead = tdata->algo;
13304 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13306 return TEST_SKIPPED;
13308 /* OOP not supported with CPU crypto */
13309 if (oop && gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13310 return TEST_SKIPPED;
13312 /* Detailed check for the particular SGL support flag */
13313 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13315 unsigned int sgl_in = fragsz < tdata->plaintext.len;
13316 if (sgl_in && (!(dev_info.feature_flags &
13317 RTE_CRYPTODEV_FF_IN_PLACE_SGL)))
13318 return TEST_SKIPPED;
13320 uint64_t feat_flags = dev_info.feature_flags;
13322 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13323 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13324 printf("Device doesn't support RAW data-path APIs.\n");
13325 return TEST_SKIPPED;
13328 unsigned int sgl_in = fragsz < tdata->plaintext.len;
13329 unsigned int sgl_out = (fragsz_oop ? fragsz_oop : fragsz) <
13330 tdata->plaintext.len;
13331 /* Raw data path API does not support OOP */
13332 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13333 return TEST_SKIPPED;
13334 if (sgl_in && !sgl_out) {
13335 if (!(dev_info.feature_flags &
13336 RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT))
13337 return TEST_SKIPPED;
13338 } else if (!sgl_in && sgl_out) {
13339 if (!(dev_info.feature_flags &
13340 RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT))
13341 return TEST_SKIPPED;
13342 } else if (sgl_in && sgl_out) {
13343 if (!(dev_info.feature_flags &
13344 RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT))
13345 return TEST_SKIPPED;
13349 if (fragsz > tdata->plaintext.len)
13350 fragsz = tdata->plaintext.len;
13352 uint16_t plaintext_len = fragsz;
13353 uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
13355 if (fragsz_oop > tdata->plaintext.len)
13356 frag_size_oop = tdata->plaintext.len;
13359 void *digest_mem = NULL;
13361 uint32_t prepend_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
13363 if (tdata->plaintext.len % fragsz != 0) {
13364 if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO)
13367 if (tdata->plaintext.len / fragsz > SGL_MAX_NO)
13372 * For out-op-place we need to alloc another mbuf
13375 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13376 rte_pktmbuf_append(ut_params->obuf,
13377 frag_size_oop + prepend_len);
13378 buf_oop = ut_params->obuf;
13381 /* Create AEAD session */
13382 retval = create_aead_session(ts_params->valid_devs[0],
13384 RTE_CRYPTO_AEAD_OP_ENCRYPT,
13385 tdata->key.data, tdata->key.len,
13386 tdata->aad.len, tdata->auth_tag.len,
13391 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13393 /* clear mbuf payload */
13394 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13395 rte_pktmbuf_tailroom(ut_params->ibuf));
13397 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13400 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
13402 trn_data += plaintext_len;
13404 buf = ut_params->ibuf;
13407 * Loop until no more fragments
13410 while (trn_data < tdata->plaintext.len) {
13412 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
13413 (tdata->plaintext.len - trn_data) : fragsz;
13415 to_trn_tbl[ecx++] = to_trn;
13417 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13420 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
13421 rte_pktmbuf_tailroom(buf));
13424 if (oop && !fragsz_oop) {
13425 buf_last_oop = buf_oop->next =
13426 rte_pktmbuf_alloc(ts_params->mbuf_pool);
13427 buf_oop = buf_oop->next;
13428 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
13429 0, rte_pktmbuf_tailroom(buf_oop));
13430 rte_pktmbuf_append(buf_oop, to_trn);
13433 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
13436 memcpy(plaintext, tdata->plaintext.data + trn_data,
13438 trn_data += to_trn;
13439 if (trn_data == tdata->plaintext.len) {
13442 digest_mem = rte_pktmbuf_append(buf_oop,
13443 tdata->auth_tag.len);
13445 digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
13446 tdata->auth_tag.len);
13450 uint64_t digest_phys = 0;
13452 ut_params->ibuf->nb_segs = segs;
13455 if (fragsz_oop && oop) {
13459 if (frag_size_oop == tdata->plaintext.len) {
13460 digest_mem = rte_pktmbuf_append(ut_params->obuf,
13461 tdata->auth_tag.len);
13463 digest_phys = rte_pktmbuf_iova_offset(
13465 tdata->plaintext.len + prepend_len);
13468 trn_data = frag_size_oop;
13469 while (trn_data < tdata->plaintext.len) {
13472 (tdata->plaintext.len - trn_data <
13474 (tdata->plaintext.len - trn_data) :
13477 to_trn_tbl[ecx++] = to_trn;
13479 buf_last_oop = buf_oop->next =
13480 rte_pktmbuf_alloc(ts_params->mbuf_pool);
13481 buf_oop = buf_oop->next;
13482 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
13483 0, rte_pktmbuf_tailroom(buf_oop));
13484 rte_pktmbuf_append(buf_oop, to_trn);
13486 trn_data += to_trn;
13488 if (trn_data == tdata->plaintext.len) {
13489 digest_mem = rte_pktmbuf_append(buf_oop,
13490 tdata->auth_tag.len);
13494 ut_params->obuf->nb_segs = segs;
13498 * Place digest at the end of the last buffer
13501 digest_phys = rte_pktmbuf_iova(buf) + to_trn;
13502 if (oop && buf_last_oop)
13503 digest_phys = rte_pktmbuf_iova(buf_last_oop) + to_trn;
13505 if (!digest_mem && !oop) {
13506 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13507 + tdata->auth_tag.len);
13508 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
13509 tdata->plaintext.len);
13512 /* Create AEAD operation */
13513 retval = create_aead_operation_SGL(RTE_CRYPTO_AEAD_OP_ENCRYPT,
13514 tdata, digest_mem, digest_phys);
13519 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
13521 ut_params->op->sym->m_src = ut_params->ibuf;
13523 ut_params->op->sym->m_dst = ut_params->obuf;
13525 /* Process crypto operation */
13526 if (oop == IN_PLACE &&
13527 gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13528 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
13529 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13530 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13531 ut_params->op, 0, 0, 0, 0);
13533 TEST_ASSERT_NOT_NULL(
13534 process_crypto_request(ts_params->valid_devs[0],
13535 ut_params->op), "failed to process sym crypto op");
13537 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
13538 "crypto op processing failed");
13541 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
13542 uint8_t *, prepend_len);
13544 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
13545 uint8_t *, prepend_len);
13549 fragsz = fragsz_oop;
13551 TEST_ASSERT_BUFFERS_ARE_EQUAL(
13553 tdata->ciphertext.data,
13555 "Ciphertext data not as expected");
13557 buf = ut_params->op->sym->m_src->next;
13559 buf = ut_params->op->sym->m_dst->next;
13561 unsigned int off = fragsz;
13565 ciphertext = rte_pktmbuf_mtod(buf,
13568 TEST_ASSERT_BUFFERS_ARE_EQUAL(
13570 tdata->ciphertext.data + off,
13572 "Ciphertext data not as expected");
13574 off += to_trn_tbl[ecx++];
13578 auth_tag = digest_mem;
13579 TEST_ASSERT_BUFFERS_ARE_EQUAL(
13581 tdata->auth_tag.data,
13582 tdata->auth_tag.len,
13583 "Generated auth tag not as expected");
13589 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void)
13591 return test_authenticated_encryption_SGL(
13592 &gcm_test_case_SGL_1, OUT_OF_PLACE, 400, 400);
13596 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B(void)
13598 return test_authenticated_encryption_SGL(
13599 &gcm_test_case_SGL_1, OUT_OF_PLACE, 1500, 2000);
13603 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void)
13605 return test_authenticated_encryption_SGL(
13606 &gcm_test_case_8, OUT_OF_PLACE, 400,
13607 gcm_test_case_8.plaintext.len);
13611 test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void)
13613 /* This test is not for OPENSSL PMD */
13614 if (gbl_driver_id == rte_cryptodev_driver_id_get(
13615 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)))
13616 return TEST_SKIPPED;
13618 return test_authenticated_encryption_SGL(
13619 &gcm_test_case_SGL_1, IN_PLACE, 1500, 0);
13623 test_authentication_verify_fail_when_data_corrupted(
13624 struct crypto_testsuite_params *ts_params,
13625 struct crypto_unittest_params *ut_params,
13626 const struct test_crypto_vector *reference)
13628 return test_authentication_verify_fail_when_data_corruption(
13629 ts_params, ut_params, reference, 1);
13633 test_authentication_verify_fail_when_tag_corrupted(
13634 struct crypto_testsuite_params *ts_params,
13635 struct crypto_unittest_params *ut_params,
13636 const struct test_crypto_vector *reference)
13638 return test_authentication_verify_fail_when_data_corruption(
13639 ts_params, ut_params, reference, 0);
13643 test_authentication_verify_GMAC_fail_when_data_corrupted(
13644 struct crypto_testsuite_params *ts_params,
13645 struct crypto_unittest_params *ut_params,
13646 const struct test_crypto_vector *reference)
13648 return test_authentication_verify_GMAC_fail_when_corruption(
13649 ts_params, ut_params, reference, 1);
13653 test_authentication_verify_GMAC_fail_when_tag_corrupted(
13654 struct crypto_testsuite_params *ts_params,
13655 struct crypto_unittest_params *ut_params,
13656 const struct test_crypto_vector *reference)
13658 return test_authentication_verify_GMAC_fail_when_corruption(
13659 ts_params, ut_params, reference, 0);
13663 test_authenticated_decryption_fail_when_data_corrupted(
13664 struct crypto_testsuite_params *ts_params,
13665 struct crypto_unittest_params *ut_params,
13666 const struct test_crypto_vector *reference)
13668 return test_authenticated_decryption_fail_when_corruption(
13669 ts_params, ut_params, reference, 1);
13673 test_authenticated_decryption_fail_when_tag_corrupted(
13674 struct crypto_testsuite_params *ts_params,
13675 struct crypto_unittest_params *ut_params,
13676 const struct test_crypto_vector *reference)
13678 return test_authenticated_decryption_fail_when_corruption(
13679 ts_params, ut_params, reference, 0);
13683 authentication_verify_HMAC_SHA1_fail_data_corrupt(void)
13685 return test_authentication_verify_fail_when_data_corrupted(
13686 &testsuite_params, &unittest_params,
13687 &hmac_sha1_test_crypto_vector);
13691 authentication_verify_HMAC_SHA1_fail_tag_corrupt(void)
13693 return test_authentication_verify_fail_when_tag_corrupted(
13694 &testsuite_params, &unittest_params,
13695 &hmac_sha1_test_crypto_vector);
13699 authentication_verify_AES128_GMAC_fail_data_corrupt(void)
13701 return test_authentication_verify_GMAC_fail_when_data_corrupted(
13702 &testsuite_params, &unittest_params,
13703 &aes128_gmac_test_vector);
13707 authentication_verify_AES128_GMAC_fail_tag_corrupt(void)
13709 return test_authentication_verify_GMAC_fail_when_tag_corrupted(
13710 &testsuite_params, &unittest_params,
13711 &aes128_gmac_test_vector);
13715 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void)
13717 return test_authenticated_decryption_fail_when_data_corrupted(
13720 &aes128cbc_hmac_sha1_test_vector);
13724 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void)
13726 return test_authenticated_decryption_fail_when_tag_corrupted(
13729 &aes128cbc_hmac_sha1_test_vector);
13733 auth_encrypt_AES128CBC_HMAC_SHA1_esn_check(void)
13735 return test_authenticated_encrypt_with_esn(
13738 &aes128cbc_hmac_sha1_aad_test_vector);
13742 auth_decrypt_AES128CBC_HMAC_SHA1_esn_check(void)
13744 return test_authenticated_decrypt_with_esn(
13747 &aes128cbc_hmac_sha1_aad_test_vector);
13751 test_chacha20_poly1305_encrypt_test_case_rfc8439(void)
13753 return test_authenticated_encryption(&chacha20_poly1305_case_rfc8439);
13757 test_chacha20_poly1305_decrypt_test_case_rfc8439(void)
13759 return test_authenticated_decryption(&chacha20_poly1305_case_rfc8439);
13762 #ifdef RTE_CRYPTO_SCHEDULER
13764 /* global AESNI worker IDs for the scheduler test */
13765 uint8_t aesni_ids[2];
13768 scheduler_testsuite_setup(void)
13771 int32_t nb_devs, ret;
13772 char vdev_args[VDEV_ARGS_SIZE] = {""};
13773 char temp_str[VDEV_ARGS_SIZE] = {"mode=multi-core,"
13774 "ordering=enable,name=cryptodev_test_scheduler,corelist="};
13775 uint16_t worker_core_count = 0;
13776 uint16_t socket_id = 0;
13778 if (gbl_driver_id == rte_cryptodev_driver_id_get(
13779 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD))) {
13781 /* Identify the Worker Cores
13782 * Use 2 worker cores for the device args
13784 RTE_LCORE_FOREACH_WORKER(i) {
13785 if (worker_core_count > 1)
13787 snprintf(vdev_args, sizeof(vdev_args),
13788 "%s%d", temp_str, i);
13789 strcpy(temp_str, vdev_args);
13790 strlcat(temp_str, ";", sizeof(temp_str));
13791 worker_core_count++;
13792 socket_id = rte_lcore_to_socket_id(i);
13794 if (worker_core_count != 2) {
13795 RTE_LOG(ERR, USER1,
13796 "Cryptodev scheduler test require at least "
13797 "two worker cores to run. "
13798 "Please use the correct coremask.\n");
13799 return TEST_FAILED;
13801 strcpy(temp_str, vdev_args);
13802 snprintf(vdev_args, sizeof(vdev_args), "%s,socket_id=%d",
13803 temp_str, socket_id);
13804 RTE_LOG(DEBUG, USER1, "vdev_args: %s\n", vdev_args);
13805 nb_devs = rte_cryptodev_device_count_by_driver(
13806 rte_cryptodev_driver_id_get(
13807 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)));
13809 ret = rte_vdev_init(
13810 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),
13812 TEST_ASSERT(ret == 0,
13813 "Failed to create instance %u of pmd : %s",
13814 i, RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
13817 return testsuite_setup();
13821 test_scheduler_attach_worker_op(void)
13823 struct crypto_testsuite_params *ts_params = &testsuite_params;
13824 uint8_t sched_id = ts_params->valid_devs[0];
13825 uint32_t i, nb_devs_attached = 0;
13827 char vdev_name[32];
13828 unsigned int count = rte_cryptodev_count();
13830 /* create 2 AESNI_MB vdevs on top of existing devices */
13831 for (i = count; i < count + 2; i++) {
13832 snprintf(vdev_name, sizeof(vdev_name), "%s_%u",
13833 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD),
13835 ret = rte_vdev_init(vdev_name, NULL);
13837 TEST_ASSERT(ret == 0,
13838 "Failed to create instance %u of"
13840 i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
13843 RTE_LOG(ERR, USER1,
13844 "Failed to create 2 AESNI MB PMDs.\n");
13845 return TEST_SKIPPED;
13849 /* attach 2 AESNI_MB cdevs */
13850 for (i = count; i < count + 2; i++) {
13851 struct rte_cryptodev_info info;
13852 unsigned int session_size;
13854 rte_cryptodev_info_get(i, &info);
13855 if (info.driver_id != rte_cryptodev_driver_id_get(
13856 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)))
13859 session_size = rte_cryptodev_sym_get_private_session_size(i);
13861 * Create the session mempool again, since now there are new devices
13862 * to use the mempool.
13864 if (ts_params->session_mpool) {
13865 rte_mempool_free(ts_params->session_mpool);
13866 ts_params->session_mpool = NULL;
13868 if (ts_params->session_priv_mpool) {
13869 rte_mempool_free(ts_params->session_priv_mpool);
13870 ts_params->session_priv_mpool = NULL;
13873 if (info.sym.max_nb_sessions != 0 &&
13874 info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
13875 RTE_LOG(ERR, USER1,
13876 "Device does not support "
13877 "at least %u sessions\n",
13879 return TEST_FAILED;
13882 * Create mempool with maximum number of sessions,
13883 * to include the session headers
13885 if (ts_params->session_mpool == NULL) {
13886 ts_params->session_mpool =
13887 rte_cryptodev_sym_session_pool_create(
13889 MAX_NB_SESSIONS, 0, 0, 0,
13891 TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
13892 "session mempool allocation failed");
13896 * Create mempool with maximum number of sessions,
13897 * to include device specific session private data
13899 if (ts_params->session_priv_mpool == NULL) {
13900 ts_params->session_priv_mpool = rte_mempool_create(
13901 "test_sess_mp_priv",
13904 0, 0, NULL, NULL, NULL,
13905 NULL, SOCKET_ID_ANY,
13908 TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
13909 "session mempool allocation failed");
13912 ts_params->qp_conf.mp_session = ts_params->session_mpool;
13913 ts_params->qp_conf.mp_session_private =
13914 ts_params->session_priv_mpool;
13916 ret = rte_cryptodev_scheduler_worker_attach(sched_id,
13919 TEST_ASSERT(ret == 0,
13920 "Failed to attach device %u of pmd : %s", i,
13921 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
13923 aesni_ids[nb_devs_attached] = (uint8_t)i;
13925 nb_devs_attached++;
13932 test_scheduler_detach_worker_op(void)
13934 struct crypto_testsuite_params *ts_params = &testsuite_params;
13935 uint8_t sched_id = ts_params->valid_devs[0];
13939 for (i = 0; i < 2; i++) {
13940 ret = rte_cryptodev_scheduler_worker_detach(sched_id,
13942 TEST_ASSERT(ret == 0,
13943 "Failed to detach device %u", aesni_ids[i]);
13950 test_scheduler_mode_op(enum rte_cryptodev_scheduler_mode scheduler_mode)
13952 struct crypto_testsuite_params *ts_params = &testsuite_params;
13953 uint8_t sched_id = ts_params->valid_devs[0];
13955 return rte_cryptodev_scheduler_mode_set(sched_id,
13960 test_scheduler_mode_roundrobin_op(void)
13962 TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) ==
13963 0, "Failed to set roundrobin mode");
13969 test_scheduler_mode_multicore_op(void)
13971 TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) ==
13972 0, "Failed to set multicore mode");
13978 test_scheduler_mode_failover_op(void)
13980 TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) ==
13981 0, "Failed to set failover mode");
13987 test_scheduler_mode_pkt_size_distr_op(void)
13989 TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) ==
13990 0, "Failed to set pktsize mode");
13996 scheduler_multicore_testsuite_setup(void)
13998 if (test_scheduler_attach_worker_op() < 0)
13999 return TEST_SKIPPED;
14000 if (test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) < 0)
14001 return TEST_SKIPPED;
14006 scheduler_roundrobin_testsuite_setup(void)
14008 if (test_scheduler_attach_worker_op() < 0)
14009 return TEST_SKIPPED;
14010 if (test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) < 0)
14011 return TEST_SKIPPED;
14016 scheduler_failover_testsuite_setup(void)
14018 if (test_scheduler_attach_worker_op() < 0)
14019 return TEST_SKIPPED;
14020 if (test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) < 0)
14021 return TEST_SKIPPED;
14026 scheduler_pkt_size_distr_testsuite_setup(void)
14028 if (test_scheduler_attach_worker_op() < 0)
14029 return TEST_SKIPPED;
14030 if (test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) < 0)
14031 return TEST_SKIPPED;
14036 scheduler_mode_testsuite_teardown(void)
14038 test_scheduler_detach_worker_op();
14041 #endif /* RTE_CRYPTO_SCHEDULER */
14043 static struct unit_test_suite end_testsuite = {
14044 .suite_name = NULL,
14047 .unit_test_suites = NULL
14050 #ifdef RTE_LIB_SECURITY
14051 static struct unit_test_suite ipsec_proto_testsuite = {
14052 .suite_name = "IPsec Proto Unit Test Suite",
14053 .setup = ipsec_proto_testsuite_setup,
14054 .unit_test_cases = {
14055 TEST_CASE_NAMED_WITH_DATA(
14056 "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 128)",
14057 ut_setup_security, ut_teardown,
14058 test_ipsec_proto_known_vec_inb, &pkt_aes_128_gcm),
14059 TEST_CASE_NAMED_WITH_DATA(
14060 "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 192)",
14061 ut_setup_security, ut_teardown,
14062 test_ipsec_proto_known_vec_inb, &pkt_aes_192_gcm),
14063 TEST_CASE_NAMED_WITH_DATA(
14064 "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 256)",
14065 ut_setup_security, ut_teardown,
14066 test_ipsec_proto_known_vec_inb, &pkt_aes_256_gcm),
14067 TEST_CASE_NAMED_ST(
14068 "Combined test alg list",
14069 ut_setup_security, ut_teardown,
14070 test_ipsec_proto_display_list),
14071 TEST_CASE_NAMED_ST(
14073 ut_setup_security, ut_teardown,
14074 test_ipsec_proto_iv_gen),
14075 TEST_CASE_NAMED_ST(
14076 "Negative test: ICV corruption",
14077 ut_setup_security, ut_teardown,
14078 test_ipsec_proto_err_icv_corrupt),
14079 TEST_CASES_END() /**< NULL terminate unit test array */
14083 static struct unit_test_suite pdcp_proto_testsuite = {
14084 .suite_name = "PDCP Proto Unit Test Suite",
14085 .setup = pdcp_proto_testsuite_setup,
14086 .unit_test_cases = {
14087 TEST_CASE_ST(ut_setup_security, ut_teardown,
14088 test_PDCP_PROTO_all),
14089 TEST_CASES_END() /**< NULL terminate unit test array */
14093 static struct unit_test_suite docsis_proto_testsuite = {
14094 .suite_name = "Docsis Proto Unit Test Suite",
14095 .setup = docsis_proto_testsuite_setup,
14096 .unit_test_cases = {
14097 TEST_CASE_ST(ut_setup_security, ut_teardown,
14098 test_DOCSIS_PROTO_all),
14099 TEST_CASES_END() /**< NULL terminate unit test array */
14104 static struct unit_test_suite cryptodev_gen_testsuite = {
14105 .suite_name = "Crypto General Unit Test Suite",
14106 .setup = crypto_gen_testsuite_setup,
14107 .unit_test_cases = {
14108 TEST_CASE_ST(ut_setup, ut_teardown,
14109 test_device_configure_invalid_dev_id),
14110 TEST_CASE_ST(ut_setup, ut_teardown,
14111 test_queue_pair_descriptor_setup),
14112 TEST_CASE_ST(ut_setup, ut_teardown,
14113 test_device_configure_invalid_queue_pair_ids),
14114 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
14115 TEST_CASE_ST(ut_setup, ut_teardown, test_enq_callback_setup),
14116 TEST_CASE_ST(ut_setup, ut_teardown, test_deq_callback_setup),
14117 TEST_CASES_END() /**< NULL terminate unit test array */
14121 static struct unit_test_suite cryptodev_negative_hmac_sha1_testsuite = {
14122 .suite_name = "Negative HMAC SHA1 Unit Test Suite",
14123 .setup = negative_hmac_sha1_testsuite_setup,
14124 .unit_test_cases = {
14125 /** Negative tests */
14126 TEST_CASE_ST(ut_setup, ut_teardown,
14127 authentication_verify_HMAC_SHA1_fail_data_corrupt),
14128 TEST_CASE_ST(ut_setup, ut_teardown,
14129 authentication_verify_HMAC_SHA1_fail_tag_corrupt),
14130 TEST_CASE_ST(ut_setup, ut_teardown,
14131 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
14132 TEST_CASE_ST(ut_setup, ut_teardown,
14133 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
14135 TEST_CASES_END() /**< NULL terminate unit test array */
14139 static struct unit_test_suite cryptodev_multi_session_testsuite = {
14140 .suite_name = "Multi Session Unit Test Suite",
14141 .setup = multi_session_testsuite_setup,
14142 .unit_test_cases = {
14143 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
14144 TEST_CASE_ST(ut_setup, ut_teardown,
14145 test_multi_session_random_usage),
14147 TEST_CASES_END() /**< NULL terminate unit test array */
14151 static struct unit_test_suite cryptodev_null_testsuite = {
14152 .suite_name = "NULL Test Suite",
14153 .setup = null_testsuite_setup,
14154 .unit_test_cases = {
14155 TEST_CASE_ST(ut_setup, ut_teardown,
14156 test_null_invalid_operation),
14157 TEST_CASE_ST(ut_setup, ut_teardown, test_null_burst_operation),
14162 static struct unit_test_suite cryptodev_aes_ccm_auth_testsuite = {
14163 .suite_name = "AES CCM Authenticated Test Suite",
14164 .setup = aes_ccm_auth_testsuite_setup,
14165 .unit_test_cases = {
14166 /** AES CCM Authenticated Encryption 128 bits key*/
14167 TEST_CASE_ST(ut_setup, ut_teardown,
14168 test_AES_CCM_authenticated_encryption_test_case_128_1),
14169 TEST_CASE_ST(ut_setup, ut_teardown,
14170 test_AES_CCM_authenticated_encryption_test_case_128_2),
14171 TEST_CASE_ST(ut_setup, ut_teardown,
14172 test_AES_CCM_authenticated_encryption_test_case_128_3),
14174 /** AES CCM Authenticated Decryption 128 bits key*/
14175 TEST_CASE_ST(ut_setup, ut_teardown,
14176 test_AES_CCM_authenticated_decryption_test_case_128_1),
14177 TEST_CASE_ST(ut_setup, ut_teardown,
14178 test_AES_CCM_authenticated_decryption_test_case_128_2),
14179 TEST_CASE_ST(ut_setup, ut_teardown,
14180 test_AES_CCM_authenticated_decryption_test_case_128_3),
14182 /** AES CCM Authenticated Encryption 192 bits key */
14183 TEST_CASE_ST(ut_setup, ut_teardown,
14184 test_AES_CCM_authenticated_encryption_test_case_192_1),
14185 TEST_CASE_ST(ut_setup, ut_teardown,
14186 test_AES_CCM_authenticated_encryption_test_case_192_2),
14187 TEST_CASE_ST(ut_setup, ut_teardown,
14188 test_AES_CCM_authenticated_encryption_test_case_192_3),
14190 /** AES CCM Authenticated Decryption 192 bits key*/
14191 TEST_CASE_ST(ut_setup, ut_teardown,
14192 test_AES_CCM_authenticated_decryption_test_case_192_1),
14193 TEST_CASE_ST(ut_setup, ut_teardown,
14194 test_AES_CCM_authenticated_decryption_test_case_192_2),
14195 TEST_CASE_ST(ut_setup, ut_teardown,
14196 test_AES_CCM_authenticated_decryption_test_case_192_3),
14198 /** AES CCM Authenticated Encryption 256 bits key */
14199 TEST_CASE_ST(ut_setup, ut_teardown,
14200 test_AES_CCM_authenticated_encryption_test_case_256_1),
14201 TEST_CASE_ST(ut_setup, ut_teardown,
14202 test_AES_CCM_authenticated_encryption_test_case_256_2),
14203 TEST_CASE_ST(ut_setup, ut_teardown,
14204 test_AES_CCM_authenticated_encryption_test_case_256_3),
14206 /** AES CCM Authenticated Decryption 256 bits key*/
14207 TEST_CASE_ST(ut_setup, ut_teardown,
14208 test_AES_CCM_authenticated_decryption_test_case_256_1),
14209 TEST_CASE_ST(ut_setup, ut_teardown,
14210 test_AES_CCM_authenticated_decryption_test_case_256_2),
14211 TEST_CASE_ST(ut_setup, ut_teardown,
14212 test_AES_CCM_authenticated_decryption_test_case_256_3),
14217 static struct unit_test_suite cryptodev_aes_gcm_auth_testsuite = {
14218 .suite_name = "AES GCM Authenticated Test Suite",
14219 .setup = aes_gcm_auth_testsuite_setup,
14220 .unit_test_cases = {
14221 /** AES GCM Authenticated Encryption */
14222 TEST_CASE_ST(ut_setup, ut_teardown,
14223 test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
14224 TEST_CASE_ST(ut_setup, ut_teardown,
14225 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
14226 TEST_CASE_ST(ut_setup, ut_teardown,
14227 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
14228 TEST_CASE_ST(ut_setup, ut_teardown,
14229 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
14230 TEST_CASE_ST(ut_setup, ut_teardown,
14231 test_AES_GCM_authenticated_encryption_test_case_1),
14232 TEST_CASE_ST(ut_setup, ut_teardown,
14233 test_AES_GCM_authenticated_encryption_test_case_2),
14234 TEST_CASE_ST(ut_setup, ut_teardown,
14235 test_AES_GCM_authenticated_encryption_test_case_3),
14236 TEST_CASE_ST(ut_setup, ut_teardown,
14237 test_AES_GCM_authenticated_encryption_test_case_4),
14238 TEST_CASE_ST(ut_setup, ut_teardown,
14239 test_AES_GCM_authenticated_encryption_test_case_5),
14240 TEST_CASE_ST(ut_setup, ut_teardown,
14241 test_AES_GCM_authenticated_encryption_test_case_6),
14242 TEST_CASE_ST(ut_setup, ut_teardown,
14243 test_AES_GCM_authenticated_encryption_test_case_7),
14244 TEST_CASE_ST(ut_setup, ut_teardown,
14245 test_AES_GCM_authenticated_encryption_test_case_8),
14246 TEST_CASE_ST(ut_setup, ut_teardown,
14247 test_AES_GCM_J0_authenticated_encryption_test_case_1),
14249 /** AES GCM Authenticated Decryption */
14250 TEST_CASE_ST(ut_setup, ut_teardown,
14251 test_AES_GCM_authenticated_decryption_test_case_1),
14252 TEST_CASE_ST(ut_setup, ut_teardown,
14253 test_AES_GCM_authenticated_decryption_test_case_2),
14254 TEST_CASE_ST(ut_setup, ut_teardown,
14255 test_AES_GCM_authenticated_decryption_test_case_3),
14256 TEST_CASE_ST(ut_setup, ut_teardown,
14257 test_AES_GCM_authenticated_decryption_test_case_4),
14258 TEST_CASE_ST(ut_setup, ut_teardown,
14259 test_AES_GCM_authenticated_decryption_test_case_5),
14260 TEST_CASE_ST(ut_setup, ut_teardown,
14261 test_AES_GCM_authenticated_decryption_test_case_6),
14262 TEST_CASE_ST(ut_setup, ut_teardown,
14263 test_AES_GCM_authenticated_decryption_test_case_7),
14264 TEST_CASE_ST(ut_setup, ut_teardown,
14265 test_AES_GCM_authenticated_decryption_test_case_8),
14266 TEST_CASE_ST(ut_setup, ut_teardown,
14267 test_AES_GCM_J0_authenticated_decryption_test_case_1),
14269 /** AES GCM Authenticated Encryption 192 bits key */
14270 TEST_CASE_ST(ut_setup, ut_teardown,
14271 test_AES_GCM_auth_encryption_test_case_192_1),
14272 TEST_CASE_ST(ut_setup, ut_teardown,
14273 test_AES_GCM_auth_encryption_test_case_192_2),
14274 TEST_CASE_ST(ut_setup, ut_teardown,
14275 test_AES_GCM_auth_encryption_test_case_192_3),
14276 TEST_CASE_ST(ut_setup, ut_teardown,
14277 test_AES_GCM_auth_encryption_test_case_192_4),
14278 TEST_CASE_ST(ut_setup, ut_teardown,
14279 test_AES_GCM_auth_encryption_test_case_192_5),
14280 TEST_CASE_ST(ut_setup, ut_teardown,
14281 test_AES_GCM_auth_encryption_test_case_192_6),
14282 TEST_CASE_ST(ut_setup, ut_teardown,
14283 test_AES_GCM_auth_encryption_test_case_192_7),
14285 /** AES GCM Authenticated Decryption 192 bits key */
14286 TEST_CASE_ST(ut_setup, ut_teardown,
14287 test_AES_GCM_auth_decryption_test_case_192_1),
14288 TEST_CASE_ST(ut_setup, ut_teardown,
14289 test_AES_GCM_auth_decryption_test_case_192_2),
14290 TEST_CASE_ST(ut_setup, ut_teardown,
14291 test_AES_GCM_auth_decryption_test_case_192_3),
14292 TEST_CASE_ST(ut_setup, ut_teardown,
14293 test_AES_GCM_auth_decryption_test_case_192_4),
14294 TEST_CASE_ST(ut_setup, ut_teardown,
14295 test_AES_GCM_auth_decryption_test_case_192_5),
14296 TEST_CASE_ST(ut_setup, ut_teardown,
14297 test_AES_GCM_auth_decryption_test_case_192_6),
14298 TEST_CASE_ST(ut_setup, ut_teardown,
14299 test_AES_GCM_auth_decryption_test_case_192_7),
14301 /** AES GCM Authenticated Encryption 256 bits key */
14302 TEST_CASE_ST(ut_setup, ut_teardown,
14303 test_AES_GCM_auth_encryption_test_case_256_1),
14304 TEST_CASE_ST(ut_setup, ut_teardown,
14305 test_AES_GCM_auth_encryption_test_case_256_2),
14306 TEST_CASE_ST(ut_setup, ut_teardown,
14307 test_AES_GCM_auth_encryption_test_case_256_3),
14308 TEST_CASE_ST(ut_setup, ut_teardown,
14309 test_AES_GCM_auth_encryption_test_case_256_4),
14310 TEST_CASE_ST(ut_setup, ut_teardown,
14311 test_AES_GCM_auth_encryption_test_case_256_5),
14312 TEST_CASE_ST(ut_setup, ut_teardown,
14313 test_AES_GCM_auth_encryption_test_case_256_6),
14314 TEST_CASE_ST(ut_setup, ut_teardown,
14315 test_AES_GCM_auth_encryption_test_case_256_7),
14317 /** AES GCM Authenticated Decryption 256 bits key */
14318 TEST_CASE_ST(ut_setup, ut_teardown,
14319 test_AES_GCM_auth_decryption_test_case_256_1),
14320 TEST_CASE_ST(ut_setup, ut_teardown,
14321 test_AES_GCM_auth_decryption_test_case_256_2),
14322 TEST_CASE_ST(ut_setup, ut_teardown,
14323 test_AES_GCM_auth_decryption_test_case_256_3),
14324 TEST_CASE_ST(ut_setup, ut_teardown,
14325 test_AES_GCM_auth_decryption_test_case_256_4),
14326 TEST_CASE_ST(ut_setup, ut_teardown,
14327 test_AES_GCM_auth_decryption_test_case_256_5),
14328 TEST_CASE_ST(ut_setup, ut_teardown,
14329 test_AES_GCM_auth_decryption_test_case_256_6),
14330 TEST_CASE_ST(ut_setup, ut_teardown,
14331 test_AES_GCM_auth_decryption_test_case_256_7),
14333 /** AES GCM Authenticated Encryption big aad size */
14334 TEST_CASE_ST(ut_setup, ut_teardown,
14335 test_AES_GCM_auth_encryption_test_case_aad_1),
14336 TEST_CASE_ST(ut_setup, ut_teardown,
14337 test_AES_GCM_auth_encryption_test_case_aad_2),
14339 /** AES GCM Authenticated Decryption big aad size */
14340 TEST_CASE_ST(ut_setup, ut_teardown,
14341 test_AES_GCM_auth_decryption_test_case_aad_1),
14342 TEST_CASE_ST(ut_setup, ut_teardown,
14343 test_AES_GCM_auth_decryption_test_case_aad_2),
14345 /** Out of place tests */
14346 TEST_CASE_ST(ut_setup, ut_teardown,
14347 test_AES_GCM_authenticated_encryption_oop_test_case_1),
14348 TEST_CASE_ST(ut_setup, ut_teardown,
14349 test_AES_GCM_authenticated_decryption_oop_test_case_1),
14351 /** Session-less tests */
14352 TEST_CASE_ST(ut_setup, ut_teardown,
14353 test_AES_GCM_authenticated_encryption_sessionless_test_case_1),
14354 TEST_CASE_ST(ut_setup, ut_teardown,
14355 test_AES_GCM_authenticated_decryption_sessionless_test_case_1),
14361 static struct unit_test_suite cryptodev_aes_gmac_auth_testsuite = {
14362 .suite_name = "AES GMAC Authentication Test Suite",
14363 .setup = aes_gmac_auth_testsuite_setup,
14364 .unit_test_cases = {
14365 TEST_CASE_ST(ut_setup, ut_teardown,
14366 test_AES_GMAC_authentication_test_case_1),
14367 TEST_CASE_ST(ut_setup, ut_teardown,
14368 test_AES_GMAC_authentication_verify_test_case_1),
14369 TEST_CASE_ST(ut_setup, ut_teardown,
14370 test_AES_GMAC_authentication_test_case_2),
14371 TEST_CASE_ST(ut_setup, ut_teardown,
14372 test_AES_GMAC_authentication_verify_test_case_2),
14373 TEST_CASE_ST(ut_setup, ut_teardown,
14374 test_AES_GMAC_authentication_test_case_3),
14375 TEST_CASE_ST(ut_setup, ut_teardown,
14376 test_AES_GMAC_authentication_verify_test_case_3),
14377 TEST_CASE_ST(ut_setup, ut_teardown,
14378 test_AES_GMAC_authentication_test_case_4),
14379 TEST_CASE_ST(ut_setup, ut_teardown,
14380 test_AES_GMAC_authentication_verify_test_case_4),
14381 TEST_CASE_ST(ut_setup, ut_teardown,
14382 test_AES_GMAC_authentication_SGL_40B),
14383 TEST_CASE_ST(ut_setup, ut_teardown,
14384 test_AES_GMAC_authentication_SGL_80B),
14385 TEST_CASE_ST(ut_setup, ut_teardown,
14386 test_AES_GMAC_authentication_SGL_2048B),
14387 TEST_CASE_ST(ut_setup, ut_teardown,
14388 test_AES_GMAC_authentication_SGL_2047B),
14394 static struct unit_test_suite cryptodev_chacha20_poly1305_testsuite = {
14395 .suite_name = "Chacha20-Poly1305 Test Suite",
14396 .setup = chacha20_poly1305_testsuite_setup,
14397 .unit_test_cases = {
14398 TEST_CASE_ST(ut_setup, ut_teardown,
14399 test_chacha20_poly1305_encrypt_test_case_rfc8439),
14400 TEST_CASE_ST(ut_setup, ut_teardown,
14401 test_chacha20_poly1305_decrypt_test_case_rfc8439),
14406 static struct unit_test_suite cryptodev_snow3g_testsuite = {
14407 .suite_name = "SNOW 3G Test Suite",
14408 .setup = snow3g_testsuite_setup,
14409 .unit_test_cases = {
14410 /** SNOW 3G encrypt only (UEA2) */
14411 TEST_CASE_ST(ut_setup, ut_teardown,
14412 test_snow3g_encryption_test_case_1),
14413 TEST_CASE_ST(ut_setup, ut_teardown,
14414 test_snow3g_encryption_test_case_2),
14415 TEST_CASE_ST(ut_setup, ut_teardown,
14416 test_snow3g_encryption_test_case_3),
14417 TEST_CASE_ST(ut_setup, ut_teardown,
14418 test_snow3g_encryption_test_case_4),
14419 TEST_CASE_ST(ut_setup, ut_teardown,
14420 test_snow3g_encryption_test_case_5),
14422 TEST_CASE_ST(ut_setup, ut_teardown,
14423 test_snow3g_encryption_test_case_1_oop),
14424 TEST_CASE_ST(ut_setup, ut_teardown,
14425 test_snow3g_encryption_test_case_1_oop_sgl),
14426 TEST_CASE_ST(ut_setup, ut_teardown,
14427 test_snow3g_encryption_test_case_1_offset_oop),
14428 TEST_CASE_ST(ut_setup, ut_teardown,
14429 test_snow3g_decryption_test_case_1_oop),
14431 /** SNOW 3G generate auth, then encrypt (UEA2) */
14432 TEST_CASE_ST(ut_setup, ut_teardown,
14433 test_snow3g_auth_cipher_test_case_1),
14434 TEST_CASE_ST(ut_setup, ut_teardown,
14435 test_snow3g_auth_cipher_test_case_2),
14436 TEST_CASE_ST(ut_setup, ut_teardown,
14437 test_snow3g_auth_cipher_test_case_2_oop),
14438 TEST_CASE_ST(ut_setup, ut_teardown,
14439 test_snow3g_auth_cipher_part_digest_enc),
14440 TEST_CASE_ST(ut_setup, ut_teardown,
14441 test_snow3g_auth_cipher_part_digest_enc_oop),
14442 TEST_CASE_ST(ut_setup, ut_teardown,
14443 test_snow3g_auth_cipher_test_case_3_sgl),
14444 TEST_CASE_ST(ut_setup, ut_teardown,
14445 test_snow3g_auth_cipher_test_case_3_oop_sgl),
14446 TEST_CASE_ST(ut_setup, ut_teardown,
14447 test_snow3g_auth_cipher_part_digest_enc_sgl),
14448 TEST_CASE_ST(ut_setup, ut_teardown,
14449 test_snow3g_auth_cipher_part_digest_enc_oop_sgl),
14451 /** SNOW 3G decrypt (UEA2), then verify auth */
14452 TEST_CASE_ST(ut_setup, ut_teardown,
14453 test_snow3g_auth_cipher_verify_test_case_1),
14454 TEST_CASE_ST(ut_setup, ut_teardown,
14455 test_snow3g_auth_cipher_verify_test_case_2),
14456 TEST_CASE_ST(ut_setup, ut_teardown,
14457 test_snow3g_auth_cipher_verify_test_case_2_oop),
14458 TEST_CASE_ST(ut_setup, ut_teardown,
14459 test_snow3g_auth_cipher_verify_part_digest_enc),
14460 TEST_CASE_ST(ut_setup, ut_teardown,
14461 test_snow3g_auth_cipher_verify_part_digest_enc_oop),
14462 TEST_CASE_ST(ut_setup, ut_teardown,
14463 test_snow3g_auth_cipher_verify_test_case_3_sgl),
14464 TEST_CASE_ST(ut_setup, ut_teardown,
14465 test_snow3g_auth_cipher_verify_test_case_3_oop_sgl),
14466 TEST_CASE_ST(ut_setup, ut_teardown,
14467 test_snow3g_auth_cipher_verify_part_digest_enc_sgl),
14468 TEST_CASE_ST(ut_setup, ut_teardown,
14469 test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl),
14471 /** SNOW 3G decrypt only (UEA2) */
14472 TEST_CASE_ST(ut_setup, ut_teardown,
14473 test_snow3g_decryption_test_case_1),
14474 TEST_CASE_ST(ut_setup, ut_teardown,
14475 test_snow3g_decryption_test_case_2),
14476 TEST_CASE_ST(ut_setup, ut_teardown,
14477 test_snow3g_decryption_test_case_3),
14478 TEST_CASE_ST(ut_setup, ut_teardown,
14479 test_snow3g_decryption_test_case_4),
14480 TEST_CASE_ST(ut_setup, ut_teardown,
14481 test_snow3g_decryption_test_case_5),
14482 TEST_CASE_ST(ut_setup, ut_teardown,
14483 test_snow3g_decryption_with_digest_test_case_1),
14484 TEST_CASE_ST(ut_setup, ut_teardown,
14485 test_snow3g_hash_generate_test_case_1),
14486 TEST_CASE_ST(ut_setup, ut_teardown,
14487 test_snow3g_hash_generate_test_case_2),
14488 TEST_CASE_ST(ut_setup, ut_teardown,
14489 test_snow3g_hash_generate_test_case_3),
14491 /* Tests with buffers which length is not byte-aligned */
14492 TEST_CASE_ST(ut_setup, ut_teardown,
14493 test_snow3g_hash_generate_test_case_4),
14494 TEST_CASE_ST(ut_setup, ut_teardown,
14495 test_snow3g_hash_generate_test_case_5),
14496 TEST_CASE_ST(ut_setup, ut_teardown,
14497 test_snow3g_hash_generate_test_case_6),
14498 TEST_CASE_ST(ut_setup, ut_teardown,
14499 test_snow3g_hash_verify_test_case_1),
14500 TEST_CASE_ST(ut_setup, ut_teardown,
14501 test_snow3g_hash_verify_test_case_2),
14502 TEST_CASE_ST(ut_setup, ut_teardown,
14503 test_snow3g_hash_verify_test_case_3),
14505 /* Tests with buffers which length is not byte-aligned */
14506 TEST_CASE_ST(ut_setup, ut_teardown,
14507 test_snow3g_hash_verify_test_case_4),
14508 TEST_CASE_ST(ut_setup, ut_teardown,
14509 test_snow3g_hash_verify_test_case_5),
14510 TEST_CASE_ST(ut_setup, ut_teardown,
14511 test_snow3g_hash_verify_test_case_6),
14512 TEST_CASE_ST(ut_setup, ut_teardown,
14513 test_snow3g_cipher_auth_test_case_1),
14514 TEST_CASE_ST(ut_setup, ut_teardown,
14515 test_snow3g_auth_cipher_with_digest_test_case_1),
14520 static struct unit_test_suite cryptodev_zuc_testsuite = {
14521 .suite_name = "ZUC Test Suite",
14522 .setup = zuc_testsuite_setup,
14523 .unit_test_cases = {
14524 /** ZUC encrypt only (EEA3) */
14525 TEST_CASE_ST(ut_setup, ut_teardown,
14526 test_zuc_encryption_test_case_1),
14527 TEST_CASE_ST(ut_setup, ut_teardown,
14528 test_zuc_encryption_test_case_2),
14529 TEST_CASE_ST(ut_setup, ut_teardown,
14530 test_zuc_encryption_test_case_3),
14531 TEST_CASE_ST(ut_setup, ut_teardown,
14532 test_zuc_encryption_test_case_4),
14533 TEST_CASE_ST(ut_setup, ut_teardown,
14534 test_zuc_encryption_test_case_5),
14535 TEST_CASE_ST(ut_setup, ut_teardown,
14536 test_zuc_encryption_test_case_6_sgl),
14538 /** ZUC authenticate (EIA3) */
14539 TEST_CASE_ST(ut_setup, ut_teardown,
14540 test_zuc_hash_generate_test_case_1),
14541 TEST_CASE_ST(ut_setup, ut_teardown,
14542 test_zuc_hash_generate_test_case_2),
14543 TEST_CASE_ST(ut_setup, ut_teardown,
14544 test_zuc_hash_generate_test_case_3),
14545 TEST_CASE_ST(ut_setup, ut_teardown,
14546 test_zuc_hash_generate_test_case_4),
14547 TEST_CASE_ST(ut_setup, ut_teardown,
14548 test_zuc_hash_generate_test_case_5),
14549 TEST_CASE_ST(ut_setup, ut_teardown,
14550 test_zuc_hash_generate_test_case_6),
14551 TEST_CASE_ST(ut_setup, ut_teardown,
14552 test_zuc_hash_generate_test_case_7),
14553 TEST_CASE_ST(ut_setup, ut_teardown,
14554 test_zuc_hash_generate_test_case_8),
14556 /** ZUC alg-chain (EEA3/EIA3) */
14557 TEST_CASE_ST(ut_setup, ut_teardown,
14558 test_zuc_cipher_auth_test_case_1),
14559 TEST_CASE_ST(ut_setup, ut_teardown,
14560 test_zuc_cipher_auth_test_case_2),
14562 /** ZUC generate auth, then encrypt (EEA3) */
14563 TEST_CASE_ST(ut_setup, ut_teardown,
14564 test_zuc_auth_cipher_test_case_1),
14565 TEST_CASE_ST(ut_setup, ut_teardown,
14566 test_zuc_auth_cipher_test_case_1_oop),
14567 TEST_CASE_ST(ut_setup, ut_teardown,
14568 test_zuc_auth_cipher_test_case_1_sgl),
14569 TEST_CASE_ST(ut_setup, ut_teardown,
14570 test_zuc_auth_cipher_test_case_1_oop_sgl),
14572 /** ZUC decrypt (EEA3), then verify auth */
14573 TEST_CASE_ST(ut_setup, ut_teardown,
14574 test_zuc_auth_cipher_verify_test_case_1),
14575 TEST_CASE_ST(ut_setup, ut_teardown,
14576 test_zuc_auth_cipher_verify_test_case_1_oop),
14577 TEST_CASE_ST(ut_setup, ut_teardown,
14578 test_zuc_auth_cipher_verify_test_case_1_sgl),
14579 TEST_CASE_ST(ut_setup, ut_teardown,
14580 test_zuc_auth_cipher_verify_test_case_1_oop_sgl),
14585 static struct unit_test_suite cryptodev_hmac_md5_auth_testsuite = {
14586 .suite_name = "HMAC_MD5 Authentication Test Suite",
14587 .setup = hmac_md5_auth_testsuite_setup,
14588 .unit_test_cases = {
14589 TEST_CASE_ST(ut_setup, ut_teardown,
14590 test_MD5_HMAC_generate_case_1),
14591 TEST_CASE_ST(ut_setup, ut_teardown,
14592 test_MD5_HMAC_verify_case_1),
14593 TEST_CASE_ST(ut_setup, ut_teardown,
14594 test_MD5_HMAC_generate_case_2),
14595 TEST_CASE_ST(ut_setup, ut_teardown,
14596 test_MD5_HMAC_verify_case_2),
14601 static struct unit_test_suite cryptodev_kasumi_testsuite = {
14602 .suite_name = "Kasumi Test Suite",
14603 .setup = kasumi_testsuite_setup,
14604 .unit_test_cases = {
14605 /** KASUMI hash only (UIA1) */
14606 TEST_CASE_ST(ut_setup, ut_teardown,
14607 test_kasumi_hash_generate_test_case_1),
14608 TEST_CASE_ST(ut_setup, ut_teardown,
14609 test_kasumi_hash_generate_test_case_2),
14610 TEST_CASE_ST(ut_setup, ut_teardown,
14611 test_kasumi_hash_generate_test_case_3),
14612 TEST_CASE_ST(ut_setup, ut_teardown,
14613 test_kasumi_hash_generate_test_case_4),
14614 TEST_CASE_ST(ut_setup, ut_teardown,
14615 test_kasumi_hash_generate_test_case_5),
14616 TEST_CASE_ST(ut_setup, ut_teardown,
14617 test_kasumi_hash_generate_test_case_6),
14619 TEST_CASE_ST(ut_setup, ut_teardown,
14620 test_kasumi_hash_verify_test_case_1),
14621 TEST_CASE_ST(ut_setup, ut_teardown,
14622 test_kasumi_hash_verify_test_case_2),
14623 TEST_CASE_ST(ut_setup, ut_teardown,
14624 test_kasumi_hash_verify_test_case_3),
14625 TEST_CASE_ST(ut_setup, ut_teardown,
14626 test_kasumi_hash_verify_test_case_4),
14627 TEST_CASE_ST(ut_setup, ut_teardown,
14628 test_kasumi_hash_verify_test_case_5),
14630 /** KASUMI encrypt only (UEA1) */
14631 TEST_CASE_ST(ut_setup, ut_teardown,
14632 test_kasumi_encryption_test_case_1),
14633 TEST_CASE_ST(ut_setup, ut_teardown,
14634 test_kasumi_encryption_test_case_1_sgl),
14635 TEST_CASE_ST(ut_setup, ut_teardown,
14636 test_kasumi_encryption_test_case_1_oop),
14637 TEST_CASE_ST(ut_setup, ut_teardown,
14638 test_kasumi_encryption_test_case_1_oop_sgl),
14639 TEST_CASE_ST(ut_setup, ut_teardown,
14640 test_kasumi_encryption_test_case_2),
14641 TEST_CASE_ST(ut_setup, ut_teardown,
14642 test_kasumi_encryption_test_case_3),
14643 TEST_CASE_ST(ut_setup, ut_teardown,
14644 test_kasumi_encryption_test_case_4),
14645 TEST_CASE_ST(ut_setup, ut_teardown,
14646 test_kasumi_encryption_test_case_5),
14648 /** KASUMI decrypt only (UEA1) */
14649 TEST_CASE_ST(ut_setup, ut_teardown,
14650 test_kasumi_decryption_test_case_1),
14651 TEST_CASE_ST(ut_setup, ut_teardown,
14652 test_kasumi_decryption_test_case_2),
14653 TEST_CASE_ST(ut_setup, ut_teardown,
14654 test_kasumi_decryption_test_case_3),
14655 TEST_CASE_ST(ut_setup, ut_teardown,
14656 test_kasumi_decryption_test_case_4),
14657 TEST_CASE_ST(ut_setup, ut_teardown,
14658 test_kasumi_decryption_test_case_5),
14659 TEST_CASE_ST(ut_setup, ut_teardown,
14660 test_kasumi_decryption_test_case_1_oop),
14661 TEST_CASE_ST(ut_setup, ut_teardown,
14662 test_kasumi_cipher_auth_test_case_1),
14664 /** KASUMI generate auth, then encrypt (F8) */
14665 TEST_CASE_ST(ut_setup, ut_teardown,
14666 test_kasumi_auth_cipher_test_case_1),
14667 TEST_CASE_ST(ut_setup, ut_teardown,
14668 test_kasumi_auth_cipher_test_case_2),
14669 TEST_CASE_ST(ut_setup, ut_teardown,
14670 test_kasumi_auth_cipher_test_case_2_oop),
14671 TEST_CASE_ST(ut_setup, ut_teardown,
14672 test_kasumi_auth_cipher_test_case_2_sgl),
14673 TEST_CASE_ST(ut_setup, ut_teardown,
14674 test_kasumi_auth_cipher_test_case_2_oop_sgl),
14676 /** KASUMI decrypt (F8), then verify auth */
14677 TEST_CASE_ST(ut_setup, ut_teardown,
14678 test_kasumi_auth_cipher_verify_test_case_1),
14679 TEST_CASE_ST(ut_setup, ut_teardown,
14680 test_kasumi_auth_cipher_verify_test_case_2),
14681 TEST_CASE_ST(ut_setup, ut_teardown,
14682 test_kasumi_auth_cipher_verify_test_case_2_oop),
14683 TEST_CASE_ST(ut_setup, ut_teardown,
14684 test_kasumi_auth_cipher_verify_test_case_2_sgl),
14685 TEST_CASE_ST(ut_setup, ut_teardown,
14686 test_kasumi_auth_cipher_verify_test_case_2_oop_sgl),
14692 static struct unit_test_suite cryptodev_esn_testsuite = {
14693 .suite_name = "ESN Test Suite",
14694 .setup = esn_testsuite_setup,
14695 .unit_test_cases = {
14696 TEST_CASE_ST(ut_setup, ut_teardown,
14697 auth_encrypt_AES128CBC_HMAC_SHA1_esn_check),
14698 TEST_CASE_ST(ut_setup, ut_teardown,
14699 auth_decrypt_AES128CBC_HMAC_SHA1_esn_check),
14704 static struct unit_test_suite cryptodev_negative_aes_gcm_testsuite = {
14705 .suite_name = "Negative AES GCM Test Suite",
14706 .setup = negative_aes_gcm_testsuite_setup,
14707 .unit_test_cases = {
14708 TEST_CASE_ST(ut_setup, ut_teardown,
14709 test_AES_GCM_auth_encryption_fail_iv_corrupt),
14710 TEST_CASE_ST(ut_setup, ut_teardown,
14711 test_AES_GCM_auth_encryption_fail_in_data_corrupt),
14712 TEST_CASE_ST(ut_setup, ut_teardown,
14713 test_AES_GCM_auth_encryption_fail_out_data_corrupt),
14714 TEST_CASE_ST(ut_setup, ut_teardown,
14715 test_AES_GCM_auth_encryption_fail_aad_len_corrupt),
14716 TEST_CASE_ST(ut_setup, ut_teardown,
14717 test_AES_GCM_auth_encryption_fail_aad_corrupt),
14718 TEST_CASE_ST(ut_setup, ut_teardown,
14719 test_AES_GCM_auth_encryption_fail_tag_corrupt),
14720 TEST_CASE_ST(ut_setup, ut_teardown,
14721 test_AES_GCM_auth_decryption_fail_iv_corrupt),
14722 TEST_CASE_ST(ut_setup, ut_teardown,
14723 test_AES_GCM_auth_decryption_fail_in_data_corrupt),
14724 TEST_CASE_ST(ut_setup, ut_teardown,
14725 test_AES_GCM_auth_decryption_fail_out_data_corrupt),
14726 TEST_CASE_ST(ut_setup, ut_teardown,
14727 test_AES_GCM_auth_decryption_fail_aad_len_corrupt),
14728 TEST_CASE_ST(ut_setup, ut_teardown,
14729 test_AES_GCM_auth_decryption_fail_aad_corrupt),
14730 TEST_CASE_ST(ut_setup, ut_teardown,
14731 test_AES_GCM_auth_decryption_fail_tag_corrupt),
14737 static struct unit_test_suite cryptodev_negative_aes_gmac_testsuite = {
14738 .suite_name = "Negative AES GMAC Test Suite",
14739 .setup = negative_aes_gmac_testsuite_setup,
14740 .unit_test_cases = {
14741 TEST_CASE_ST(ut_setup, ut_teardown,
14742 authentication_verify_AES128_GMAC_fail_data_corrupt),
14743 TEST_CASE_ST(ut_setup, ut_teardown,
14744 authentication_verify_AES128_GMAC_fail_tag_corrupt),
14750 static struct unit_test_suite cryptodev_mixed_cipher_hash_testsuite = {
14751 .suite_name = "Mixed CIPHER + HASH algorithms Test Suite",
14752 .setup = mixed_cipher_hash_testsuite_setup,
14753 .unit_test_cases = {
14754 /** AUTH AES CMAC + CIPHER AES CTR */
14755 TEST_CASE_ST(ut_setup, ut_teardown,
14756 test_aes_cmac_aes_ctr_digest_enc_test_case_1),
14757 TEST_CASE_ST(ut_setup, ut_teardown,
14758 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
14759 TEST_CASE_ST(ut_setup, ut_teardown,
14760 test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
14761 TEST_CASE_ST(ut_setup, ut_teardown,
14762 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
14763 TEST_CASE_ST(ut_setup, ut_teardown,
14764 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1),
14765 TEST_CASE_ST(ut_setup, ut_teardown,
14766 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
14767 TEST_CASE_ST(ut_setup, ut_teardown,
14768 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
14769 TEST_CASE_ST(ut_setup, ut_teardown,
14770 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
14772 /** AUTH ZUC + CIPHER SNOW3G */
14773 TEST_CASE_ST(ut_setup, ut_teardown,
14774 test_auth_zuc_cipher_snow_test_case_1),
14775 TEST_CASE_ST(ut_setup, ut_teardown,
14776 test_verify_auth_zuc_cipher_snow_test_case_1),
14777 /** AUTH AES CMAC + CIPHER SNOW3G */
14778 TEST_CASE_ST(ut_setup, ut_teardown,
14779 test_auth_aes_cmac_cipher_snow_test_case_1),
14780 TEST_CASE_ST(ut_setup, ut_teardown,
14781 test_verify_auth_aes_cmac_cipher_snow_test_case_1),
14782 /** AUTH ZUC + CIPHER AES CTR */
14783 TEST_CASE_ST(ut_setup, ut_teardown,
14784 test_auth_zuc_cipher_aes_ctr_test_case_1),
14785 TEST_CASE_ST(ut_setup, ut_teardown,
14786 test_verify_auth_zuc_cipher_aes_ctr_test_case_1),
14787 /** AUTH SNOW3G + CIPHER AES CTR */
14788 TEST_CASE_ST(ut_setup, ut_teardown,
14789 test_auth_snow_cipher_aes_ctr_test_case_1),
14790 TEST_CASE_ST(ut_setup, ut_teardown,
14791 test_verify_auth_snow_cipher_aes_ctr_test_case_1),
14792 /** AUTH SNOW3G + CIPHER ZUC */
14793 TEST_CASE_ST(ut_setup, ut_teardown,
14794 test_auth_snow_cipher_zuc_test_case_1),
14795 TEST_CASE_ST(ut_setup, ut_teardown,
14796 test_verify_auth_snow_cipher_zuc_test_case_1),
14797 /** AUTH AES CMAC + CIPHER ZUC */
14798 TEST_CASE_ST(ut_setup, ut_teardown,
14799 test_auth_aes_cmac_cipher_zuc_test_case_1),
14800 TEST_CASE_ST(ut_setup, ut_teardown,
14801 test_verify_auth_aes_cmac_cipher_zuc_test_case_1),
14803 /** AUTH NULL + CIPHER SNOW3G */
14804 TEST_CASE_ST(ut_setup, ut_teardown,
14805 test_auth_null_cipher_snow_test_case_1),
14806 TEST_CASE_ST(ut_setup, ut_teardown,
14807 test_verify_auth_null_cipher_snow_test_case_1),
14808 /** AUTH NULL + CIPHER ZUC */
14809 TEST_CASE_ST(ut_setup, ut_teardown,
14810 test_auth_null_cipher_zuc_test_case_1),
14811 TEST_CASE_ST(ut_setup, ut_teardown,
14812 test_verify_auth_null_cipher_zuc_test_case_1),
14813 /** AUTH SNOW3G + CIPHER NULL */
14814 TEST_CASE_ST(ut_setup, ut_teardown,
14815 test_auth_snow_cipher_null_test_case_1),
14816 TEST_CASE_ST(ut_setup, ut_teardown,
14817 test_verify_auth_snow_cipher_null_test_case_1),
14818 /** AUTH ZUC + CIPHER NULL */
14819 TEST_CASE_ST(ut_setup, ut_teardown,
14820 test_auth_zuc_cipher_null_test_case_1),
14821 TEST_CASE_ST(ut_setup, ut_teardown,
14822 test_verify_auth_zuc_cipher_null_test_case_1),
14823 /** AUTH NULL + CIPHER AES CTR */
14824 TEST_CASE_ST(ut_setup, ut_teardown,
14825 test_auth_null_cipher_aes_ctr_test_case_1),
14826 TEST_CASE_ST(ut_setup, ut_teardown,
14827 test_verify_auth_null_cipher_aes_ctr_test_case_1),
14828 /** AUTH AES CMAC + CIPHER NULL */
14829 TEST_CASE_ST(ut_setup, ut_teardown,
14830 test_auth_aes_cmac_cipher_null_test_case_1),
14831 TEST_CASE_ST(ut_setup, ut_teardown,
14832 test_verify_auth_aes_cmac_cipher_null_test_case_1),
14838 run_cryptodev_testsuite(const char *pmd_name)
14840 uint8_t ret, j, i = 0, blk_start_idx = 0;
14841 const enum blockcipher_test_type blk_suites[] = {
14842 BLKCIPHER_AES_CHAIN_TYPE,
14843 BLKCIPHER_AES_CIPHERONLY_TYPE,
14844 BLKCIPHER_AES_DOCSIS_TYPE,
14845 BLKCIPHER_3DES_CHAIN_TYPE,
14846 BLKCIPHER_3DES_CIPHERONLY_TYPE,
14847 BLKCIPHER_DES_CIPHERONLY_TYPE,
14848 BLKCIPHER_DES_DOCSIS_TYPE,
14849 BLKCIPHER_AUTHONLY_TYPE};
14850 struct unit_test_suite *static_suites[] = {
14851 &cryptodev_multi_session_testsuite,
14852 &cryptodev_null_testsuite,
14853 &cryptodev_aes_ccm_auth_testsuite,
14854 &cryptodev_aes_gcm_auth_testsuite,
14855 &cryptodev_aes_gmac_auth_testsuite,
14856 &cryptodev_snow3g_testsuite,
14857 &cryptodev_chacha20_poly1305_testsuite,
14858 &cryptodev_zuc_testsuite,
14859 &cryptodev_hmac_md5_auth_testsuite,
14860 &cryptodev_kasumi_testsuite,
14861 &cryptodev_esn_testsuite,
14862 &cryptodev_negative_aes_gcm_testsuite,
14863 &cryptodev_negative_aes_gmac_testsuite,
14864 &cryptodev_mixed_cipher_hash_testsuite,
14865 &cryptodev_negative_hmac_sha1_testsuite,
14866 &cryptodev_gen_testsuite,
14867 #ifdef RTE_LIB_SECURITY
14868 &ipsec_proto_testsuite,
14869 &pdcp_proto_testsuite,
14870 &docsis_proto_testsuite,
14874 static struct unit_test_suite ts = {
14875 .suite_name = "Cryptodev Unit Test Suite",
14876 .setup = testsuite_setup,
14877 .teardown = testsuite_teardown,
14878 .unit_test_cases = {TEST_CASES_END()}
14881 gbl_driver_id = rte_cryptodev_driver_id_get(pmd_name);
14883 if (gbl_driver_id == -1) {
14884 RTE_LOG(ERR, USER1, "%s PMD must be loaded.\n", pmd_name);
14885 return TEST_SKIPPED;
14888 ts.unit_test_suites = malloc(sizeof(struct unit_test_suite *) *
14889 (RTE_DIM(blk_suites) + RTE_DIM(static_suites)));
14891 ADD_BLOCKCIPHER_TESTSUITE(i, ts, blk_suites, RTE_DIM(blk_suites));
14892 ADD_STATIC_TESTSUITE(i, ts, static_suites, RTE_DIM(static_suites));
14893 ret = unit_test_suite_runner(&ts);
14895 FREE_BLOCKCIPHER_TESTSUITE(blk_start_idx, ts, RTE_DIM(blk_suites));
14896 free(ts.unit_test_suites);
14901 require_feature_flag(const char *pmd_name, uint64_t flag, const char *flag_name)
14903 struct rte_cryptodev_info dev_info;
14904 uint8_t i, nb_devs;
14907 driver_id = rte_cryptodev_driver_id_get(pmd_name);
14908 if (driver_id == -1) {
14909 RTE_LOG(WARNING, USER1, "%s PMD must be loaded.\n", pmd_name);
14910 return TEST_SKIPPED;
14913 nb_devs = rte_cryptodev_count();
14915 RTE_LOG(WARNING, USER1, "No crypto devices found?\n");
14916 return TEST_SKIPPED;
14919 for (i = 0; i < nb_devs; i++) {
14920 rte_cryptodev_info_get(i, &dev_info);
14921 if (dev_info.driver_id == driver_id) {
14922 if (!(dev_info.feature_flags & flag)) {
14923 RTE_LOG(INFO, USER1, "%s not supported\n",
14925 return TEST_SKIPPED;
14927 return 0; /* found */
14931 RTE_LOG(INFO, USER1, "%s not supported\n", flag_name);
14932 return TEST_SKIPPED;
14936 test_cryptodev_qat(void)
14938 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
14942 test_cryptodev_virtio(void)
14944 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD));
14948 test_cryptodev_aesni_mb(void)
14950 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
14954 test_cryptodev_cpu_aesni_mb(void)
14957 enum rte_security_session_action_type at = gbl_action_type;
14958 gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
14959 rc = run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
14960 gbl_action_type = at;
14965 test_cryptodev_openssl(void)
14967 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
14971 test_cryptodev_aesni_gcm(void)
14973 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
14977 test_cryptodev_cpu_aesni_gcm(void)
14980 enum rte_security_session_action_type at = gbl_action_type;
14981 gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
14982 rc = run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
14983 gbl_action_type = at;
14988 test_cryptodev_mlx5(void)
14990 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_MLX5_PMD));
14994 test_cryptodev_null(void)
14996 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_NULL_PMD));
15000 test_cryptodev_sw_snow3g(void)
15002 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
15006 test_cryptodev_sw_kasumi(void)
15008 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
15012 test_cryptodev_sw_zuc(void)
15014 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
15018 test_cryptodev_armv8(void)
15020 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
15024 test_cryptodev_mrvl(void)
15026 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
15029 #ifdef RTE_CRYPTO_SCHEDULER
15032 test_cryptodev_scheduler(void)
15034 uint8_t ret, sched_i, j, i = 0, blk_start_idx = 0;
15035 const enum blockcipher_test_type blk_suites[] = {
15036 BLKCIPHER_AES_CHAIN_TYPE,
15037 BLKCIPHER_AES_CIPHERONLY_TYPE,
15038 BLKCIPHER_AUTHONLY_TYPE
15040 static struct unit_test_suite scheduler_multicore = {
15041 .suite_name = "Scheduler Multicore Unit Test Suite",
15042 .setup = scheduler_multicore_testsuite_setup,
15043 .teardown = scheduler_mode_testsuite_teardown,
15044 .unit_test_cases = {TEST_CASES_END()}
15046 static struct unit_test_suite scheduler_round_robin = {
15047 .suite_name = "Scheduler Round Robin Unit Test Suite",
15048 .setup = scheduler_roundrobin_testsuite_setup,
15049 .teardown = scheduler_mode_testsuite_teardown,
15050 .unit_test_cases = {TEST_CASES_END()}
15052 static struct unit_test_suite scheduler_failover = {
15053 .suite_name = "Scheduler Failover Unit Test Suite",
15054 .setup = scheduler_failover_testsuite_setup,
15055 .teardown = scheduler_mode_testsuite_teardown,
15056 .unit_test_cases = {TEST_CASES_END()}
15058 static struct unit_test_suite scheduler_pkt_size_distr = {
15059 .suite_name = "Scheduler Pkt Size Distr Unit Test Suite",
15060 .setup = scheduler_pkt_size_distr_testsuite_setup,
15061 .teardown = scheduler_mode_testsuite_teardown,
15062 .unit_test_cases = {TEST_CASES_END()}
15064 struct unit_test_suite *sched_mode_suites[] = {
15065 &scheduler_multicore,
15066 &scheduler_round_robin,
15067 &scheduler_failover,
15068 &scheduler_pkt_size_distr
15070 static struct unit_test_suite scheduler_config = {
15071 .suite_name = "Crypto Device Scheduler Config Unit Test Suite",
15072 .unit_test_cases = {
15073 TEST_CASE(test_scheduler_attach_worker_op),
15074 TEST_CASE(test_scheduler_mode_multicore_op),
15075 TEST_CASE(test_scheduler_mode_roundrobin_op),
15076 TEST_CASE(test_scheduler_mode_failover_op),
15077 TEST_CASE(test_scheduler_mode_pkt_size_distr_op),
15078 TEST_CASE(test_scheduler_detach_worker_op),
15080 TEST_CASES_END() /**< NULL terminate array */
15083 struct unit_test_suite *static_suites[] = {
15087 static struct unit_test_suite ts = {
15088 .suite_name = "Scheduler Unit Test Suite",
15089 .setup = scheduler_testsuite_setup,
15090 .teardown = testsuite_teardown,
15091 .unit_test_cases = {TEST_CASES_END()}
15094 gbl_driver_id = rte_cryptodev_driver_id_get(
15095 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
15097 if (gbl_driver_id == -1) {
15098 RTE_LOG(ERR, USER1, "SCHEDULER PMD must be loaded.\n");
15099 return TEST_SKIPPED;
15102 if (rte_cryptodev_driver_id_get(
15103 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) == -1) {
15104 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded.\n");
15105 return TEST_SKIPPED;
15108 for (sched_i = 0; sched_i < RTE_DIM(sched_mode_suites); sched_i++) {
15110 sched_mode_suites[sched_i]->unit_test_suites = malloc(sizeof
15111 (struct unit_test_suite *) *
15112 (RTE_DIM(blk_suites) + 1));
15113 ADD_BLOCKCIPHER_TESTSUITE(blk_i, (*sched_mode_suites[sched_i]),
15114 blk_suites, RTE_DIM(blk_suites));
15115 sched_mode_suites[sched_i]->unit_test_suites[blk_i] = &end_testsuite;
15118 ts.unit_test_suites = malloc(sizeof(struct unit_test_suite *) *
15119 (RTE_DIM(static_suites) + RTE_DIM(sched_mode_suites)));
15120 ADD_STATIC_TESTSUITE(i, ts, sched_mode_suites,
15121 RTE_DIM(sched_mode_suites));
15122 ADD_STATIC_TESTSUITE(i, ts, static_suites, RTE_DIM(static_suites));
15123 ret = unit_test_suite_runner(&ts);
15125 for (sched_i = 0; sched_i < RTE_DIM(sched_mode_suites); sched_i++) {
15126 FREE_BLOCKCIPHER_TESTSUITE(blk_start_idx,
15127 (*sched_mode_suites[sched_i]),
15128 RTE_DIM(blk_suites));
15129 free(sched_mode_suites[sched_i]->unit_test_suites);
15131 free(ts.unit_test_suites);
15135 REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler);
15140 test_cryptodev_dpaa2_sec(void)
15142 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
15146 test_cryptodev_dpaa_sec(void)
15148 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD));
15152 test_cryptodev_ccp(void)
15154 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CCP_PMD));
15158 test_cryptodev_octeontx(void)
15160 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD));
15164 test_cryptodev_octeontx2(void)
15166 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OCTEONTX2_PMD));
15170 test_cryptodev_caam_jr(void)
15172 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD));
15176 test_cryptodev_nitrox(void)
15178 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_NITROX_PMD));
15182 test_cryptodev_bcmfs(void)
15184 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_BCMFS_PMD));
15188 test_cryptodev_qat_raw_api(void)
15190 static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD);
15193 ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
15198 global_api_test_type = CRYPTODEV_RAW_API_TEST;
15199 ret = run_cryptodev_testsuite(pmd_name);
15200 global_api_test_type = CRYPTODEV_API_TEST;
15206 test_cryptodev_cn9k(void)
15208 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CN9K_PMD));
15212 test_cryptodev_cn10k(void)
15214 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CN10K_PMD));
15217 REGISTER_TEST_COMMAND(cryptodev_qat_raw_api_autotest,
15218 test_cryptodev_qat_raw_api);
15219 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
15220 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
15221 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_mb_autotest,
15222 test_cryptodev_cpu_aesni_mb);
15223 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl);
15224 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm);
15225 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_gcm_autotest,
15226 test_cryptodev_cpu_aesni_gcm);
15227 REGISTER_TEST_COMMAND(cryptodev_mlx5_autotest, test_cryptodev_mlx5);
15228 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null);
15229 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
15230 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);
15231 REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc);
15232 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_autotest, test_cryptodev_armv8);
15233 REGISTER_TEST_COMMAND(cryptodev_sw_mvsam_autotest, test_cryptodev_mrvl);
15234 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_autotest, test_cryptodev_dpaa2_sec);
15235 REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_autotest, test_cryptodev_dpaa_sec);
15236 REGISTER_TEST_COMMAND(cryptodev_ccp_autotest, test_cryptodev_ccp);
15237 REGISTER_TEST_COMMAND(cryptodev_virtio_autotest, test_cryptodev_virtio);
15238 REGISTER_TEST_COMMAND(cryptodev_octeontx_autotest, test_cryptodev_octeontx);
15239 REGISTER_TEST_COMMAND(cryptodev_octeontx2_autotest, test_cryptodev_octeontx2);
15240 REGISTER_TEST_COMMAND(cryptodev_caam_jr_autotest, test_cryptodev_caam_jr);
15241 REGISTER_TEST_COMMAND(cryptodev_nitrox_autotest, test_cryptodev_nitrox);
15242 REGISTER_TEST_COMMAND(cryptodev_bcmfs_autotest, test_cryptodev_bcmfs);
15243 REGISTER_TEST_COMMAND(cryptodev_cn9k_autotest, test_cryptodev_cn9k);
15244 REGISTER_TEST_COMMAND(cryptodev_cn10k_autotest, test_cryptodev_cn10k);