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>
24 #ifdef RTE_CRYPTO_SCHEDULER
25 #include <rte_cryptodev_scheduler.h>
26 #include <rte_cryptodev_scheduler_operations.h>
29 #include <rte_lcore.h>
32 #include "test_cryptodev.h"
34 #include "test_cryptodev_blockcipher.h"
35 #include "test_cryptodev_aes_test_vectors.h"
36 #include "test_cryptodev_des_test_vectors.h"
37 #include "test_cryptodev_hash_test_vectors.h"
38 #include "test_cryptodev_kasumi_test_vectors.h"
39 #include "test_cryptodev_kasumi_hash_test_vectors.h"
40 #include "test_cryptodev_snow3g_test_vectors.h"
41 #include "test_cryptodev_snow3g_hash_test_vectors.h"
42 #include "test_cryptodev_zuc_test_vectors.h"
43 #include "test_cryptodev_aead_test_vectors.h"
44 #include "test_cryptodev_hmac_test_vectors.h"
45 #include "test_cryptodev_mixed_test_vectors.h"
46 #ifdef RTE_LIB_SECURITY
47 #include "test_cryptodev_security_ipsec.h"
48 #include "test_cryptodev_security_ipsec_test_vectors.h"
49 #include "test_cryptodev_security_pdcp_test_vectors.h"
50 #include "test_cryptodev_security_pdcp_sdap_test_vectors.h"
51 #include "test_cryptodev_security_pdcp_test_func.h"
52 #include "test_cryptodev_security_docsis_test_vectors.h"
54 #define SDAP_DISABLED 0
55 #define SDAP_ENABLED 1
58 #define VDEV_ARGS_SIZE 100
59 #define MAX_NB_SESSIONS 4
61 #define MAX_DRV_SERVICE_CTX_SIZE 256
63 #define MAX_RAW_DEQUEUE_COUNT 65535
66 #define OUT_OF_PLACE 1
68 static int gbl_driver_id;
70 static enum rte_security_session_action_type gbl_action_type =
71 RTE_SECURITY_ACTION_TYPE_NONE;
73 enum cryptodev_api_test_type global_api_test_type = CRYPTODEV_API_TEST;
75 struct crypto_unittest_params {
76 struct rte_crypto_sym_xform cipher_xform;
77 struct rte_crypto_sym_xform auth_xform;
78 struct rte_crypto_sym_xform aead_xform;
79 #ifdef RTE_LIB_SECURITY
80 struct rte_security_docsis_xform docsis_xform;
84 struct rte_cryptodev_sym_session *sess;
85 #ifdef RTE_LIB_SECURITY
86 struct rte_security_session *sec_session;
89 #ifdef RTE_LIB_SECURITY
90 enum rte_security_session_action_type type;
92 struct rte_crypto_op *op;
94 struct rte_mbuf *obuf, *ibuf;
99 #define ALIGN_POW2_ROUNDUP(num, align) \
100 (((num) + (align) - 1) & ~((align) - 1))
102 #define ADD_STATIC_TESTSUITE(index, parent_ts, child_ts, num_child_ts) \
103 for (j = 0; j < num_child_ts; index++, j++) \
104 parent_ts.unit_test_suites[index] = child_ts[j]
106 #define ADD_BLOCKCIPHER_TESTSUITE(index, parent_ts, blk_types, num_blk_types) \
107 for (j = 0; j < num_blk_types; index++, j++) \
108 parent_ts.unit_test_suites[index] = \
109 build_blockcipher_test_suite(blk_types[j])
111 #define FREE_BLOCKCIPHER_TESTSUITE(index, parent_ts, num_blk_types) \
112 for (j = index; j < index + num_blk_types; j++) \
113 free_blockcipher_test_suite(parent_ts.unit_test_suites[j])
116 * Forward declarations.
119 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
120 struct crypto_unittest_params *ut_params, uint8_t *cipher_key,
124 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
125 struct crypto_unittest_params *ut_params,
126 struct crypto_testsuite_params *ts_param,
127 const uint8_t *cipher,
128 const uint8_t *digest,
132 security_proto_supported(enum rte_security_session_action_type action,
133 enum rte_security_session_protocol proto);
136 dev_configure_and_start(uint64_t ff_disable);
138 static struct rte_mbuf *
139 setup_test_string(struct rte_mempool *mpool,
140 const char *string, size_t len, uint8_t blocksize)
142 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
143 size_t t_len = len - (blocksize ? (len % blocksize) : 0);
148 memset(m->buf_addr, 0, m->buf_len);
149 dst = rte_pktmbuf_append(m, t_len);
155 rte_memcpy(dst, string, t_len);
157 memset(dst, 0, t_len);
163 /* Get number of bytes in X bits (rounding up) */
165 ceil_byte_length(uint32_t num_bits)
168 return ((num_bits >> 3) + 1);
170 return (num_bits >> 3);
174 post_process_raw_dp_op(void *user_data, uint32_t index __rte_unused,
175 uint8_t is_op_success)
177 struct rte_crypto_op *op = user_data;
178 op->status = is_op_success ? RTE_CRYPTO_OP_STATUS_SUCCESS :
179 RTE_CRYPTO_OP_STATUS_ERROR;
182 static struct crypto_testsuite_params testsuite_params = { NULL };
183 struct crypto_testsuite_params *p_testsuite_params = &testsuite_params;
184 static struct crypto_unittest_params unittest_params;
187 process_sym_raw_dp_op(uint8_t dev_id, uint16_t qp_id,
188 struct rte_crypto_op *op, uint8_t is_cipher, uint8_t is_auth,
189 uint8_t len_in_bits, uint8_t cipher_iv_len)
191 struct rte_crypto_sym_op *sop = op->sym;
192 struct rte_crypto_op *ret_op = NULL;
193 struct rte_crypto_vec data_vec[UINT8_MAX], dest_data_vec[UINT8_MAX];
194 struct rte_crypto_va_iova_ptr cipher_iv, digest, aad_auth_iv;
195 union rte_crypto_sym_ofs ofs;
196 struct rte_crypto_sym_vec vec;
197 struct rte_crypto_sgl sgl, dest_sgl;
199 union rte_cryptodev_session_ctx sess;
200 uint64_t auth_end_iova;
202 struct rte_crypto_raw_dp_ctx *ctx;
203 uint32_t cipher_offset = 0, cipher_len = 0, auth_offset = 0,
207 int ctx_service_size;
209 int enqueue_status, dequeue_status;
210 struct crypto_unittest_params *ut_params = &unittest_params;
211 int is_sgl = sop->m_src->nb_segs > 1;
213 ctx_service_size = rte_cryptodev_get_raw_dp_ctx_size(dev_id);
214 if (ctx_service_size < 0) {
215 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
219 ctx = malloc(ctx_service_size);
221 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
225 /* Both are enums, setting crypto_sess will suit any session type */
226 sess.crypto_sess = op->sym->session;
228 if (rte_cryptodev_configure_raw_dp_ctx(dev_id, qp_id, ctx,
229 op->sess_type, sess, 0) < 0) {
230 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
236 aad_auth_iv.iova = 0;
237 aad_auth_iv.va = NULL;
244 vec.digest = &digest;
245 vec.aad = &aad_auth_iv;
246 vec.status = &status;
250 if (is_cipher && is_auth) {
251 cipher_offset = sop->cipher.data.offset;
252 cipher_len = sop->cipher.data.length;
253 auth_offset = sop->auth.data.offset;
254 auth_len = sop->auth.data.length;
255 max_len = RTE_MAX(cipher_offset + cipher_len,
256 auth_offset + auth_len);
258 max_len = max_len >> 3;
259 cipher_offset = cipher_offset >> 3;
260 auth_offset = auth_offset >> 3;
261 cipher_len = cipher_len >> 3;
262 auth_len = auth_len >> 3;
264 ofs.ofs.cipher.head = cipher_offset;
265 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
266 ofs.ofs.auth.head = auth_offset;
267 ofs.ofs.auth.tail = max_len - auth_offset - auth_len;
268 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
269 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
270 aad_auth_iv.va = rte_crypto_op_ctod_offset(
271 op, void *, IV_OFFSET + cipher_iv_len);
272 aad_auth_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET +
274 digest.va = (void *)sop->auth.digest.data;
275 digest.iova = sop->auth.digest.phys_addr;
278 uint32_t remaining_off = auth_offset + auth_len;
279 struct rte_mbuf *sgl_buf = sop->m_src;
281 while (remaining_off >= rte_pktmbuf_data_len(sgl_buf)
282 && sgl_buf->next != NULL) {
283 remaining_off -= rte_pktmbuf_data_len(sgl_buf);
284 sgl_buf = sgl_buf->next;
287 auth_end_iova = (uint64_t)rte_pktmbuf_iova_offset(
288 sgl_buf, remaining_off);
290 auth_end_iova = rte_pktmbuf_iova(op->sym->m_src) +
291 auth_offset + auth_len;
293 /* Then check if digest-encrypted conditions are met */
294 if ((auth_offset + auth_len < cipher_offset + cipher_len) &&
295 (digest.iova == auth_end_iova) && is_sgl)
296 max_len = RTE_MAX(max_len, auth_offset + auth_len +
297 ut_params->auth_xform.auth.digest_length);
299 } else if (is_cipher) {
300 cipher_offset = sop->cipher.data.offset;
301 cipher_len = sop->cipher.data.length;
302 max_len = cipher_len + cipher_offset;
304 max_len = max_len >> 3;
305 cipher_offset = cipher_offset >> 3;
306 cipher_len = cipher_len >> 3;
308 ofs.ofs.cipher.head = cipher_offset;
309 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
310 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
311 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
313 } else if (is_auth) {
314 auth_offset = sop->auth.data.offset;
315 auth_len = sop->auth.data.length;
316 max_len = auth_len + auth_offset;
318 max_len = max_len >> 3;
319 auth_offset = auth_offset >> 3;
320 auth_len = auth_len >> 3;
322 ofs.ofs.auth.head = auth_offset;
323 ofs.ofs.auth.tail = max_len - auth_offset - auth_len;
324 aad_auth_iv.va = rte_crypto_op_ctod_offset(
325 op, void *, IV_OFFSET + cipher_iv_len);
326 aad_auth_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET +
328 digest.va = (void *)sop->auth.digest.data;
329 digest.iova = sop->auth.digest.phys_addr;
332 cipher_offset = sop->aead.data.offset;
333 cipher_len = sop->aead.data.length;
334 max_len = cipher_len + cipher_offset;
336 max_len = max_len >> 3;
337 cipher_offset = cipher_offset >> 3;
338 cipher_len = cipher_len >> 3;
340 ofs.ofs.cipher.head = cipher_offset;
341 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
342 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
343 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
344 aad_auth_iv.va = (void *)sop->aead.aad.data;
345 aad_auth_iv.iova = sop->aead.aad.phys_addr;
346 digest.va = (void *)sop->aead.digest.data;
347 digest.iova = sop->aead.digest.phys_addr;
350 n = rte_crypto_mbuf_to_vec(sop->m_src, 0, max_len,
351 data_vec, RTE_DIM(data_vec));
352 if (n < 0 || n > sop->m_src->nb_segs) {
353 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
359 if (sop->m_dst != NULL) {
360 dest_sgl.vec = dest_data_vec;
361 vec.dest_sgl = &dest_sgl;
362 n = rte_crypto_mbuf_to_vec(sop->m_dst, 0, max_len,
363 dest_data_vec, RTE_DIM(dest_data_vec));
364 if (n < 0 || n > sop->m_dst->nb_segs) {
365 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
372 if (rte_cryptodev_raw_enqueue_burst(ctx, &vec, ofs, (void **)&op,
373 &enqueue_status) < 1) {
374 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
378 if (enqueue_status == 0) {
379 status = rte_cryptodev_raw_enqueue_done(ctx, 1);
381 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
384 } else if (enqueue_status < 0) {
385 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
390 while (count++ < MAX_RAW_DEQUEUE_COUNT && n == 0) {
391 n = rte_cryptodev_raw_dequeue_burst(ctx,
392 NULL, 1, post_process_raw_dp_op,
393 (void **)&ret_op, 0, &n_success,
395 if (dequeue_status < 0) {
396 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
403 if (n == 1 && dequeue_status == 0) {
404 if (rte_cryptodev_raw_dequeue_done(ctx, 1) < 0) {
405 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
410 op->status = (count == MAX_RAW_DEQUEUE_COUNT + 1 || ret_op != op ||
411 ret_op->status == RTE_CRYPTO_OP_STATUS_ERROR ||
412 n_success < 1) ? RTE_CRYPTO_OP_STATUS_ERROR :
413 RTE_CRYPTO_OP_STATUS_SUCCESS;
420 process_cpu_aead_op(uint8_t dev_id, struct rte_crypto_op *op)
423 struct rte_crypto_sym_op *sop;
424 union rte_crypto_sym_ofs ofs;
425 struct rte_crypto_sgl sgl;
426 struct rte_crypto_sym_vec symvec;
427 struct rte_crypto_va_iova_ptr iv_ptr, aad_ptr, digest_ptr;
428 struct rte_crypto_vec vec[UINT8_MAX];
432 n = rte_crypto_mbuf_to_vec(sop->m_src, sop->aead.data.offset,
433 sop->aead.data.length, vec, RTE_DIM(vec));
435 if (n < 0 || n != sop->m_src->nb_segs) {
436 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
442 symvec.src_sgl = &sgl;
444 symvec.digest = &digest_ptr;
445 symvec.aad = &aad_ptr;
449 /* for CPU crypto the IOVA address is not required */
450 iv_ptr.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
451 digest_ptr.va = (void *)sop->aead.digest.data;
452 aad_ptr.va = (void *)sop->aead.aad.data;
456 n = rte_cryptodev_sym_cpu_crypto_process(dev_id, sop->session, ofs,
460 op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
462 op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
466 process_cpu_crypt_auth_op(uint8_t dev_id, struct rte_crypto_op *op)
469 struct rte_crypto_sym_op *sop;
470 union rte_crypto_sym_ofs ofs;
471 struct rte_crypto_sgl sgl;
472 struct rte_crypto_sym_vec symvec;
473 struct rte_crypto_va_iova_ptr iv_ptr, digest_ptr;
474 struct rte_crypto_vec vec[UINT8_MAX];
478 n = rte_crypto_mbuf_to_vec(sop->m_src, sop->auth.data.offset,
479 sop->auth.data.length, vec, RTE_DIM(vec));
481 if (n < 0 || n != sop->m_src->nb_segs) {
482 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
488 symvec.src_sgl = &sgl;
490 symvec.digest = &digest_ptr;
494 iv_ptr.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
495 digest_ptr.va = (void *)sop->auth.digest.data;
498 ofs.ofs.cipher.head = sop->cipher.data.offset - sop->auth.data.offset;
499 ofs.ofs.cipher.tail = (sop->auth.data.offset + sop->auth.data.length) -
500 (sop->cipher.data.offset + sop->cipher.data.length);
502 n = rte_cryptodev_sym_cpu_crypto_process(dev_id, sop->session, ofs,
506 op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
508 op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
511 static struct rte_crypto_op *
512 process_crypto_request(uint8_t dev_id, struct rte_crypto_op *op)
515 RTE_VERIFY(gbl_action_type != RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO);
517 if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
518 RTE_LOG(ERR, USER1, "Error sending packet for encryption\n");
524 while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0)
527 if (op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
528 RTE_LOG(DEBUG, USER1, "Operation status %d\n", op->status);
536 testsuite_setup(void)
538 struct crypto_testsuite_params *ts_params = &testsuite_params;
539 struct rte_cryptodev_info info;
540 uint32_t i = 0, nb_devs, dev_id;
543 memset(ts_params, 0, sizeof(*ts_params));
545 ts_params->mbuf_pool = rte_mempool_lookup("CRYPTO_MBUFPOOL");
546 if (ts_params->mbuf_pool == NULL) {
547 /* Not already created so create */
548 ts_params->mbuf_pool = rte_pktmbuf_pool_create(
550 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
552 if (ts_params->mbuf_pool == NULL) {
553 RTE_LOG(ERR, USER1, "Can't create CRYPTO_MBUFPOOL\n");
558 ts_params->large_mbuf_pool = rte_mempool_lookup(
559 "CRYPTO_LARGE_MBUFPOOL");
560 if (ts_params->large_mbuf_pool == NULL) {
561 /* Not already created so create */
562 ts_params->large_mbuf_pool = rte_pktmbuf_pool_create(
563 "CRYPTO_LARGE_MBUFPOOL",
566 if (ts_params->large_mbuf_pool == NULL) {
568 "Can't create CRYPTO_LARGE_MBUFPOOL\n");
573 ts_params->op_mpool = rte_crypto_op_pool_create(
574 "MBUF_CRYPTO_SYM_OP_POOL",
575 RTE_CRYPTO_OP_TYPE_SYMMETRIC,
576 NUM_MBUFS, MBUF_CACHE_SIZE,
578 sizeof(struct rte_crypto_sym_xform) +
581 if (ts_params->op_mpool == NULL) {
582 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
586 nb_devs = rte_cryptodev_count();
588 RTE_LOG(WARNING, USER1, "No crypto devices found?\n");
592 if (rte_cryptodev_device_count_by_driver(gbl_driver_id) < 1) {
593 RTE_LOG(WARNING, USER1, "No %s devices found?\n",
594 rte_cryptodev_driver_name_get(gbl_driver_id));
598 /* Create list of valid crypto devs */
599 for (i = 0; i < nb_devs; i++) {
600 rte_cryptodev_info_get(i, &info);
601 if (info.driver_id == gbl_driver_id)
602 ts_params->valid_devs[ts_params->valid_dev_count++] = i;
605 if (ts_params->valid_dev_count < 1)
608 /* Set up all the qps on the first of the valid devices found */
610 dev_id = ts_params->valid_devs[0];
612 rte_cryptodev_info_get(dev_id, &info);
614 ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
615 ts_params->conf.socket_id = SOCKET_ID_ANY;
616 ts_params->conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY;
618 unsigned int session_size =
619 rte_cryptodev_sym_get_private_session_size(dev_id);
621 #ifdef RTE_LIB_SECURITY
622 unsigned int security_session_size = rte_security_session_get_size(
623 rte_cryptodev_get_sec_ctx(dev_id));
625 if (session_size < security_session_size)
626 session_size = security_session_size;
629 * Create mempool with maximum number of sessions.
631 if (info.sym.max_nb_sessions != 0 &&
632 info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
633 RTE_LOG(ERR, USER1, "Device does not support "
634 "at least %u sessions\n",
639 ts_params->session_mpool = rte_cryptodev_sym_session_pool_create(
640 "test_sess_mp", MAX_NB_SESSIONS, 0, 0, 0,
642 TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
643 "session mempool allocation failed");
645 ts_params->session_priv_mpool = rte_mempool_create(
649 0, 0, NULL, NULL, NULL,
652 TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
653 "session mempool allocation failed");
657 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id,
659 "Failed to configure cryptodev %u with %u qps",
660 dev_id, ts_params->conf.nb_queue_pairs);
662 ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
663 ts_params->qp_conf.mp_session = ts_params->session_mpool;
664 ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
666 for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) {
667 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
668 dev_id, qp_id, &ts_params->qp_conf,
669 rte_cryptodev_socket_id(dev_id)),
670 "Failed to setup queue pair %u on cryptodev %u",
678 testsuite_teardown(void)
680 struct crypto_testsuite_params *ts_params = &testsuite_params;
683 if (ts_params->mbuf_pool != NULL) {
684 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
685 rte_mempool_avail_count(ts_params->mbuf_pool));
688 if (ts_params->op_mpool != NULL) {
689 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n",
690 rte_mempool_avail_count(ts_params->op_mpool));
693 /* Free session mempools */
694 if (ts_params->session_priv_mpool != NULL) {
695 rte_mempool_free(ts_params->session_priv_mpool);
696 ts_params->session_priv_mpool = NULL;
699 if (ts_params->session_mpool != NULL) {
700 rte_mempool_free(ts_params->session_mpool);
701 ts_params->session_mpool = NULL;
704 res = rte_cryptodev_close(ts_params->valid_devs[0]);
706 RTE_LOG(ERR, USER1, "Crypto device close error %d\n", res);
710 check_capabilities_supported(enum rte_crypto_sym_xform_type type,
711 const int *algs, uint16_t num_algs)
713 uint8_t dev_id = testsuite_params.valid_devs[0];
714 bool some_alg_supported = FALSE;
717 for (i = 0; i < num_algs && !some_alg_supported; i++) {
718 struct rte_cryptodev_sym_capability_idx alg = {
721 if (rte_cryptodev_sym_capability_get(dev_id,
723 some_alg_supported = TRUE;
725 if (!some_alg_supported)
732 check_cipher_capabilities_supported(const enum rte_crypto_cipher_algorithm *ciphers,
733 uint16_t num_ciphers)
735 return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_CIPHER,
736 (const int *) ciphers, num_ciphers);
740 check_auth_capabilities_supported(const enum rte_crypto_auth_algorithm *auths,
743 return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_AUTH,
744 (const int *) auths, num_auths);
748 check_aead_capabilities_supported(const enum rte_crypto_aead_algorithm *aeads,
751 return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_AEAD,
752 (const int *) aeads, num_aeads);
756 null_testsuite_setup(void)
758 struct crypto_testsuite_params *ts_params = &testsuite_params;
759 uint8_t dev_id = ts_params->valid_devs[0];
760 struct rte_cryptodev_info dev_info;
761 const enum rte_crypto_cipher_algorithm ciphers[] = {
762 RTE_CRYPTO_CIPHER_NULL
764 const enum rte_crypto_auth_algorithm auths[] = {
768 rte_cryptodev_info_get(dev_id, &dev_info);
770 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
771 RTE_LOG(INFO, USER1, "Feature flag requirements for NULL "
772 "testsuite not met\n");
776 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
777 && check_auth_capabilities_supported(auths,
778 RTE_DIM(auths)) != 0) {
779 RTE_LOG(INFO, USER1, "Capability requirements for NULL "
780 "testsuite not met\n");
788 crypto_gen_testsuite_setup(void)
790 struct crypto_testsuite_params *ts_params = &testsuite_params;
791 uint8_t dev_id = ts_params->valid_devs[0];
792 struct rte_cryptodev_info dev_info;
794 rte_cryptodev_info_get(dev_id, &dev_info);
796 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
797 RTE_LOG(INFO, USER1, "Feature flag requirements for Crypto Gen "
798 "testsuite not met\n");
805 #ifdef RTE_LIB_SECURITY
807 ipsec_proto_testsuite_setup(void)
809 struct crypto_testsuite_params *ts_params = &testsuite_params;
810 struct crypto_unittest_params *ut_params = &unittest_params;
811 struct rte_cryptodev_info dev_info;
814 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
816 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SECURITY)) {
817 RTE_LOG(INFO, USER1, "Feature flag requirements for IPsec Proto "
818 "testsuite not met\n");
822 /* Reconfigure to enable security */
823 ret = dev_configure_and_start(0);
824 if (ret != TEST_SUCCESS)
827 /* Set action type */
828 ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
830 if (security_proto_supported(
831 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
832 RTE_SECURITY_PROTOCOL_IPSEC) < 0) {
833 RTE_LOG(INFO, USER1, "Capability requirements for IPsec Proto "
838 test_ipsec_alg_list_populate();
841 * Stop the device. Device would be started again by individual test
842 * case setup routine.
844 rte_cryptodev_stop(ts_params->valid_devs[0]);
850 pdcp_proto_testsuite_setup(void)
852 struct crypto_testsuite_params *ts_params = &testsuite_params;
853 uint8_t dev_id = ts_params->valid_devs[0];
854 struct rte_cryptodev_info dev_info;
855 const enum rte_crypto_cipher_algorithm ciphers[] = {
856 RTE_CRYPTO_CIPHER_NULL,
857 RTE_CRYPTO_CIPHER_AES_CTR,
858 RTE_CRYPTO_CIPHER_ZUC_EEA3,
859 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
861 const enum rte_crypto_auth_algorithm auths[] = {
862 RTE_CRYPTO_AUTH_NULL,
863 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
864 RTE_CRYPTO_AUTH_AES_CMAC,
865 RTE_CRYPTO_AUTH_ZUC_EIA3
868 rte_cryptodev_info_get(dev_id, &dev_info);
870 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
871 !(dev_info.feature_flags &
872 RTE_CRYPTODEV_FF_SECURITY)) {
873 RTE_LOG(INFO, USER1, "Feature flag requirements for PDCP Proto "
874 "testsuite not met\n");
878 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
879 && check_auth_capabilities_supported(auths,
880 RTE_DIM(auths)) != 0) {
881 RTE_LOG(INFO, USER1, "Capability requirements for PDCP Proto "
882 "testsuite not met\n");
890 docsis_proto_testsuite_setup(void)
892 struct crypto_testsuite_params *ts_params = &testsuite_params;
893 uint8_t dev_id = ts_params->valid_devs[0];
894 struct rte_cryptodev_info dev_info;
895 const enum rte_crypto_cipher_algorithm ciphers[] = {
896 RTE_CRYPTO_CIPHER_AES_DOCSISBPI
899 rte_cryptodev_info_get(dev_id, &dev_info);
901 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
902 !(dev_info.feature_flags &
903 RTE_CRYPTODEV_FF_SECURITY)) {
904 RTE_LOG(INFO, USER1, "Feature flag requirements for DOCSIS "
905 "Proto testsuite not met\n");
909 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0) {
910 RTE_LOG(INFO, USER1, "Capability requirements for DOCSIS Proto "
911 "testsuite not met\n");
920 aes_ccm_auth_testsuite_setup(void)
922 struct crypto_testsuite_params *ts_params = &testsuite_params;
923 uint8_t dev_id = ts_params->valid_devs[0];
924 struct rte_cryptodev_info dev_info;
925 const enum rte_crypto_aead_algorithm aeads[] = {
926 RTE_CRYPTO_AEAD_AES_CCM
929 rte_cryptodev_info_get(dev_id, &dev_info);
931 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
932 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
933 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
934 RTE_LOG(INFO, USER1, "Feature flag requirements for AES CCM "
935 "testsuite not met\n");
939 if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
940 RTE_LOG(INFO, USER1, "Capability requirements for AES CCM "
941 "testsuite not met\n");
949 aes_gcm_auth_testsuite_setup(void)
951 struct crypto_testsuite_params *ts_params = &testsuite_params;
952 uint8_t dev_id = ts_params->valid_devs[0];
953 struct rte_cryptodev_info dev_info;
954 const enum rte_crypto_aead_algorithm aeads[] = {
955 RTE_CRYPTO_AEAD_AES_GCM
958 rte_cryptodev_info_get(dev_id, &dev_info);
960 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
961 RTE_LOG(INFO, USER1, "Feature flag requirements for AES GCM "
962 "testsuite not met\n");
966 if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
967 RTE_LOG(INFO, USER1, "Capability requirements for AES GCM "
968 "testsuite not met\n");
976 aes_gmac_auth_testsuite_setup(void)
978 struct crypto_testsuite_params *ts_params = &testsuite_params;
979 uint8_t dev_id = ts_params->valid_devs[0];
980 struct rte_cryptodev_info dev_info;
981 const enum rte_crypto_auth_algorithm auths[] = {
982 RTE_CRYPTO_AUTH_AES_GMAC
985 rte_cryptodev_info_get(dev_id, &dev_info);
987 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
988 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
989 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
990 RTE_LOG(INFO, USER1, "Feature flag requirements for AES GMAC "
991 "testsuite not met\n");
995 if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
996 RTE_LOG(INFO, USER1, "Capability requirements for AES GMAC "
997 "testsuite not met\n");
1005 chacha20_poly1305_testsuite_setup(void)
1007 struct crypto_testsuite_params *ts_params = &testsuite_params;
1008 uint8_t dev_id = ts_params->valid_devs[0];
1009 struct rte_cryptodev_info dev_info;
1010 const enum rte_crypto_aead_algorithm aeads[] = {
1011 RTE_CRYPTO_AEAD_CHACHA20_POLY1305
1014 rte_cryptodev_info_get(dev_id, &dev_info);
1016 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1017 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1018 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1019 RTE_LOG(INFO, USER1, "Feature flag requirements for "
1020 "Chacha20-Poly1305 testsuite not met\n");
1021 return TEST_SKIPPED;
1024 if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
1025 RTE_LOG(INFO, USER1, "Capability requirements for "
1026 "Chacha20-Poly1305 testsuite not met\n");
1027 return TEST_SKIPPED;
1034 snow3g_testsuite_setup(void)
1036 struct crypto_testsuite_params *ts_params = &testsuite_params;
1037 uint8_t dev_id = ts_params->valid_devs[0];
1038 struct rte_cryptodev_info dev_info;
1039 const enum rte_crypto_cipher_algorithm ciphers[] = {
1040 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
1043 const enum rte_crypto_auth_algorithm auths[] = {
1044 RTE_CRYPTO_AUTH_SNOW3G_UIA2
1047 rte_cryptodev_info_get(dev_id, &dev_info);
1049 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1050 RTE_LOG(INFO, USER1, "Feature flag requirements for Snow3G "
1051 "testsuite not met\n");
1052 return TEST_SKIPPED;
1055 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1056 && check_auth_capabilities_supported(auths,
1057 RTE_DIM(auths)) != 0) {
1058 RTE_LOG(INFO, USER1, "Capability requirements for Snow3G "
1059 "testsuite not met\n");
1060 return TEST_SKIPPED;
1067 zuc_testsuite_setup(void)
1069 struct crypto_testsuite_params *ts_params = &testsuite_params;
1070 uint8_t dev_id = ts_params->valid_devs[0];
1071 struct rte_cryptodev_info dev_info;
1072 const enum rte_crypto_cipher_algorithm ciphers[] = {
1073 RTE_CRYPTO_CIPHER_ZUC_EEA3
1075 const enum rte_crypto_auth_algorithm auths[] = {
1076 RTE_CRYPTO_AUTH_ZUC_EIA3
1079 rte_cryptodev_info_get(dev_id, &dev_info);
1081 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1082 RTE_LOG(INFO, USER1, "Feature flag requirements for ZUC "
1083 "testsuite not met\n");
1084 return TEST_SKIPPED;
1087 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1088 && check_auth_capabilities_supported(auths,
1089 RTE_DIM(auths)) != 0) {
1090 RTE_LOG(INFO, USER1, "Capability requirements for ZUC "
1091 "testsuite not met\n");
1092 return TEST_SKIPPED;
1099 hmac_md5_auth_testsuite_setup(void)
1101 struct crypto_testsuite_params *ts_params = &testsuite_params;
1102 uint8_t dev_id = ts_params->valid_devs[0];
1103 struct rte_cryptodev_info dev_info;
1104 const enum rte_crypto_auth_algorithm auths[] = {
1105 RTE_CRYPTO_AUTH_MD5_HMAC
1108 rte_cryptodev_info_get(dev_id, &dev_info);
1110 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1111 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1112 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1113 RTE_LOG(INFO, USER1, "Feature flag requirements for HMAC MD5 "
1114 "Auth testsuite not met\n");
1115 return TEST_SKIPPED;
1118 if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
1119 RTE_LOG(INFO, USER1, "Capability requirements for HMAC MD5 "
1120 "testsuite not met\n");
1121 return TEST_SKIPPED;
1128 kasumi_testsuite_setup(void)
1130 struct crypto_testsuite_params *ts_params = &testsuite_params;
1131 uint8_t dev_id = ts_params->valid_devs[0];
1132 struct rte_cryptodev_info dev_info;
1133 const enum rte_crypto_cipher_algorithm ciphers[] = {
1134 RTE_CRYPTO_CIPHER_KASUMI_F8
1136 const enum rte_crypto_auth_algorithm auths[] = {
1137 RTE_CRYPTO_AUTH_KASUMI_F9
1140 rte_cryptodev_info_get(dev_id, &dev_info);
1142 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1143 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1144 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1145 RTE_LOG(INFO, USER1, "Feature flag requirements for Kasumi "
1146 "testsuite not met\n");
1147 return TEST_SKIPPED;
1150 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1151 && check_auth_capabilities_supported(auths,
1152 RTE_DIM(auths)) != 0) {
1153 RTE_LOG(INFO, USER1, "Capability requirements for Kasumi "
1154 "testsuite not met\n");
1155 return TEST_SKIPPED;
1162 negative_aes_gcm_testsuite_setup(void)
1164 struct crypto_testsuite_params *ts_params = &testsuite_params;
1165 uint8_t dev_id = ts_params->valid_devs[0];
1166 struct rte_cryptodev_info dev_info;
1167 const enum rte_crypto_aead_algorithm aeads[] = {
1168 RTE_CRYPTO_AEAD_AES_GCM
1171 rte_cryptodev_info_get(dev_id, &dev_info);
1173 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1174 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1175 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1176 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1177 "AES GCM testsuite not met\n");
1178 return TEST_SKIPPED;
1181 if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
1182 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1183 "AES GCM testsuite not met\n");
1184 return TEST_SKIPPED;
1191 negative_aes_gmac_testsuite_setup(void)
1193 struct crypto_testsuite_params *ts_params = &testsuite_params;
1194 uint8_t dev_id = ts_params->valid_devs[0];
1195 struct rte_cryptodev_info dev_info;
1196 const enum rte_crypto_auth_algorithm auths[] = {
1197 RTE_CRYPTO_AUTH_AES_GMAC
1200 rte_cryptodev_info_get(dev_id, &dev_info);
1202 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1203 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1204 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1205 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1206 "AES GMAC testsuite not met\n");
1207 return TEST_SKIPPED;
1210 if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
1211 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1212 "AES GMAC testsuite not met\n");
1213 return TEST_SKIPPED;
1220 mixed_cipher_hash_testsuite_setup(void)
1222 struct crypto_testsuite_params *ts_params = &testsuite_params;
1223 uint8_t dev_id = ts_params->valid_devs[0];
1224 struct rte_cryptodev_info dev_info;
1225 uint64_t feat_flags;
1226 const enum rte_crypto_cipher_algorithm ciphers[] = {
1227 RTE_CRYPTO_CIPHER_NULL,
1228 RTE_CRYPTO_CIPHER_AES_CTR,
1229 RTE_CRYPTO_CIPHER_ZUC_EEA3,
1230 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
1232 const enum rte_crypto_auth_algorithm auths[] = {
1233 RTE_CRYPTO_AUTH_NULL,
1234 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
1235 RTE_CRYPTO_AUTH_AES_CMAC,
1236 RTE_CRYPTO_AUTH_ZUC_EIA3
1239 rte_cryptodev_info_get(dev_id, &dev_info);
1240 feat_flags = dev_info.feature_flags;
1242 if (!(feat_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1243 (global_api_test_type == CRYPTODEV_RAW_API_TEST)) {
1244 RTE_LOG(INFO, USER1, "Feature flag requirements for Mixed "
1245 "Cipher Hash testsuite not met\n");
1246 return TEST_SKIPPED;
1249 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1250 && check_auth_capabilities_supported(auths,
1251 RTE_DIM(auths)) != 0) {
1252 RTE_LOG(INFO, USER1, "Capability requirements for Mixed "
1253 "Cipher Hash testsuite not met\n");
1254 return TEST_SKIPPED;
1261 esn_testsuite_setup(void)
1263 struct crypto_testsuite_params *ts_params = &testsuite_params;
1264 uint8_t dev_id = ts_params->valid_devs[0];
1265 struct rte_cryptodev_info dev_info;
1266 const enum rte_crypto_cipher_algorithm ciphers[] = {
1267 RTE_CRYPTO_CIPHER_AES_CBC
1269 const enum rte_crypto_auth_algorithm auths[] = {
1270 RTE_CRYPTO_AUTH_SHA1_HMAC
1273 rte_cryptodev_info_get(dev_id, &dev_info);
1275 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1276 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1277 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1278 RTE_LOG(INFO, USER1, "Feature flag requirements for ESN "
1279 "testsuite not met\n");
1280 return TEST_SKIPPED;
1283 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1284 && check_auth_capabilities_supported(auths,
1285 RTE_DIM(auths)) != 0) {
1286 RTE_LOG(INFO, USER1, "Capability requirements for ESN "
1287 "testsuite not met\n");
1288 return TEST_SKIPPED;
1295 multi_session_testsuite_setup(void)
1297 struct crypto_testsuite_params *ts_params = &testsuite_params;
1298 uint8_t dev_id = ts_params->valid_devs[0];
1299 struct rte_cryptodev_info dev_info;
1300 const enum rte_crypto_cipher_algorithm ciphers[] = {
1301 RTE_CRYPTO_CIPHER_AES_CBC
1303 const enum rte_crypto_auth_algorithm auths[] = {
1304 RTE_CRYPTO_AUTH_SHA512_HMAC
1307 rte_cryptodev_info_get(dev_id, &dev_info);
1309 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1310 RTE_LOG(INFO, USER1, "Feature flag requirements for Multi "
1311 "Session testsuite not met\n");
1312 return TEST_SKIPPED;
1315 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1316 && check_auth_capabilities_supported(auths,
1317 RTE_DIM(auths)) != 0) {
1318 RTE_LOG(INFO, USER1, "Capability requirements for Multi "
1319 "Session testsuite not met\n");
1320 return TEST_SKIPPED;
1327 negative_hmac_sha1_testsuite_setup(void)
1329 struct crypto_testsuite_params *ts_params = &testsuite_params;
1330 uint8_t dev_id = ts_params->valid_devs[0];
1331 struct rte_cryptodev_info dev_info;
1332 const enum rte_crypto_cipher_algorithm ciphers[] = {
1333 RTE_CRYPTO_CIPHER_AES_CBC
1335 const enum rte_crypto_auth_algorithm auths[] = {
1336 RTE_CRYPTO_AUTH_SHA1_HMAC
1339 rte_cryptodev_info_get(dev_id, &dev_info);
1341 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1342 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1343 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1344 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1345 "HMAC SHA1 testsuite not met\n");
1346 return TEST_SKIPPED;
1349 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1350 && check_auth_capabilities_supported(auths,
1351 RTE_DIM(auths)) != 0) {
1352 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1353 "HMAC SHA1 testsuite not met\n");
1354 return TEST_SKIPPED;
1361 dev_configure_and_start(uint64_t ff_disable)
1363 struct crypto_testsuite_params *ts_params = &testsuite_params;
1364 struct crypto_unittest_params *ut_params = &unittest_params;
1368 /* Clear unit test parameters before running test */
1369 memset(ut_params, 0, sizeof(*ut_params));
1371 /* Reconfigure device to default parameters */
1372 ts_params->conf.socket_id = SOCKET_ID_ANY;
1373 ts_params->conf.ff_disable = ff_disable;
1374 ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
1375 ts_params->qp_conf.mp_session = ts_params->session_mpool;
1376 ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
1378 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1380 "Failed to configure cryptodev %u",
1381 ts_params->valid_devs[0]);
1383 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
1384 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1385 ts_params->valid_devs[0], qp_id,
1386 &ts_params->qp_conf,
1387 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1388 "Failed to setup queue pair %u on cryptodev %u",
1389 qp_id, ts_params->valid_devs[0]);
1393 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
1395 /* Start the device */
1396 TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
1397 "Failed to start cryptodev %u",
1398 ts_params->valid_devs[0]);
1400 return TEST_SUCCESS;
1406 /* Configure and start the device with security feature disabled */
1407 return dev_configure_and_start(RTE_CRYPTODEV_FF_SECURITY);
1411 ut_setup_security(void)
1413 /* Configure and start the device with no features disabled */
1414 return dev_configure_and_start(0);
1420 struct crypto_testsuite_params *ts_params = &testsuite_params;
1421 struct crypto_unittest_params *ut_params = &unittest_params;
1423 /* free crypto session structure */
1424 #ifdef RTE_LIB_SECURITY
1425 if (ut_params->type == RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL) {
1426 if (ut_params->sec_session) {
1427 rte_security_session_destroy(rte_cryptodev_get_sec_ctx
1428 (ts_params->valid_devs[0]),
1429 ut_params->sec_session);
1430 ut_params->sec_session = NULL;
1435 if (ut_params->sess) {
1436 rte_cryptodev_sym_session_clear(
1437 ts_params->valid_devs[0],
1439 rte_cryptodev_sym_session_free(ut_params->sess);
1440 ut_params->sess = NULL;
1444 /* free crypto operation structure */
1446 rte_crypto_op_free(ut_params->op);
1449 * free mbuf - both obuf and ibuf are usually the same,
1450 * so check if they point at the same address is necessary,
1451 * to avoid freeing the mbuf twice.
1453 if (ut_params->obuf) {
1454 rte_pktmbuf_free(ut_params->obuf);
1455 if (ut_params->ibuf == ut_params->obuf)
1456 ut_params->ibuf = 0;
1457 ut_params->obuf = 0;
1459 if (ut_params->ibuf) {
1460 rte_pktmbuf_free(ut_params->ibuf);
1461 ut_params->ibuf = 0;
1464 if (ts_params->mbuf_pool != NULL)
1465 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
1466 rte_mempool_avail_count(ts_params->mbuf_pool));
1468 /* Stop the device */
1469 rte_cryptodev_stop(ts_params->valid_devs[0]);
1473 test_device_configure_invalid_dev_id(void)
1475 struct crypto_testsuite_params *ts_params = &testsuite_params;
1476 uint16_t dev_id, num_devs = 0;
1478 TEST_ASSERT((num_devs = rte_cryptodev_count()) >= 1,
1479 "Need at least %d devices for test", 1);
1481 /* valid dev_id values */
1482 dev_id = ts_params->valid_devs[0];
1484 /* Stop the device in case it's started so it can be configured */
1485 rte_cryptodev_stop(dev_id);
1487 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf),
1488 "Failed test for rte_cryptodev_configure: "
1489 "invalid dev_num %u", dev_id);
1491 /* invalid dev_id values */
1494 TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
1495 "Failed test for rte_cryptodev_configure: "
1496 "invalid dev_num %u", dev_id);
1500 TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
1501 "Failed test for rte_cryptodev_configure:"
1502 "invalid dev_num %u", dev_id);
1504 return TEST_SUCCESS;
1508 test_device_configure_invalid_queue_pair_ids(void)
1510 struct crypto_testsuite_params *ts_params = &testsuite_params;
1511 uint16_t orig_nb_qps = ts_params->conf.nb_queue_pairs;
1513 /* Stop the device in case it's started so it can be configured */
1514 rte_cryptodev_stop(ts_params->valid_devs[0]);
1516 /* valid - max value queue pairs */
1517 ts_params->conf.nb_queue_pairs = orig_nb_qps;
1519 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1521 "Failed to configure cryptodev: dev_id %u, qp_id %u",
1522 ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
1524 /* valid - one queue pairs */
1525 ts_params->conf.nb_queue_pairs = 1;
1527 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1529 "Failed to configure cryptodev: dev_id %u, qp_id %u",
1530 ts_params->valid_devs[0],
1531 ts_params->conf.nb_queue_pairs);
1534 /* invalid - zero queue pairs */
1535 ts_params->conf.nb_queue_pairs = 0;
1537 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1539 "Failed test for rte_cryptodev_configure, dev_id %u,"
1541 ts_params->valid_devs[0],
1542 ts_params->conf.nb_queue_pairs);
1545 /* invalid - max value supported by field queue pairs */
1546 ts_params->conf.nb_queue_pairs = UINT16_MAX;
1548 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1550 "Failed test for rte_cryptodev_configure, dev_id %u,"
1552 ts_params->valid_devs[0],
1553 ts_params->conf.nb_queue_pairs);
1556 /* invalid - max value + 1 queue pairs */
1557 ts_params->conf.nb_queue_pairs = orig_nb_qps + 1;
1559 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1561 "Failed test for rte_cryptodev_configure, dev_id %u,"
1563 ts_params->valid_devs[0],
1564 ts_params->conf.nb_queue_pairs);
1566 /* revert to original testsuite value */
1567 ts_params->conf.nb_queue_pairs = orig_nb_qps;
1569 return TEST_SUCCESS;
1573 test_queue_pair_descriptor_setup(void)
1575 struct crypto_testsuite_params *ts_params = &testsuite_params;
1576 struct rte_cryptodev_qp_conf qp_conf = {
1577 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
1581 /* Stop the device in case it's started so it can be configured */
1582 rte_cryptodev_stop(ts_params->valid_devs[0]);
1584 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1586 "Failed to configure cryptodev %u",
1587 ts_params->valid_devs[0]);
1590 * Test various ring sizes on this device. memzones can't be
1591 * freed so are re-used if ring is released and re-created.
1593 qp_conf.nb_descriptors = MIN_NUM_OPS_INFLIGHT; /* min size*/
1594 qp_conf.mp_session = ts_params->session_mpool;
1595 qp_conf.mp_session_private = ts_params->session_priv_mpool;
1597 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1598 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1599 ts_params->valid_devs[0], qp_id, &qp_conf,
1600 rte_cryptodev_socket_id(
1601 ts_params->valid_devs[0])),
1603 "rte_cryptodev_queue_pair_setup: num_inflights "
1604 "%u on qp %u on cryptodev %u",
1605 qp_conf.nb_descriptors, qp_id,
1606 ts_params->valid_devs[0]);
1609 qp_conf.nb_descriptors = (uint32_t)(MAX_NUM_OPS_INFLIGHT / 2);
1611 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1612 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1613 ts_params->valid_devs[0], qp_id, &qp_conf,
1614 rte_cryptodev_socket_id(
1615 ts_params->valid_devs[0])),
1617 " rte_cryptodev_queue_pair_setup: num_inflights"
1618 " %u on qp %u on cryptodev %u",
1619 qp_conf.nb_descriptors, qp_id,
1620 ts_params->valid_devs[0]);
1623 qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; /* valid */
1625 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1626 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1627 ts_params->valid_devs[0], qp_id, &qp_conf,
1628 rte_cryptodev_socket_id(
1629 ts_params->valid_devs[0])),
1631 "rte_cryptodev_queue_pair_setup: num_inflights"
1632 " %u on qp %u on cryptodev %u",
1633 qp_conf.nb_descriptors, qp_id,
1634 ts_params->valid_devs[0]);
1637 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
1639 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1640 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1641 ts_params->valid_devs[0], qp_id, &qp_conf,
1642 rte_cryptodev_socket_id(
1643 ts_params->valid_devs[0])),
1645 " rte_cryptodev_queue_pair_setup:"
1646 "num_inflights %u on qp %u on cryptodev %u",
1647 qp_conf.nb_descriptors, qp_id,
1648 ts_params->valid_devs[0]);
1651 /* test invalid queue pair id */
1652 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT; /*valid */
1654 qp_id = ts_params->conf.nb_queue_pairs; /*invalid */
1656 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
1657 ts_params->valid_devs[0],
1659 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1660 "Failed test for rte_cryptodev_queue_pair_setup:"
1661 "invalid qp %u on cryptodev %u",
1662 qp_id, ts_params->valid_devs[0]);
1664 qp_id = 0xffff; /*invalid*/
1666 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
1667 ts_params->valid_devs[0],
1669 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1670 "Failed test for rte_cryptodev_queue_pair_setup:"
1671 "invalid qp %u on cryptodev %u",
1672 qp_id, ts_params->valid_devs[0]);
1674 return TEST_SUCCESS;
1677 /* ***** Plaintext data for tests ***** */
1679 const char catch_22_quote_1[] =
1680 "There was only one catch and that was Catch-22, which "
1681 "specified that a concern for one's safety in the face of "
1682 "dangers that were real and immediate was the process of a "
1683 "rational mind. Orr was crazy and could be grounded. All he "
1684 "had to do was ask; and as soon as he did, he would no longer "
1685 "be crazy and would have to fly more missions. Orr would be "
1686 "crazy to fly more missions and sane if he didn't, but if he "
1687 "was sane he had to fly them. If he flew them he was crazy "
1688 "and didn't have to; but if he didn't want to he was sane and "
1689 "had to. Yossarian was moved very deeply by the absolute "
1690 "simplicity of this clause of Catch-22 and let out a "
1691 "respectful whistle. \"That's some catch, that Catch-22\", he "
1692 "observed. \"It's the best there is,\" Doc Daneeka agreed.";
1694 const char catch_22_quote[] =
1695 "What a lousy earth! He wondered how many people were "
1696 "destitute that same night even in his own prosperous country, "
1697 "how many homes were shanties, how many husbands were drunk "
1698 "and wives socked, and how many children were bullied, abused, "
1699 "or abandoned. How many families hungered for food they could "
1700 "not afford to buy? How many hearts were broken? How many "
1701 "suicides would take place that same night, how many people "
1702 "would go insane? How many cockroaches and landlords would "
1703 "triumph? How many winners were losers, successes failures, "
1704 "and rich men poor men? How many wise guys were stupid? How "
1705 "many happy endings were unhappy endings? How many honest men "
1706 "were liars, brave men cowards, loyal men traitors, how many "
1707 "sainted men were corrupt, how many people in positions of "
1708 "trust had sold their souls to bodyguards, how many had never "
1709 "had souls? How many straight-and-narrow paths were crooked "
1710 "paths? How many best families were worst families and how "
1711 "many good people were bad people? When you added them all up "
1712 "and then subtracted, you might be left with only the children, "
1713 "and perhaps with Albert Einstein and an old violinist or "
1714 "sculptor somewhere.";
1716 #define QUOTE_480_BYTES (480)
1717 #define QUOTE_512_BYTES (512)
1718 #define QUOTE_768_BYTES (768)
1719 #define QUOTE_1024_BYTES (1024)
1723 /* ***** SHA1 Hash Tests ***** */
1725 #define HMAC_KEY_LENGTH_SHA1 (DIGEST_BYTE_LENGTH_SHA1)
1727 static uint8_t hmac_sha1_key[] = {
1728 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
1729 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
1730 0xDE, 0xF4, 0xDE, 0xAD };
1732 /* ***** SHA224 Hash Tests ***** */
1734 #define HMAC_KEY_LENGTH_SHA224 (DIGEST_BYTE_LENGTH_SHA224)
1737 /* ***** AES-CBC Cipher Tests ***** */
1739 #define CIPHER_KEY_LENGTH_AES_CBC (16)
1740 #define CIPHER_IV_LENGTH_AES_CBC (CIPHER_KEY_LENGTH_AES_CBC)
1742 static uint8_t aes_cbc_key[] = {
1743 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
1744 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A };
1746 static uint8_t aes_cbc_iv[] = {
1747 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1748 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
1751 /* ***** AES-CBC / HMAC-SHA1 Hash Tests ***** */
1753 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_ciphertext[] = {
1754 0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31,
1755 0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76,
1756 0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E,
1757 0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A,
1758 0x3F, 0x6B, 0x5D, 0xDF, 0x52, 0x85, 0x5F, 0x8E,
1759 0x42, 0x3C, 0xFB, 0xE9, 0x1A, 0x24, 0xD6, 0x08,
1760 0xDD, 0xFD, 0x16, 0xFB, 0xE9, 0x55, 0xEF, 0xF0,
1761 0xA0, 0x8D, 0x13, 0xAB, 0x81, 0xC6, 0x90, 0x01,
1762 0xB5, 0x18, 0x84, 0xB3, 0xF6, 0xE6, 0x11, 0x57,
1763 0xD6, 0x71, 0xC6, 0x3C, 0x3F, 0x2F, 0x33, 0xEE,
1764 0x24, 0x42, 0x6E, 0xAC, 0x0B, 0xCA, 0xEC, 0xF9,
1765 0x84, 0xF8, 0x22, 0xAA, 0x60, 0xF0, 0x32, 0xA9,
1766 0x75, 0x75, 0x3B, 0xCB, 0x70, 0x21, 0x0A, 0x8D,
1767 0x0F, 0xE0, 0xC4, 0x78, 0x2B, 0xF8, 0x97, 0xE3,
1768 0xE4, 0x26, 0x4B, 0x29, 0xDA, 0x88, 0xCD, 0x46,
1769 0xEC, 0xAA, 0xF9, 0x7F, 0xF1, 0x15, 0xEA, 0xC3,
1770 0x87, 0xE6, 0x31, 0xF2, 0xCF, 0xDE, 0x4D, 0x80,
1771 0x70, 0x91, 0x7E, 0x0C, 0xF7, 0x26, 0x3A, 0x92,
1772 0x4F, 0x18, 0x83, 0xC0, 0x8F, 0x59, 0x01, 0xA5,
1773 0x88, 0xD1, 0xDB, 0x26, 0x71, 0x27, 0x16, 0xF5,
1774 0xEE, 0x10, 0x82, 0xAC, 0x68, 0x26, 0x9B, 0xE2,
1775 0x6D, 0xD8, 0x9A, 0x80, 0xDF, 0x04, 0x31, 0xD5,
1776 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1777 0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
1778 0x73, 0x02, 0x42, 0xC9, 0x23, 0x18, 0x8E, 0xB4,
1779 0x6F, 0xB4, 0xA3, 0x54, 0x6E, 0x88, 0x3B, 0x62,
1780 0x7C, 0x02, 0x8D, 0x4C, 0x9F, 0xC8, 0x45, 0xF4,
1781 0xC9, 0xDE, 0x4F, 0xEB, 0x22, 0x83, 0x1B, 0xE4,
1782 0x49, 0x37, 0xE4, 0xAD, 0xE7, 0xCD, 0x21, 0x54,
1783 0xBC, 0x1C, 0xC2, 0x04, 0x97, 0xB4, 0x10, 0x61,
1784 0xF0, 0xE4, 0xEF, 0x27, 0x63, 0x3A, 0xDA, 0x91,
1785 0x41, 0x25, 0x62, 0x1C, 0x5C, 0xB6, 0x38, 0x4A,
1786 0x88, 0x71, 0x59, 0x5A, 0x8D, 0xA0, 0x09, 0xAF,
1787 0x72, 0x94, 0xD7, 0x79, 0x5C, 0x60, 0x7C, 0x8F,
1788 0x4C, 0xF5, 0xD9, 0xA1, 0x39, 0x6D, 0x81, 0x28,
1789 0xEF, 0x13, 0x28, 0xDF, 0xF5, 0x3E, 0xF7, 0x8E,
1790 0x09, 0x9C, 0x78, 0x18, 0x79, 0xB8, 0x68, 0xD7,
1791 0xA8, 0x29, 0x62, 0xAD, 0xDE, 0xE1, 0x61, 0x76,
1792 0x1B, 0x05, 0x16, 0xCD, 0xBF, 0x02, 0x8E, 0xA6,
1793 0x43, 0x6E, 0x92, 0x55, 0x4F, 0x60, 0x9C, 0x03,
1794 0xB8, 0x4F, 0xA3, 0x02, 0xAC, 0xA8, 0xA7, 0x0C,
1795 0x1E, 0xB5, 0x6B, 0xF8, 0xC8, 0x4D, 0xDE, 0xD2,
1796 0xB0, 0x29, 0x6E, 0x40, 0xE6, 0xD6, 0xC9, 0xE6,
1797 0xB9, 0x0F, 0xB6, 0x63, 0xF5, 0xAA, 0x2B, 0x96,
1798 0xA7, 0x16, 0xAC, 0x4E, 0x0A, 0x33, 0x1C, 0xA6,
1799 0xE6, 0xBD, 0x8A, 0xCF, 0x40, 0xA9, 0xB2, 0xFA,
1800 0x63, 0x27, 0xFD, 0x9B, 0xD9, 0xFC, 0xD5, 0x87,
1801 0x8D, 0x4C, 0xB6, 0xA4, 0xCB, 0xE7, 0x74, 0x55,
1802 0xF4, 0xFB, 0x41, 0x25, 0xB5, 0x4B, 0x0A, 0x1B,
1803 0xB1, 0xD6, 0xB7, 0xD9, 0x47, 0x2A, 0xC3, 0x98,
1804 0x6A, 0xC4, 0x03, 0x73, 0x1F, 0x93, 0x6E, 0x53,
1805 0x19, 0x25, 0x64, 0x15, 0x83, 0xF9, 0x73, 0x2A,
1806 0x74, 0xB4, 0x93, 0x69, 0xC4, 0x72, 0xFC, 0x26,
1807 0xA2, 0x9F, 0x43, 0x45, 0xDD, 0xB9, 0xEF, 0x36,
1808 0xC8, 0x3A, 0xCD, 0x99, 0x9B, 0x54, 0x1A, 0x36,
1809 0xC1, 0x59, 0xF8, 0x98, 0xA8, 0xCC, 0x28, 0x0D,
1810 0x73, 0x4C, 0xEE, 0x98, 0xCB, 0x7C, 0x58, 0x7E,
1811 0x20, 0x75, 0x1E, 0xB7, 0xC9, 0xF8, 0xF2, 0x0E,
1812 0x63, 0x9E, 0x05, 0x78, 0x1A, 0xB6, 0xA8, 0x7A,
1813 0xF9, 0x98, 0x6A, 0xA6, 0x46, 0x84, 0x2E, 0xF6,
1814 0x4B, 0xDC, 0x9B, 0x8F, 0x9B, 0x8F, 0xEE, 0xB4,
1815 0xAA, 0x3F, 0xEE, 0xC0, 0x37, 0x27, 0x76, 0xC7,
1816 0x95, 0xBB, 0x26, 0x74, 0x69, 0x12, 0x7F, 0xF1,
1817 0xBB, 0xFF, 0xAE, 0xB5, 0x99, 0x6E, 0xCB, 0x0C
1820 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest[] = {
1821 0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60,
1822 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1823 0x18, 0x8c, 0x1d, 0x32
1827 /* Multisession Vector context Test */
1828 /*Begin Session 0 */
1829 static uint8_t ms_aes_cbc_key0[] = {
1830 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1831 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1834 static uint8_t ms_aes_cbc_iv0[] = {
1835 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1836 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1839 static const uint8_t ms_aes_cbc_cipher0[] = {
1840 0x3C, 0xE4, 0xEE, 0x42, 0xB6, 0x9B, 0xC3, 0x38,
1841 0x5F, 0xAD, 0x54, 0xDC, 0xA8, 0x32, 0x81, 0xDC,
1842 0x7A, 0x6F, 0x85, 0x58, 0x07, 0x35, 0xED, 0xEB,
1843 0xAD, 0x79, 0x79, 0x96, 0xD3, 0x0E, 0xA6, 0xD9,
1844 0xAA, 0x86, 0xA4, 0x8F, 0xB5, 0xD6, 0x6E, 0x6D,
1845 0x0C, 0x91, 0x2F, 0xC4, 0x67, 0x98, 0x0E, 0xC4,
1846 0x8D, 0x83, 0x68, 0x69, 0xC4, 0xD3, 0x94, 0x34,
1847 0xC4, 0x5D, 0x60, 0x55, 0x22, 0x87, 0x8F, 0x6F,
1848 0x17, 0x8E, 0x75, 0xE4, 0x02, 0xF5, 0x1B, 0x99,
1849 0xC8, 0x39, 0xA9, 0xAB, 0x23, 0x91, 0x12, 0xED,
1850 0x08, 0xE7, 0xD9, 0x25, 0x89, 0x24, 0x4F, 0x8D,
1851 0x68, 0xF3, 0x10, 0x39, 0x0A, 0xEE, 0x45, 0x24,
1852 0xDF, 0x7A, 0x9D, 0x00, 0x25, 0xE5, 0x35, 0x71,
1853 0x4E, 0x40, 0x59, 0x6F, 0x0A, 0x13, 0xB3, 0x72,
1854 0x1D, 0x98, 0x63, 0x94, 0x89, 0xA5, 0x39, 0x8E,
1855 0xD3, 0x9C, 0x8A, 0x7F, 0x71, 0x2F, 0xC7, 0xCD,
1856 0x81, 0x05, 0xDC, 0xC0, 0x8D, 0xCE, 0x6D, 0x18,
1857 0x30, 0xC4, 0x72, 0x51, 0xF0, 0x27, 0xC8, 0xF6,
1858 0x60, 0x5B, 0x7C, 0xB2, 0xE3, 0x49, 0x0C, 0x29,
1859 0xC6, 0x9F, 0x39, 0x57, 0x80, 0x55, 0x24, 0x2C,
1860 0x9B, 0x0F, 0x5A, 0xB3, 0x89, 0x55, 0x31, 0x96,
1861 0x0D, 0xCD, 0xF6, 0x51, 0x03, 0x2D, 0x89, 0x26,
1862 0x74, 0x44, 0xD6, 0xE8, 0xDC, 0xEA, 0x44, 0x55,
1863 0x64, 0x71, 0x9C, 0x9F, 0x5D, 0xBA, 0x39, 0x46,
1864 0xA8, 0x17, 0xA1, 0x9C, 0x52, 0x9D, 0xBC, 0x6B,
1865 0x4A, 0x98, 0xE6, 0xEA, 0x33, 0xEC, 0x58, 0xB4,
1866 0x43, 0xF0, 0x32, 0x45, 0xA4, 0xC1, 0x55, 0xB7,
1867 0x5D, 0xB5, 0x59, 0xB2, 0xE3, 0x96, 0xFF, 0xA5,
1868 0xAF, 0xE1, 0x86, 0x1B, 0x42, 0xE6, 0x3B, 0xA0,
1869 0x90, 0x4A, 0xE8, 0x8C, 0x21, 0x7F, 0x36, 0x1E,
1870 0x5B, 0x65, 0x25, 0xD1, 0xC1, 0x5A, 0xCA, 0x3D,
1871 0x10, 0xED, 0x2D, 0x79, 0xD0, 0x0F, 0x58, 0x44,
1872 0x69, 0x81, 0xF5, 0xD4, 0xC9, 0x0F, 0x90, 0x76,
1873 0x1F, 0x54, 0xD2, 0xD5, 0x97, 0xCE, 0x2C, 0xE3,
1874 0xEF, 0xF4, 0xB7, 0xC6, 0x3A, 0x87, 0x7F, 0x83,
1875 0x2A, 0xAF, 0xCD, 0x90, 0x12, 0xA7, 0x7D, 0x85,
1876 0x1D, 0x62, 0xD3, 0x85, 0x25, 0x05, 0xDB, 0x45,
1877 0x92, 0xA3, 0xF6, 0xA2, 0xA8, 0x41, 0xE4, 0x25,
1878 0x86, 0x87, 0x67, 0x24, 0xEC, 0x89, 0x23, 0x2A,
1879 0x9B, 0x20, 0x4D, 0x93, 0xEE, 0xE2, 0x2E, 0xC1,
1880 0x0B, 0x15, 0x33, 0xCF, 0x00, 0xD1, 0x1A, 0xDA,
1881 0x93, 0xFD, 0x28, 0x21, 0x5B, 0xCF, 0xD1, 0xF3,
1882 0x5A, 0x81, 0xBA, 0x82, 0x5E, 0x2F, 0x61, 0xB4,
1883 0x05, 0x71, 0xB5, 0xF4, 0x39, 0x3C, 0x1F, 0x60,
1884 0x00, 0x7A, 0xC4, 0xF8, 0x35, 0x20, 0x6C, 0x3A,
1885 0xCC, 0x03, 0x8F, 0x7B, 0xA2, 0xB6, 0x65, 0x8A,
1886 0xB6, 0x5F, 0xFD, 0x25, 0xD3, 0x5F, 0x92, 0xF9,
1887 0xAE, 0x17, 0x9B, 0x5E, 0x6E, 0x9A, 0xE4, 0x55,
1888 0x10, 0x25, 0x07, 0xA4, 0xAF, 0x21, 0x69, 0x13,
1889 0xD8, 0xFA, 0x31, 0xED, 0xF7, 0xA7, 0xA7, 0x3B,
1890 0xB8, 0x96, 0x8E, 0x10, 0x86, 0x74, 0xD8, 0xB1,
1891 0x34, 0x9E, 0x9B, 0x6A, 0x26, 0xA8, 0xD4, 0xD0,
1892 0xB5, 0xF6, 0xDE, 0xE7, 0xCA, 0x06, 0xDC, 0xA3,
1893 0x6F, 0xEE, 0x6B, 0x1E, 0xB5, 0x30, 0x99, 0x23,
1894 0xF9, 0x76, 0xF0, 0xA0, 0xCF, 0x3B, 0x94, 0x7B,
1895 0x19, 0x8D, 0xA5, 0x0C, 0x18, 0xA6, 0x1D, 0x07,
1896 0x89, 0xBE, 0x5B, 0x61, 0xE5, 0xF1, 0x42, 0xDB,
1897 0xD4, 0x2E, 0x02, 0x1F, 0xCE, 0xEF, 0x92, 0xB1,
1898 0x1B, 0x56, 0x50, 0xF2, 0x16, 0xE5, 0xE7, 0x4F,
1899 0xFD, 0xBB, 0x3E, 0xD2, 0xFC, 0x3C, 0xC6, 0x0F,
1900 0xF9, 0x12, 0x4E, 0xCB, 0x1E, 0x0C, 0x15, 0x84,
1901 0x2A, 0x14, 0x8A, 0x02, 0xE4, 0x7E, 0x95, 0x5B,
1902 0x86, 0xDB, 0x9B, 0x62, 0x5B, 0x19, 0xD2, 0x17,
1903 0xFA, 0x13, 0xBB, 0x6B, 0x3F, 0x45, 0x9F, 0xBF
1907 static uint8_t ms_hmac_key0[] = {
1908 0xFF, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1909 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1910 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1911 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1912 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1913 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1914 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1915 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1918 static const uint8_t ms_hmac_digest0[] = {
1919 0x43, 0x52, 0xED, 0x34, 0xAB, 0x36, 0xB2, 0x51,
1920 0xFB, 0xA3, 0xA6, 0x7C, 0x38, 0xFC, 0x42, 0x8F,
1921 0x57, 0x64, 0xAB, 0x81, 0xA7, 0x89, 0xB7, 0x6C,
1922 0xA0, 0xDC, 0xB9, 0x4D, 0xC4, 0x30, 0xF9, 0xD4,
1923 0x10, 0x82, 0x55, 0xD0, 0xAB, 0x32, 0xFB, 0x56,
1924 0x0D, 0xE4, 0x68, 0x3D, 0x76, 0xD0, 0x7B, 0xE4,
1925 0xA6, 0x2C, 0x34, 0x9E, 0x8C, 0x41, 0xF8, 0x23,
1926 0x28, 0x1B, 0x3A, 0x90, 0x26, 0x34, 0x47, 0x90
1930 /* Begin session 1 */
1932 static uint8_t ms_aes_cbc_key1[] = {
1933 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1934 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1937 static uint8_t ms_aes_cbc_iv1[] = {
1938 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1939 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1942 static const uint8_t ms_aes_cbc_cipher1[] = {
1943 0x5A, 0x7A, 0x67, 0x5D, 0xB8, 0xE1, 0xDC, 0x71,
1944 0x39, 0xA8, 0x74, 0x93, 0x9C, 0x4C, 0xFE, 0x23,
1945 0x61, 0xCD, 0xA4, 0xB3, 0xD9, 0xCE, 0x99, 0x09,
1946 0x2A, 0x23, 0xF3, 0x29, 0xBF, 0x4C, 0xB4, 0x6A,
1947 0x1B, 0x6B, 0x73, 0x4D, 0x48, 0x0C, 0xCF, 0x6C,
1948 0x5E, 0x34, 0x9E, 0x7F, 0xBC, 0x8F, 0xCC, 0x8F,
1949 0x75, 0x1D, 0x3D, 0x77, 0x10, 0x76, 0xC8, 0xB9,
1950 0x99, 0x6F, 0xD6, 0x56, 0x75, 0xA9, 0xB2, 0x66,
1951 0xC2, 0x24, 0x2B, 0x9C, 0xFE, 0x40, 0x8E, 0x43,
1952 0x20, 0x97, 0x1B, 0xFA, 0xD0, 0xCF, 0x04, 0xAB,
1953 0xBB, 0xF6, 0x5D, 0xF5, 0xA0, 0x19, 0x7C, 0x23,
1954 0x5D, 0x80, 0x8C, 0x49, 0xF6, 0x76, 0x88, 0x29,
1955 0x27, 0x4C, 0x59, 0x2B, 0x43, 0xA6, 0xB2, 0x26,
1956 0x27, 0x78, 0xBE, 0x1B, 0xE1, 0x4F, 0x5A, 0x1F,
1957 0xFC, 0x68, 0x08, 0xE7, 0xC4, 0xD1, 0x34, 0x68,
1958 0xB7, 0x13, 0x14, 0x41, 0x62, 0x6B, 0x1F, 0x77,
1959 0x0C, 0x68, 0x1D, 0x0D, 0xED, 0x89, 0xAA, 0xD8,
1960 0x97, 0x02, 0xBA, 0x5E, 0xD4, 0x84, 0x25, 0x97,
1961 0x03, 0xA5, 0xA6, 0x13, 0x66, 0x02, 0xF4, 0xC3,
1962 0xF3, 0xD3, 0xCC, 0x95, 0xC3, 0x87, 0x46, 0x90,
1963 0x1F, 0x6E, 0x14, 0xA8, 0x00, 0xF2, 0x6F, 0xD5,
1964 0xA1, 0xAD, 0xD5, 0x40, 0xA2, 0x0F, 0x32, 0x7E,
1965 0x99, 0xA3, 0xF5, 0x53, 0xC3, 0x26, 0xA1, 0x45,
1966 0x01, 0x88, 0x57, 0x84, 0x3E, 0x7B, 0x4E, 0x0B,
1967 0x3C, 0xB5, 0x3E, 0x9E, 0xE9, 0x78, 0x77, 0xC5,
1968 0xC0, 0x89, 0xA8, 0xF8, 0xF1, 0xA5, 0x2D, 0x5D,
1969 0xF9, 0xC6, 0xFB, 0xCB, 0x05, 0x23, 0xBD, 0x6E,
1970 0x5E, 0x14, 0xC6, 0x57, 0x73, 0xCF, 0x98, 0xBD,
1971 0x10, 0x8B, 0x18, 0xA6, 0x01, 0x5B, 0x13, 0xAE,
1972 0x8E, 0xDE, 0x1F, 0xB5, 0xB7, 0x40, 0x6C, 0xC1,
1973 0x1E, 0xA1, 0x19, 0x20, 0x9E, 0x95, 0xE0, 0x2F,
1974 0x1C, 0xF5, 0xD9, 0xD0, 0x2B, 0x1E, 0x82, 0x25,
1975 0x62, 0xB4, 0xEB, 0xA1, 0x1F, 0xCE, 0x44, 0xA1,
1976 0xCB, 0x92, 0x01, 0x6B, 0xE4, 0x26, 0x23, 0xE3,
1977 0xC5, 0x67, 0x35, 0x55, 0xDA, 0xE5, 0x27, 0xEE,
1978 0x8D, 0x12, 0x84, 0xB7, 0xBA, 0xA7, 0x1C, 0xD6,
1979 0x32, 0x3F, 0x67, 0xED, 0xFB, 0x5B, 0x8B, 0x52,
1980 0x46, 0x8C, 0xF9, 0x69, 0xCD, 0xAE, 0x79, 0xAA,
1981 0x37, 0x78, 0x49, 0xEB, 0xC6, 0x8E, 0x76, 0x63,
1982 0x84, 0xFF, 0x9D, 0x22, 0x99, 0x51, 0xB7, 0x5E,
1983 0x83, 0x4C, 0x8B, 0xDF, 0x5A, 0x07, 0xCC, 0xBA,
1984 0x42, 0xA5, 0x98, 0xB6, 0x47, 0x0E, 0x66, 0xEB,
1985 0x23, 0x0E, 0xBA, 0x44, 0xA8, 0xAA, 0x20, 0x71,
1986 0x79, 0x9C, 0x77, 0x5F, 0xF5, 0xFE, 0xEC, 0xEF,
1987 0xC6, 0x64, 0x3D, 0x84, 0xD0, 0x2B, 0xA7, 0x0A,
1988 0xC3, 0x72, 0x5B, 0x9C, 0xFA, 0xA8, 0x87, 0x95,
1989 0x94, 0x11, 0x38, 0xA7, 0x1E, 0x58, 0xE3, 0x73,
1990 0xC6, 0xC9, 0xD1, 0x7B, 0x92, 0xDB, 0x0F, 0x49,
1991 0x74, 0xC2, 0xA2, 0x0E, 0x35, 0x57, 0xAC, 0xDB,
1992 0x9A, 0x1C, 0xCF, 0x5A, 0x32, 0x3E, 0x26, 0x9B,
1993 0xEC, 0xB3, 0xEF, 0x9C, 0xFE, 0xBE, 0x52, 0xAC,
1994 0xB1, 0x29, 0xDD, 0xFD, 0x07, 0xE2, 0xEE, 0xED,
1995 0xE4, 0x46, 0x37, 0xFE, 0xD1, 0xDC, 0xCD, 0x02,
1996 0xF9, 0x31, 0xB0, 0xFB, 0x36, 0xB7, 0x34, 0xA4,
1997 0x76, 0xE8, 0x57, 0xBF, 0x99, 0x92, 0xC7, 0xAF,
1998 0x98, 0x10, 0xE2, 0x70, 0xCA, 0xC9, 0x2B, 0x82,
1999 0x06, 0x96, 0x88, 0x0D, 0xB3, 0xAC, 0x9E, 0x6D,
2000 0x43, 0xBC, 0x5B, 0x31, 0xCF, 0x65, 0x8D, 0xA6,
2001 0xC7, 0xFE, 0x73, 0xE1, 0x54, 0xF7, 0x10, 0xF9,
2002 0x86, 0xF7, 0xDF, 0xA1, 0xA1, 0xD8, 0xAE, 0x35,
2003 0xB3, 0x90, 0xDC, 0x6F, 0x43, 0x7A, 0x8B, 0xE0,
2004 0xFE, 0x8F, 0x33, 0x4D, 0x29, 0x6C, 0x45, 0x53,
2005 0x73, 0xDD, 0x21, 0x0B, 0x85, 0x30, 0xB5, 0xA5,
2006 0xF3, 0x5D, 0xEC, 0x79, 0x61, 0x9D, 0x9E, 0xB3
2010 static uint8_t ms_hmac_key1[] = {
2011 0xFE, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
2012 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
2013 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
2014 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
2015 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
2016 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
2017 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
2018 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
2021 static const uint8_t ms_hmac_digest1[] = {
2022 0xCE, 0x6E, 0x5F, 0x77, 0x96, 0x9A, 0xB1, 0x69,
2023 0x2D, 0x5E, 0xF3, 0x2F, 0x32, 0x10, 0xCB, 0x50,
2024 0x0E, 0x09, 0x56, 0x25, 0x07, 0x34, 0xC9, 0x20,
2025 0xEC, 0x13, 0x43, 0x23, 0x5C, 0x08, 0x8B, 0xCD,
2026 0xDC, 0x86, 0x8C, 0xEE, 0x0A, 0x95, 0x2E, 0xB9,
2027 0x8C, 0x7B, 0x02, 0x7A, 0xD4, 0xE1, 0x49, 0xB4,
2028 0x45, 0xB5, 0x52, 0x37, 0xC6, 0xFF, 0xFE, 0xAA,
2029 0x0A, 0x87, 0xB8, 0x51, 0xF9, 0x2A, 0x01, 0x8F
2032 /* Begin Session 2 */
2033 static uint8_t ms_aes_cbc_key2[] = {
2034 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
2035 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
2038 static uint8_t ms_aes_cbc_iv2[] = {
2039 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
2040 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
2043 static const uint8_t ms_aes_cbc_cipher2[] = {
2044 0xBB, 0x3C, 0x68, 0x25, 0xFD, 0xB6, 0xA2, 0x91,
2045 0x20, 0x56, 0xF6, 0x30, 0x35, 0xFC, 0x9E, 0x97,
2046 0xF2, 0x90, 0xFC, 0x7E, 0x3E, 0x0A, 0x75, 0xC8,
2047 0x4C, 0xF2, 0x2D, 0xAC, 0xD3, 0x93, 0xF0, 0xC5,
2048 0x14, 0x88, 0x8A, 0x23, 0xC2, 0x59, 0x9A, 0x98,
2049 0x4B, 0xD5, 0x2C, 0xDA, 0x43, 0xA9, 0x34, 0x69,
2050 0x7C, 0x6D, 0xDB, 0xDC, 0xCB, 0xC0, 0xA0, 0x09,
2051 0xA7, 0x86, 0x16, 0x4B, 0xBF, 0xA8, 0xB6, 0xCF,
2052 0x7F, 0x74, 0x1F, 0x22, 0xF0, 0xF6, 0xBB, 0x44,
2053 0x8B, 0x4C, 0x9E, 0x23, 0xF8, 0x9F, 0xFC, 0x5B,
2054 0x9E, 0x9C, 0x2A, 0x79, 0x30, 0x8F, 0xBF, 0xA9,
2055 0x68, 0xA1, 0x20, 0x71, 0x7C, 0x77, 0x22, 0x34,
2056 0x07, 0xCD, 0xC6, 0xF6, 0x50, 0x0A, 0x08, 0x99,
2057 0x17, 0x98, 0xE3, 0x93, 0x8A, 0xB0, 0xEE, 0xDF,
2058 0xC2, 0xBA, 0x3B, 0x44, 0x73, 0xDF, 0xDD, 0xDC,
2059 0x14, 0x4D, 0x3B, 0xBB, 0x5E, 0x58, 0xC1, 0x26,
2060 0xA7, 0xAE, 0x47, 0xF3, 0x24, 0x6D, 0x4F, 0xD3,
2061 0x6E, 0x3E, 0x33, 0xE6, 0x7F, 0xCA, 0x50, 0xAF,
2062 0x5D, 0x3D, 0xA0, 0xDD, 0xC9, 0xF3, 0x30, 0xD3,
2063 0x6E, 0x8B, 0x2E, 0x12, 0x24, 0x34, 0xF0, 0xD3,
2064 0xC7, 0x8D, 0x23, 0x29, 0xAA, 0x05, 0xE1, 0xFA,
2065 0x2E, 0xF6, 0x8D, 0x37, 0x86, 0xC0, 0x6D, 0x13,
2066 0x2D, 0x98, 0xF3, 0x52, 0x39, 0x22, 0xCE, 0x38,
2067 0xC2, 0x1A, 0x72, 0xED, 0xFB, 0xCC, 0xE4, 0x71,
2068 0x5A, 0x0C, 0x0D, 0x09, 0xF8, 0xE8, 0x1B, 0xBC,
2069 0x53, 0xC8, 0xD8, 0x8F, 0xE5, 0x98, 0x5A, 0xB1,
2070 0x06, 0xA6, 0x5B, 0xE6, 0xA2, 0x88, 0x21, 0x9E,
2071 0x36, 0xC0, 0x34, 0xF9, 0xFB, 0x3B, 0x0A, 0x22,
2072 0x00, 0x00, 0x39, 0x48, 0x8D, 0x23, 0x74, 0x62,
2073 0x72, 0x91, 0xE6, 0x36, 0xAA, 0x77, 0x9C, 0x72,
2074 0x9D, 0xA8, 0xC3, 0xA9, 0xD5, 0x44, 0x72, 0xA6,
2075 0xB9, 0x28, 0x8F, 0x64, 0x4C, 0x8A, 0x64, 0xE6,
2076 0x4E, 0xFA, 0xEF, 0x87, 0xDE, 0x7B, 0x22, 0x44,
2077 0xB0, 0xDF, 0x2E, 0x5F, 0x0B, 0xA5, 0xF2, 0x24,
2078 0x07, 0x5C, 0x2D, 0x39, 0xB7, 0x3D, 0x8A, 0xE5,
2079 0x0E, 0x9D, 0x4E, 0x50, 0xED, 0x03, 0x99, 0x8E,
2080 0xF0, 0x06, 0x55, 0x4E, 0xA2, 0x24, 0xE7, 0x17,
2081 0x46, 0xDF, 0x6C, 0xCD, 0xC6, 0x44, 0xE8, 0xF9,
2082 0xB9, 0x1B, 0x36, 0xF6, 0x7F, 0x10, 0xA4, 0x7D,
2083 0x90, 0xBD, 0xE4, 0xAA, 0xD6, 0x9E, 0x18, 0x9D,
2084 0x22, 0x35, 0xD6, 0x55, 0x54, 0xAA, 0xF7, 0x22,
2085 0xA3, 0x3E, 0xEF, 0xC8, 0xA2, 0x34, 0x8D, 0xA9,
2086 0x37, 0x63, 0xA6, 0xC3, 0x57, 0xCB, 0x0C, 0x49,
2087 0x7D, 0x02, 0xBE, 0xAA, 0x13, 0x75, 0xB7, 0x4E,
2088 0x52, 0x62, 0xA5, 0xC2, 0x33, 0xC7, 0x6C, 0x1B,
2089 0xF6, 0x34, 0xF6, 0x09, 0xA5, 0x0C, 0xC7, 0xA2,
2090 0x61, 0x48, 0x62, 0x7D, 0x17, 0x15, 0xE3, 0x95,
2091 0xC8, 0x63, 0xD2, 0xA4, 0x43, 0xA9, 0x49, 0x07,
2092 0xB2, 0x3B, 0x2B, 0x62, 0x7D, 0xCB, 0x51, 0xB3,
2093 0x25, 0x33, 0x47, 0x0E, 0x14, 0x67, 0xDC, 0x6A,
2094 0x9B, 0x51, 0xAC, 0x9D, 0x8F, 0xA2, 0x2B, 0x57,
2095 0x8C, 0x5C, 0x5F, 0x76, 0x23, 0x92, 0x0F, 0x84,
2096 0x46, 0x0E, 0x40, 0x85, 0x38, 0x60, 0xFA, 0x61,
2097 0x20, 0xC5, 0xE3, 0xF1, 0x70, 0xAC, 0x1B, 0xBF,
2098 0xC4, 0x2B, 0xC5, 0x67, 0xD1, 0x43, 0xC5, 0x17,
2099 0x74, 0x71, 0x69, 0x6F, 0x82, 0x89, 0x19, 0x8A,
2100 0x70, 0x43, 0x92, 0x01, 0xC4, 0x63, 0x7E, 0xB1,
2101 0x59, 0x4E, 0xCD, 0xEA, 0x93, 0xA4, 0x52, 0x53,
2102 0x9B, 0x61, 0x5B, 0xD2, 0x3E, 0x19, 0x39, 0xB7,
2103 0x32, 0xEA, 0x8E, 0xF8, 0x1D, 0x76, 0x5C, 0xB2,
2104 0x73, 0x2D, 0x91, 0xC0, 0x18, 0xED, 0x25, 0x2A,
2105 0x53, 0x64, 0xF0, 0x92, 0x31, 0x55, 0x21, 0xA8,
2106 0x24, 0xA9, 0xD1, 0x02, 0xF6, 0x6C, 0x2B, 0x70,
2107 0xA9, 0x59, 0xC1, 0xD6, 0xC3, 0x57, 0x5B, 0x92
2110 static uint8_t ms_hmac_key2[] = {
2111 0xFC, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
2112 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
2113 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
2114 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
2115 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
2116 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
2117 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
2118 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
2121 static const uint8_t ms_hmac_digest2[] = {
2122 0xA5, 0x0F, 0x9C, 0xFB, 0x08, 0x62, 0x59, 0xFF,
2123 0x80, 0x2F, 0xEB, 0x4B, 0xE1, 0x46, 0x21, 0xD6,
2124 0x02, 0x98, 0xF2, 0x8E, 0xF4, 0xEC, 0xD4, 0x77,
2125 0x86, 0x4C, 0x31, 0x28, 0xC8, 0x25, 0x80, 0x27,
2126 0x3A, 0x72, 0x5D, 0x6A, 0x56, 0x8A, 0xD3, 0x82,
2127 0xB0, 0xEC, 0x31, 0x6D, 0x8B, 0x6B, 0xB4, 0x24,
2128 0xE7, 0x62, 0xC1, 0x52, 0xBC, 0x14, 0x1B, 0x8E,
2129 0xEC, 0x9A, 0xF1, 0x47, 0x80, 0xD2, 0xB0, 0x59
2136 test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
2138 struct crypto_testsuite_params *ts_params = &testsuite_params;
2139 struct crypto_unittest_params *ut_params = &unittest_params;
2142 /* Verify the capabilities */
2143 struct rte_cryptodev_sym_capability_idx cap_idx;
2144 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2145 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
2146 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2148 return TEST_SKIPPED;
2149 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2150 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
2151 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2153 return TEST_SKIPPED;
2155 /* Generate test mbuf data and space for digest */
2156 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
2157 catch_22_quote, QUOTE_512_BYTES, 0);
2159 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2160 DIGEST_BYTE_LENGTH_SHA1);
2161 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
2163 /* Setup Cipher Parameters */
2164 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2165 ut_params->cipher_xform.next = &ut_params->auth_xform;
2167 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
2168 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2169 ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
2170 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
2171 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2172 ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
2174 /* Setup HMAC Parameters */
2175 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2177 ut_params->auth_xform.next = NULL;
2179 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2180 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
2181 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1;
2182 ut_params->auth_xform.auth.key.data = hmac_sha1_key;
2183 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
2185 ut_params->sess = rte_cryptodev_sym_session_create(
2186 ts_params->session_mpool);
2187 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2189 /* Create crypto session*/
2190 status = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
2191 ut_params->sess, &ut_params->cipher_xform,
2192 ts_params->session_priv_mpool);
2194 if (status == -ENOTSUP)
2195 return TEST_SKIPPED;
2197 TEST_ASSERT_EQUAL(status, 0, "Session init failed");
2199 /* Generate crypto op data structure */
2200 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2201 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2202 TEST_ASSERT_NOT_NULL(ut_params->op,
2203 "Failed to allocate symmetric crypto operation struct");
2205 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2207 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2209 /* set crypto operation source mbuf */
2210 sym_op->m_src = ut_params->ibuf;
2212 /* Set crypto operation authentication parameters */
2213 sym_op->auth.digest.data = ut_params->digest;
2214 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2215 ut_params->ibuf, QUOTE_512_BYTES);
2217 sym_op->auth.data.offset = 0;
2218 sym_op->auth.data.length = QUOTE_512_BYTES;
2220 /* Copy IV at the end of the crypto operation */
2221 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2222 aes_cbc_iv, CIPHER_IV_LENGTH_AES_CBC);
2224 /* Set crypto operation cipher parameters */
2225 sym_op->cipher.data.offset = 0;
2226 sym_op->cipher.data.length = QUOTE_512_BYTES;
2228 /* Process crypto operation */
2229 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2230 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
2233 TEST_ASSERT_NOT_NULL(
2234 process_crypto_request(ts_params->valid_devs[0],
2236 "failed to process sym crypto op");
2238 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2239 "crypto op processing failed");
2242 uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
2245 TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext,
2246 catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
2248 "ciphertext data not as expected");
2250 uint8_t *digest = ciphertext + QUOTE_512_BYTES;
2252 TEST_ASSERT_BUFFERS_ARE_EQUAL(digest,
2253 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
2254 gbl_driver_id == rte_cryptodev_driver_id_get(
2255 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) ?
2256 TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
2257 DIGEST_BYTE_LENGTH_SHA1,
2258 "Generated digest data not as expected");
2260 return TEST_SUCCESS;
2263 /* ***** AES-CBC / HMAC-SHA512 Hash Tests ***** */
2265 #define HMAC_KEY_LENGTH_SHA512 (DIGEST_BYTE_LENGTH_SHA512)
2267 static uint8_t hmac_sha512_key[] = {
2268 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
2269 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
2270 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
2271 0x9a, 0xaf, 0x88, 0x1b, 0xb6, 0x8f, 0xf8, 0x60,
2272 0xa2, 0x5a, 0x7f, 0x3f, 0xf4, 0x72, 0x70, 0xf1,
2273 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
2274 0x47, 0x3a, 0x75, 0x61, 0x5C, 0xa2, 0x10, 0x76,
2275 0x9a, 0xaf, 0x77, 0x5b, 0xb6, 0x7f, 0xf7, 0x60 };
2277 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest[] = {
2278 0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8,
2279 0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48,
2280 0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8,
2281 0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70,
2282 0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8,
2283 0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E,
2284 0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D,
2285 0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A };
2290 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
2291 struct crypto_unittest_params *ut_params,
2292 uint8_t *cipher_key,
2296 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
2297 struct crypto_unittest_params *ut_params,
2298 struct crypto_testsuite_params *ts_params,
2299 const uint8_t *cipher,
2300 const uint8_t *digest,
2305 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
2306 struct crypto_unittest_params *ut_params,
2307 uint8_t *cipher_key,
2311 /* Setup Cipher Parameters */
2312 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2313 ut_params->cipher_xform.next = NULL;
2315 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
2316 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
2317 ut_params->cipher_xform.cipher.key.data = cipher_key;
2318 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
2319 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2320 ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
2322 /* Setup HMAC Parameters */
2323 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2324 ut_params->auth_xform.next = &ut_params->cipher_xform;
2326 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
2327 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC;
2328 ut_params->auth_xform.auth.key.data = hmac_key;
2329 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512;
2330 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512;
2332 return TEST_SUCCESS;
2337 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
2338 struct crypto_unittest_params *ut_params,
2339 struct crypto_testsuite_params *ts_params,
2340 const uint8_t *cipher,
2341 const uint8_t *digest,
2344 /* Generate test mbuf data and digest */
2345 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
2348 QUOTE_512_BYTES, 0);
2350 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2351 DIGEST_BYTE_LENGTH_SHA512);
2352 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
2354 rte_memcpy(ut_params->digest,
2356 DIGEST_BYTE_LENGTH_SHA512);
2358 /* Generate Crypto op data structure */
2359 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2360 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2361 TEST_ASSERT_NOT_NULL(ut_params->op,
2362 "Failed to allocate symmetric crypto operation struct");
2364 rte_crypto_op_attach_sym_session(ut_params->op, sess);
2366 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2368 /* set crypto operation source mbuf */
2369 sym_op->m_src = ut_params->ibuf;
2371 sym_op->auth.digest.data = ut_params->digest;
2372 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2373 ut_params->ibuf, QUOTE_512_BYTES);
2375 sym_op->auth.data.offset = 0;
2376 sym_op->auth.data.length = QUOTE_512_BYTES;
2378 /* Copy IV at the end of the crypto operation */
2379 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2380 iv, CIPHER_IV_LENGTH_AES_CBC);
2382 sym_op->cipher.data.offset = 0;
2383 sym_op->cipher.data.length = QUOTE_512_BYTES;
2385 /* Process crypto operation */
2386 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2387 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
2389 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
2390 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
2391 ut_params->op, 1, 1, 0, 0);
2393 TEST_ASSERT_NOT_NULL(
2394 process_crypto_request(ts_params->valid_devs[0],
2396 "failed to process sym crypto op");
2398 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2399 "crypto op processing failed");
2401 ut_params->obuf = ut_params->op->sym->m_src;
2404 TEST_ASSERT_BUFFERS_ARE_EQUAL(
2405 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *),
2408 "Plaintext data not as expected");
2411 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2412 "Digest verification failed");
2414 return TEST_SUCCESS;
2417 /* ***** SNOW 3G Tests ***** */
2419 create_wireless_algo_hash_session(uint8_t dev_id,
2420 const uint8_t *key, const uint8_t key_len,
2421 const uint8_t iv_len, const uint8_t auth_len,
2422 enum rte_crypto_auth_operation op,
2423 enum rte_crypto_auth_algorithm algo)
2425 uint8_t hash_key[key_len];
2428 struct crypto_testsuite_params *ts_params = &testsuite_params;
2429 struct crypto_unittest_params *ut_params = &unittest_params;
2431 memcpy(hash_key, key, key_len);
2433 debug_hexdump(stdout, "key:", key, key_len);
2435 /* Setup Authentication Parameters */
2436 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2437 ut_params->auth_xform.next = NULL;
2439 ut_params->auth_xform.auth.op = op;
2440 ut_params->auth_xform.auth.algo = algo;
2441 ut_params->auth_xform.auth.key.length = key_len;
2442 ut_params->auth_xform.auth.key.data = hash_key;
2443 ut_params->auth_xform.auth.digest_length = auth_len;
2444 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
2445 ut_params->auth_xform.auth.iv.length = iv_len;
2446 ut_params->sess = rte_cryptodev_sym_session_create(
2447 ts_params->session_mpool);
2449 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2450 &ut_params->auth_xform,
2451 ts_params->session_priv_mpool);
2452 if (status == -ENOTSUP)
2453 return TEST_SKIPPED;
2455 TEST_ASSERT_EQUAL(status, 0, "session init failed");
2456 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2461 create_wireless_algo_cipher_session(uint8_t dev_id,
2462 enum rte_crypto_cipher_operation op,
2463 enum rte_crypto_cipher_algorithm algo,
2464 const uint8_t *key, const uint8_t key_len,
2467 uint8_t cipher_key[key_len];
2469 struct crypto_testsuite_params *ts_params = &testsuite_params;
2470 struct crypto_unittest_params *ut_params = &unittest_params;
2472 memcpy(cipher_key, key, key_len);
2474 /* Setup Cipher Parameters */
2475 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2476 ut_params->cipher_xform.next = NULL;
2478 ut_params->cipher_xform.cipher.algo = algo;
2479 ut_params->cipher_xform.cipher.op = op;
2480 ut_params->cipher_xform.cipher.key.data = cipher_key;
2481 ut_params->cipher_xform.cipher.key.length = key_len;
2482 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2483 ut_params->cipher_xform.cipher.iv.length = iv_len;
2485 debug_hexdump(stdout, "key:", key, key_len);
2487 /* Create Crypto session */
2488 ut_params->sess = rte_cryptodev_sym_session_create(
2489 ts_params->session_mpool);
2491 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2492 &ut_params->cipher_xform,
2493 ts_params->session_priv_mpool);
2494 if (status == -ENOTSUP)
2495 return TEST_SKIPPED;
2497 TEST_ASSERT_EQUAL(status, 0, "session init failed");
2498 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2503 create_wireless_algo_cipher_operation(const uint8_t *iv, uint8_t iv_len,
2504 unsigned int cipher_len,
2505 unsigned int cipher_offset)
2507 struct crypto_testsuite_params *ts_params = &testsuite_params;
2508 struct crypto_unittest_params *ut_params = &unittest_params;
2510 /* Generate Crypto op data structure */
2511 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2512 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2513 TEST_ASSERT_NOT_NULL(ut_params->op,
2514 "Failed to allocate pktmbuf offload");
2516 /* Set crypto operation data parameters */
2517 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2519 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2521 /* set crypto operation source mbuf */
2522 sym_op->m_src = ut_params->ibuf;
2525 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2527 sym_op->cipher.data.length = cipher_len;
2528 sym_op->cipher.data.offset = cipher_offset;
2533 create_wireless_algo_cipher_operation_oop(const uint8_t *iv, uint8_t iv_len,
2534 unsigned int cipher_len,
2535 unsigned int cipher_offset)
2537 struct crypto_testsuite_params *ts_params = &testsuite_params;
2538 struct crypto_unittest_params *ut_params = &unittest_params;
2540 /* Generate Crypto op data structure */
2541 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2542 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2543 TEST_ASSERT_NOT_NULL(ut_params->op,
2544 "Failed to allocate pktmbuf offload");
2546 /* Set crypto operation data parameters */
2547 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2549 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2551 /* set crypto operation source mbuf */
2552 sym_op->m_src = ut_params->ibuf;
2553 sym_op->m_dst = ut_params->obuf;
2556 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2558 sym_op->cipher.data.length = cipher_len;
2559 sym_op->cipher.data.offset = cipher_offset;
2564 create_wireless_algo_cipher_auth_session(uint8_t dev_id,
2565 enum rte_crypto_cipher_operation cipher_op,
2566 enum rte_crypto_auth_operation auth_op,
2567 enum rte_crypto_auth_algorithm auth_algo,
2568 enum rte_crypto_cipher_algorithm cipher_algo,
2569 const uint8_t *key, uint8_t key_len,
2570 uint8_t auth_iv_len, uint8_t auth_len,
2571 uint8_t cipher_iv_len)
2574 uint8_t cipher_auth_key[key_len];
2577 struct crypto_testsuite_params *ts_params = &testsuite_params;
2578 struct crypto_unittest_params *ut_params = &unittest_params;
2580 memcpy(cipher_auth_key, key, key_len);
2582 /* Setup Authentication Parameters */
2583 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2584 ut_params->auth_xform.next = NULL;
2586 ut_params->auth_xform.auth.op = auth_op;
2587 ut_params->auth_xform.auth.algo = auth_algo;
2588 ut_params->auth_xform.auth.key.length = key_len;
2589 /* Hash key = cipher key */
2590 ut_params->auth_xform.auth.key.data = cipher_auth_key;
2591 ut_params->auth_xform.auth.digest_length = auth_len;
2592 /* Auth IV will be after cipher IV */
2593 ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2594 ut_params->auth_xform.auth.iv.length = auth_iv_len;
2596 /* Setup Cipher Parameters */
2597 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2598 ut_params->cipher_xform.next = &ut_params->auth_xform;
2600 ut_params->cipher_xform.cipher.algo = cipher_algo;
2601 ut_params->cipher_xform.cipher.op = cipher_op;
2602 ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2603 ut_params->cipher_xform.cipher.key.length = key_len;
2604 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2605 ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2607 debug_hexdump(stdout, "key:", key, key_len);
2609 /* Create Crypto session*/
2610 ut_params->sess = rte_cryptodev_sym_session_create(
2611 ts_params->session_mpool);
2612 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2614 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2615 &ut_params->cipher_xform,
2616 ts_params->session_priv_mpool);
2617 if (status == -ENOTSUP)
2618 return TEST_SKIPPED;
2620 TEST_ASSERT_EQUAL(status, 0, "session init failed");
2625 create_wireless_cipher_auth_session(uint8_t dev_id,
2626 enum rte_crypto_cipher_operation cipher_op,
2627 enum rte_crypto_auth_operation auth_op,
2628 enum rte_crypto_auth_algorithm auth_algo,
2629 enum rte_crypto_cipher_algorithm cipher_algo,
2630 const struct wireless_test_data *tdata)
2632 const uint8_t key_len = tdata->key.len;
2633 uint8_t cipher_auth_key[key_len];
2636 struct crypto_testsuite_params *ts_params = &testsuite_params;
2637 struct crypto_unittest_params *ut_params = &unittest_params;
2638 const uint8_t *key = tdata->key.data;
2639 const uint8_t auth_len = tdata->digest.len;
2640 uint8_t cipher_iv_len = tdata->cipher_iv.len;
2641 uint8_t auth_iv_len = tdata->auth_iv.len;
2643 memcpy(cipher_auth_key, key, key_len);
2645 /* Setup Authentication Parameters */
2646 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2647 ut_params->auth_xform.next = NULL;
2649 ut_params->auth_xform.auth.op = auth_op;
2650 ut_params->auth_xform.auth.algo = auth_algo;
2651 ut_params->auth_xform.auth.key.length = key_len;
2652 /* Hash key = cipher key */
2653 ut_params->auth_xform.auth.key.data = cipher_auth_key;
2654 ut_params->auth_xform.auth.digest_length = auth_len;
2655 /* Auth IV will be after cipher IV */
2656 ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2657 ut_params->auth_xform.auth.iv.length = auth_iv_len;
2659 /* Setup Cipher Parameters */
2660 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2661 ut_params->cipher_xform.next = &ut_params->auth_xform;
2663 ut_params->cipher_xform.cipher.algo = cipher_algo;
2664 ut_params->cipher_xform.cipher.op = cipher_op;
2665 ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2666 ut_params->cipher_xform.cipher.key.length = key_len;
2667 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2668 ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2671 debug_hexdump(stdout, "key:", key, key_len);
2673 /* Create Crypto session*/
2674 ut_params->sess = rte_cryptodev_sym_session_create(
2675 ts_params->session_mpool);
2677 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2678 &ut_params->cipher_xform,
2679 ts_params->session_priv_mpool);
2680 if (status == -ENOTSUP)
2681 return TEST_SKIPPED;
2683 TEST_ASSERT_EQUAL(status, 0, "session init failed");
2684 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2689 create_zuc_cipher_auth_encrypt_generate_session(uint8_t dev_id,
2690 const struct wireless_test_data *tdata)
2692 return create_wireless_cipher_auth_session(dev_id,
2693 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2694 RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_ZUC_EIA3,
2695 RTE_CRYPTO_CIPHER_ZUC_EEA3, tdata);
2699 create_wireless_algo_auth_cipher_session(uint8_t dev_id,
2700 enum rte_crypto_cipher_operation cipher_op,
2701 enum rte_crypto_auth_operation auth_op,
2702 enum rte_crypto_auth_algorithm auth_algo,
2703 enum rte_crypto_cipher_algorithm cipher_algo,
2704 const uint8_t *key, const uint8_t key_len,
2705 uint8_t auth_iv_len, uint8_t auth_len,
2706 uint8_t cipher_iv_len)
2708 uint8_t auth_cipher_key[key_len];
2710 struct crypto_testsuite_params *ts_params = &testsuite_params;
2711 struct crypto_unittest_params *ut_params = &unittest_params;
2713 memcpy(auth_cipher_key, key, key_len);
2715 /* Setup Authentication Parameters */
2716 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2717 ut_params->auth_xform.auth.op = auth_op;
2718 ut_params->auth_xform.next = &ut_params->cipher_xform;
2719 ut_params->auth_xform.auth.algo = auth_algo;
2720 ut_params->auth_xform.auth.key.length = key_len;
2721 ut_params->auth_xform.auth.key.data = auth_cipher_key;
2722 ut_params->auth_xform.auth.digest_length = auth_len;
2723 /* Auth IV will be after cipher IV */
2724 ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2725 ut_params->auth_xform.auth.iv.length = auth_iv_len;
2727 /* Setup Cipher Parameters */
2728 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2729 ut_params->cipher_xform.next = NULL;
2730 ut_params->cipher_xform.cipher.algo = cipher_algo;
2731 ut_params->cipher_xform.cipher.op = cipher_op;
2732 ut_params->cipher_xform.cipher.key.data = auth_cipher_key;
2733 ut_params->cipher_xform.cipher.key.length = key_len;
2734 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2735 ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2737 debug_hexdump(stdout, "key:", key, key_len);
2739 /* Create Crypto session*/
2740 ut_params->sess = rte_cryptodev_sym_session_create(
2741 ts_params->session_mpool);
2742 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2744 if (cipher_op == RTE_CRYPTO_CIPHER_OP_DECRYPT) {
2745 ut_params->auth_xform.next = NULL;
2746 ut_params->cipher_xform.next = &ut_params->auth_xform;
2747 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2748 &ut_params->cipher_xform,
2749 ts_params->session_priv_mpool);
2752 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2753 &ut_params->auth_xform,
2754 ts_params->session_priv_mpool);
2756 if (status == -ENOTSUP)
2757 return TEST_SKIPPED;
2759 TEST_ASSERT_EQUAL(status, 0, "session init failed");
2765 create_wireless_algo_hash_operation(const uint8_t *auth_tag,
2766 unsigned int auth_tag_len,
2767 const uint8_t *iv, unsigned int iv_len,
2768 unsigned int data_pad_len,
2769 enum rte_crypto_auth_operation op,
2770 unsigned int auth_len, unsigned int auth_offset)
2772 struct crypto_testsuite_params *ts_params = &testsuite_params;
2774 struct crypto_unittest_params *ut_params = &unittest_params;
2776 /* Generate Crypto op data structure */
2777 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2778 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2779 TEST_ASSERT_NOT_NULL(ut_params->op,
2780 "Failed to allocate pktmbuf offload");
2782 /* Set crypto operation data parameters */
2783 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2785 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2787 /* set crypto operation source mbuf */
2788 sym_op->m_src = ut_params->ibuf;
2791 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2794 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2795 ut_params->ibuf, auth_tag_len);
2797 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2798 "no room to append auth tag");
2799 ut_params->digest = sym_op->auth.digest.data;
2800 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2801 ut_params->ibuf, data_pad_len);
2802 if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2803 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2805 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2807 debug_hexdump(stdout, "digest:",
2808 sym_op->auth.digest.data,
2811 sym_op->auth.data.length = auth_len;
2812 sym_op->auth.data.offset = auth_offset;
2818 create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata,
2819 enum rte_crypto_auth_operation op)
2821 struct crypto_testsuite_params *ts_params = &testsuite_params;
2822 struct crypto_unittest_params *ut_params = &unittest_params;
2824 const uint8_t *auth_tag = tdata->digest.data;
2825 const unsigned int auth_tag_len = tdata->digest.len;
2826 unsigned int plaintext_len = ceil_byte_length(tdata->plaintext.len);
2827 unsigned int data_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2829 const uint8_t *cipher_iv = tdata->cipher_iv.data;
2830 const uint8_t cipher_iv_len = tdata->cipher_iv.len;
2831 const uint8_t *auth_iv = tdata->auth_iv.data;
2832 const uint8_t auth_iv_len = tdata->auth_iv.len;
2833 const unsigned int cipher_len = tdata->validCipherLenInBits.len;
2834 const unsigned int auth_len = tdata->validAuthLenInBits.len;
2836 /* Generate Crypto op data structure */
2837 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2838 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2839 TEST_ASSERT_NOT_NULL(ut_params->op,
2840 "Failed to allocate pktmbuf offload");
2841 /* Set crypto operation data parameters */
2842 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2844 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2846 /* set crypto operation source mbuf */
2847 sym_op->m_src = ut_params->ibuf;
2850 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2851 ut_params->ibuf, auth_tag_len);
2853 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2854 "no room to append auth tag");
2855 ut_params->digest = sym_op->auth.digest.data;
2856 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2857 ut_params->ibuf, data_pad_len);
2858 if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2859 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2861 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2863 debug_hexdump(stdout, "digest:",
2864 sym_op->auth.digest.data,
2867 /* Copy cipher and auth IVs at the end of the crypto operation */
2868 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2870 rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2871 iv_ptr += cipher_iv_len;
2872 rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2874 sym_op->cipher.data.length = cipher_len;
2875 sym_op->cipher.data.offset = 0;
2876 sym_op->auth.data.length = auth_len;
2877 sym_op->auth.data.offset = 0;
2883 create_zuc_cipher_hash_generate_operation(
2884 const struct wireless_test_data *tdata)
2886 return create_wireless_cipher_hash_operation(tdata,
2887 RTE_CRYPTO_AUTH_OP_GENERATE);
2891 create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
2892 const unsigned auth_tag_len,
2893 const uint8_t *auth_iv, uint8_t auth_iv_len,
2894 unsigned data_pad_len,
2895 enum rte_crypto_auth_operation op,
2896 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2897 const unsigned cipher_len, const unsigned cipher_offset,
2898 const unsigned auth_len, const unsigned auth_offset)
2900 struct crypto_testsuite_params *ts_params = &testsuite_params;
2901 struct crypto_unittest_params *ut_params = &unittest_params;
2903 enum rte_crypto_cipher_algorithm cipher_algo =
2904 ut_params->cipher_xform.cipher.algo;
2905 enum rte_crypto_auth_algorithm auth_algo =
2906 ut_params->auth_xform.auth.algo;
2908 /* Generate Crypto op data structure */
2909 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2910 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2911 TEST_ASSERT_NOT_NULL(ut_params->op,
2912 "Failed to allocate pktmbuf offload");
2913 /* Set crypto operation data parameters */
2914 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2916 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2918 /* set crypto operation source mbuf */
2919 sym_op->m_src = ut_params->ibuf;
2922 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2923 ut_params->ibuf, auth_tag_len);
2925 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2926 "no room to append auth tag");
2927 ut_params->digest = sym_op->auth.digest.data;
2929 if (rte_pktmbuf_is_contiguous(ut_params->ibuf)) {
2930 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2931 ut_params->ibuf, data_pad_len);
2933 struct rte_mbuf *m = ut_params->ibuf;
2934 unsigned int offset = data_pad_len;
2936 while (offset > m->data_len && m->next != NULL) {
2937 offset -= m->data_len;
2940 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2944 if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2945 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2947 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2949 debug_hexdump(stdout, "digest:",
2950 sym_op->auth.digest.data,
2953 /* Copy cipher and auth IVs at the end of the crypto operation */
2954 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2956 rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2957 iv_ptr += cipher_iv_len;
2958 rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2960 if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
2961 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
2962 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
2963 sym_op->cipher.data.length = cipher_len;
2964 sym_op->cipher.data.offset = cipher_offset;
2966 sym_op->cipher.data.length = cipher_len >> 3;
2967 sym_op->cipher.data.offset = cipher_offset >> 3;
2970 if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
2971 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
2972 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
2973 sym_op->auth.data.length = auth_len;
2974 sym_op->auth.data.offset = auth_offset;
2976 sym_op->auth.data.length = auth_len >> 3;
2977 sym_op->auth.data.offset = auth_offset >> 3;
2984 create_wireless_algo_auth_cipher_operation(
2985 const uint8_t *auth_tag, unsigned int auth_tag_len,
2986 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2987 const uint8_t *auth_iv, uint8_t auth_iv_len,
2988 unsigned int data_pad_len,
2989 unsigned int cipher_len, unsigned int cipher_offset,
2990 unsigned int auth_len, unsigned int auth_offset,
2991 uint8_t op_mode, uint8_t do_sgl, uint8_t verify)
2993 struct crypto_testsuite_params *ts_params = &testsuite_params;
2994 struct crypto_unittest_params *ut_params = &unittest_params;
2996 enum rte_crypto_cipher_algorithm cipher_algo =
2997 ut_params->cipher_xform.cipher.algo;
2998 enum rte_crypto_auth_algorithm auth_algo =
2999 ut_params->auth_xform.auth.algo;
3001 /* Generate Crypto op data structure */
3002 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
3003 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
3004 TEST_ASSERT_NOT_NULL(ut_params->op,
3005 "Failed to allocate pktmbuf offload");
3007 /* Set crypto operation data parameters */
3008 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
3010 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
3012 /* set crypto operation mbufs */
3013 sym_op->m_src = ut_params->ibuf;
3014 if (op_mode == OUT_OF_PLACE)
3015 sym_op->m_dst = ut_params->obuf;
3019 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(
3020 (op_mode == IN_PLACE ?
3021 ut_params->ibuf : ut_params->obuf),
3022 uint8_t *, data_pad_len);
3023 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
3024 (op_mode == IN_PLACE ?
3025 ut_params->ibuf : ut_params->obuf),
3027 memset(sym_op->auth.digest.data, 0, auth_tag_len);
3029 uint16_t remaining_off = (auth_offset >> 3) + (auth_len >> 3);
3030 struct rte_mbuf *sgl_buf = (op_mode == IN_PLACE ?
3031 sym_op->m_src : sym_op->m_dst);
3032 while (remaining_off >= rte_pktmbuf_data_len(sgl_buf)) {
3033 remaining_off -= rte_pktmbuf_data_len(sgl_buf);
3034 sgl_buf = sgl_buf->next;
3036 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(sgl_buf,
3037 uint8_t *, remaining_off);
3038 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(sgl_buf,
3040 memset(sym_op->auth.digest.data, 0, remaining_off);
3041 while (sgl_buf->next != NULL) {
3042 memset(rte_pktmbuf_mtod(sgl_buf, uint8_t *),
3043 0, rte_pktmbuf_data_len(sgl_buf));
3044 sgl_buf = sgl_buf->next;
3048 /* Copy digest for the verification */
3050 memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
3052 /* Copy cipher and auth IVs at the end of the crypto operation */
3053 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(
3054 ut_params->op, uint8_t *, IV_OFFSET);
3056 rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
3057 iv_ptr += cipher_iv_len;
3058 rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
3060 /* Only copy over the offset data needed from src to dst in OOP,
3061 * if the auth and cipher offsets are not aligned
3063 if (op_mode == OUT_OF_PLACE) {
3064 if (cipher_offset > auth_offset)
3066 rte_pktmbuf_mtod_offset(
3068 uint8_t *, auth_offset >> 3),
3069 rte_pktmbuf_mtod_offset(
3071 uint8_t *, auth_offset >> 3),
3072 ((cipher_offset >> 3) - (auth_offset >> 3)));
3075 if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
3076 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
3077 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
3078 sym_op->cipher.data.length = cipher_len;
3079 sym_op->cipher.data.offset = cipher_offset;
3081 sym_op->cipher.data.length = cipher_len >> 3;
3082 sym_op->cipher.data.offset = cipher_offset >> 3;
3085 if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
3086 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
3087 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
3088 sym_op->auth.data.length = auth_len;
3089 sym_op->auth.data.offset = auth_offset;
3091 sym_op->auth.data.length = auth_len >> 3;
3092 sym_op->auth.data.offset = auth_offset >> 3;
3099 test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
3101 struct crypto_testsuite_params *ts_params = &testsuite_params;
3102 struct crypto_unittest_params *ut_params = &unittest_params;
3105 unsigned plaintext_pad_len;
3106 unsigned plaintext_len;
3108 struct rte_cryptodev_info dev_info;
3110 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3111 uint64_t feat_flags = dev_info.feature_flags;
3113 if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
3114 ((tdata->validAuthLenInBits.len % 8) != 0)) {
3115 printf("Device doesn't support NON-Byte Aligned Data.\n");
3116 return TEST_SKIPPED;
3119 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3120 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3121 printf("Device doesn't support RAW data-path APIs.\n");
3122 return TEST_SKIPPED;
3125 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3126 return TEST_SKIPPED;
3128 /* Verify the capabilities */
3129 struct rte_cryptodev_sym_capability_idx cap_idx;
3130 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3131 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
3132 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3134 return TEST_SKIPPED;
3136 /* Create SNOW 3G session */
3137 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3138 tdata->key.data, tdata->key.len,
3139 tdata->auth_iv.len, tdata->digest.len,
3140 RTE_CRYPTO_AUTH_OP_GENERATE,
3141 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
3145 /* alloc mbuf and set payload */
3146 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3148 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3149 rte_pktmbuf_tailroom(ut_params->ibuf));
3151 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3152 /* Append data which is padded to a multiple of */
3153 /* the algorithms block size */
3154 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3155 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3157 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3159 /* Create SNOW 3G operation */
3160 retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
3161 tdata->auth_iv.data, tdata->auth_iv.len,
3162 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3163 tdata->validAuthLenInBits.len,
3168 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3169 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3170 ut_params->op, 0, 1, 1, 0);
3172 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3174 ut_params->obuf = ut_params->op->sym->m_src;
3175 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3176 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3177 + plaintext_pad_len;
3180 TEST_ASSERT_BUFFERS_ARE_EQUAL(
3183 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
3184 "SNOW 3G Generated auth tag not as expected");
3190 test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
3192 struct crypto_testsuite_params *ts_params = &testsuite_params;
3193 struct crypto_unittest_params *ut_params = &unittest_params;
3196 unsigned plaintext_pad_len;
3197 unsigned plaintext_len;
3199 struct rte_cryptodev_info dev_info;
3201 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3202 uint64_t feat_flags = dev_info.feature_flags;
3204 if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
3205 ((tdata->validAuthLenInBits.len % 8) != 0)) {
3206 printf("Device doesn't support NON-Byte Aligned Data.\n");
3207 return TEST_SKIPPED;
3210 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3211 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3212 printf("Device doesn't support RAW data-path APIs.\n");
3213 return TEST_SKIPPED;
3216 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3217 return TEST_SKIPPED;
3219 /* Verify the capabilities */
3220 struct rte_cryptodev_sym_capability_idx cap_idx;
3221 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3222 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
3223 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3225 return TEST_SKIPPED;
3227 /* Create SNOW 3G session */
3228 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3229 tdata->key.data, tdata->key.len,
3230 tdata->auth_iv.len, tdata->digest.len,
3231 RTE_CRYPTO_AUTH_OP_VERIFY,
3232 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
3235 /* alloc mbuf and set payload */
3236 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3238 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3239 rte_pktmbuf_tailroom(ut_params->ibuf));
3241 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3242 /* Append data which is padded to a multiple of */
3243 /* the algorithms block size */
3244 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3245 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3247 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3249 /* Create SNOW 3G operation */
3250 retval = create_wireless_algo_hash_operation(tdata->digest.data,
3252 tdata->auth_iv.data, tdata->auth_iv.len,
3254 RTE_CRYPTO_AUTH_OP_VERIFY,
3255 tdata->validAuthLenInBits.len,
3260 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3261 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3262 ut_params->op, 0, 1, 1, 0);
3264 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3266 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3267 ut_params->obuf = ut_params->op->sym->m_src;
3268 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3269 + plaintext_pad_len;
3272 if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
3281 test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
3283 struct crypto_testsuite_params *ts_params = &testsuite_params;
3284 struct crypto_unittest_params *ut_params = &unittest_params;
3287 unsigned plaintext_pad_len;
3288 unsigned plaintext_len;
3290 struct rte_cryptodev_info dev_info;
3292 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3293 uint64_t feat_flags = dev_info.feature_flags;
3295 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3296 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3297 printf("Device doesn't support RAW data-path APIs.\n");
3298 return TEST_SKIPPED;
3301 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3302 return TEST_SKIPPED;
3304 /* Verify the capabilities */
3305 struct rte_cryptodev_sym_capability_idx cap_idx;
3306 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3307 cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
3308 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3310 return TEST_SKIPPED;
3312 /* Create KASUMI session */
3313 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3314 tdata->key.data, tdata->key.len,
3315 0, tdata->digest.len,
3316 RTE_CRYPTO_AUTH_OP_GENERATE,
3317 RTE_CRYPTO_AUTH_KASUMI_F9);
3321 /* alloc mbuf and set payload */
3322 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3324 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3325 rte_pktmbuf_tailroom(ut_params->ibuf));
3327 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3328 /* Append data which is padded to a multiple of */
3329 /* the algorithms block size */
3330 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3331 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3333 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3335 /* Create KASUMI operation */
3336 retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
3338 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3339 tdata->plaintext.len,
3344 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3345 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
3347 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3348 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3349 ut_params->op, 0, 1, 1, 0);
3351 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3354 ut_params->obuf = ut_params->op->sym->m_src;
3355 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3356 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3357 + plaintext_pad_len;
3360 TEST_ASSERT_BUFFERS_ARE_EQUAL(
3363 DIGEST_BYTE_LENGTH_KASUMI_F9,
3364 "KASUMI Generated auth tag not as expected");
3370 test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
3372 struct crypto_testsuite_params *ts_params = &testsuite_params;
3373 struct crypto_unittest_params *ut_params = &unittest_params;
3376 unsigned plaintext_pad_len;
3377 unsigned plaintext_len;
3379 struct rte_cryptodev_info dev_info;
3381 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3382 uint64_t feat_flags = dev_info.feature_flags;
3384 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3385 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3386 printf("Device doesn't support RAW data-path APIs.\n");
3387 return TEST_SKIPPED;
3390 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3391 return TEST_SKIPPED;
3393 /* Verify the capabilities */
3394 struct rte_cryptodev_sym_capability_idx cap_idx;
3395 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3396 cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
3397 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3399 return TEST_SKIPPED;
3401 /* Create KASUMI session */
3402 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3403 tdata->key.data, tdata->key.len,
3404 0, tdata->digest.len,
3405 RTE_CRYPTO_AUTH_OP_VERIFY,
3406 RTE_CRYPTO_AUTH_KASUMI_F9);
3409 /* alloc mbuf and set payload */
3410 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3412 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3413 rte_pktmbuf_tailroom(ut_params->ibuf));
3415 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3416 /* Append data which is padded to a multiple */
3417 /* of the algorithms block size */
3418 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3419 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3421 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3423 /* Create KASUMI operation */
3424 retval = create_wireless_algo_hash_operation(tdata->digest.data,
3428 RTE_CRYPTO_AUTH_OP_VERIFY,
3429 tdata->plaintext.len,
3434 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3435 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3436 ut_params->op, 0, 1, 1, 0);
3438 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3440 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3441 ut_params->obuf = ut_params->op->sym->m_src;
3442 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3443 + plaintext_pad_len;
3446 if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
3455 test_snow3g_hash_generate_test_case_1(void)
3457 return test_snow3g_authentication(&snow3g_hash_test_case_1);
3461 test_snow3g_hash_generate_test_case_2(void)
3463 return test_snow3g_authentication(&snow3g_hash_test_case_2);
3467 test_snow3g_hash_generate_test_case_3(void)
3469 return test_snow3g_authentication(&snow3g_hash_test_case_3);
3473 test_snow3g_hash_generate_test_case_4(void)
3475 return test_snow3g_authentication(&snow3g_hash_test_case_4);
3479 test_snow3g_hash_generate_test_case_5(void)
3481 return test_snow3g_authentication(&snow3g_hash_test_case_5);
3485 test_snow3g_hash_generate_test_case_6(void)
3487 return test_snow3g_authentication(&snow3g_hash_test_case_6);
3491 test_snow3g_hash_verify_test_case_1(void)
3493 return test_snow3g_authentication_verify(&snow3g_hash_test_case_1);
3498 test_snow3g_hash_verify_test_case_2(void)
3500 return test_snow3g_authentication_verify(&snow3g_hash_test_case_2);
3504 test_snow3g_hash_verify_test_case_3(void)
3506 return test_snow3g_authentication_verify(&snow3g_hash_test_case_3);
3510 test_snow3g_hash_verify_test_case_4(void)
3512 return test_snow3g_authentication_verify(&snow3g_hash_test_case_4);
3516 test_snow3g_hash_verify_test_case_5(void)
3518 return test_snow3g_authentication_verify(&snow3g_hash_test_case_5);
3522 test_snow3g_hash_verify_test_case_6(void)
3524 return test_snow3g_authentication_verify(&snow3g_hash_test_case_6);
3528 test_kasumi_hash_generate_test_case_1(void)
3530 return test_kasumi_authentication(&kasumi_hash_test_case_1);
3534 test_kasumi_hash_generate_test_case_2(void)
3536 return test_kasumi_authentication(&kasumi_hash_test_case_2);
3540 test_kasumi_hash_generate_test_case_3(void)
3542 return test_kasumi_authentication(&kasumi_hash_test_case_3);
3546 test_kasumi_hash_generate_test_case_4(void)
3548 return test_kasumi_authentication(&kasumi_hash_test_case_4);
3552 test_kasumi_hash_generate_test_case_5(void)
3554 return test_kasumi_authentication(&kasumi_hash_test_case_5);
3558 test_kasumi_hash_generate_test_case_6(void)
3560 return test_kasumi_authentication(&kasumi_hash_test_case_6);
3564 test_kasumi_hash_verify_test_case_1(void)
3566 return test_kasumi_authentication_verify(&kasumi_hash_test_case_1);
3570 test_kasumi_hash_verify_test_case_2(void)
3572 return test_kasumi_authentication_verify(&kasumi_hash_test_case_2);
3576 test_kasumi_hash_verify_test_case_3(void)
3578 return test_kasumi_authentication_verify(&kasumi_hash_test_case_3);
3582 test_kasumi_hash_verify_test_case_4(void)
3584 return test_kasumi_authentication_verify(&kasumi_hash_test_case_4);
3588 test_kasumi_hash_verify_test_case_5(void)
3590 return test_kasumi_authentication_verify(&kasumi_hash_test_case_5);
3594 test_kasumi_encryption(const struct kasumi_test_data *tdata)
3596 struct crypto_testsuite_params *ts_params = &testsuite_params;
3597 struct crypto_unittest_params *ut_params = &unittest_params;
3600 uint8_t *plaintext, *ciphertext;
3601 unsigned plaintext_pad_len;
3602 unsigned plaintext_len;
3603 struct rte_cryptodev_info dev_info;
3605 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3606 uint64_t feat_flags = dev_info.feature_flags;
3608 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3609 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3610 printf("Device doesn't support RAW data-path APIs.\n");
3611 return TEST_SKIPPED;
3614 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3615 return TEST_SKIPPED;
3617 /* Verify the capabilities */
3618 struct rte_cryptodev_sym_capability_idx cap_idx;
3619 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3620 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3621 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3623 return TEST_SKIPPED;
3625 /* Create KASUMI session */
3626 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3627 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3628 RTE_CRYPTO_CIPHER_KASUMI_F8,
3629 tdata->key.data, tdata->key.len,
3630 tdata->cipher_iv.len);
3634 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3636 /* Clear mbuf payload */
3637 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3638 rte_pktmbuf_tailroom(ut_params->ibuf));
3640 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3641 /* Append data which is padded to a multiple */
3642 /* of the algorithms block size */
3643 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3644 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3646 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3648 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3650 /* Create KASUMI operation */
3651 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3652 tdata->cipher_iv.len,
3653 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3654 tdata->validCipherOffsetInBits.len);
3658 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3659 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3660 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
3662 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3664 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3666 ut_params->obuf = ut_params->op->sym->m_dst;
3667 if (ut_params->obuf)
3668 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3670 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3672 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3674 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3675 (tdata->validCipherOffsetInBits.len >> 3);
3677 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3679 reference_ciphertext,
3680 tdata->validCipherLenInBits.len,
3681 "KASUMI Ciphertext data not as expected");
3686 test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
3688 struct crypto_testsuite_params *ts_params = &testsuite_params;
3689 struct crypto_unittest_params *ut_params = &unittest_params;
3693 unsigned int plaintext_pad_len;
3694 unsigned int plaintext_len;
3696 uint8_t buffer[10000];
3697 const uint8_t *ciphertext;
3699 struct rte_cryptodev_info dev_info;
3701 /* Verify the capabilities */
3702 struct rte_cryptodev_sym_capability_idx cap_idx;
3703 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3704 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3705 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3707 return TEST_SKIPPED;
3709 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3711 uint64_t feat_flags = dev_info.feature_flags;
3713 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
3714 printf("Device doesn't support in-place scatter-gather. "
3716 return TEST_SKIPPED;
3719 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3720 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3721 printf("Device doesn't support RAW data-path APIs.\n");
3722 return TEST_SKIPPED;
3725 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3726 return TEST_SKIPPED;
3728 /* Create KASUMI session */
3729 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3730 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3731 RTE_CRYPTO_CIPHER_KASUMI_F8,
3732 tdata->key.data, tdata->key.len,
3733 tdata->cipher_iv.len);
3737 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3740 /* Append data which is padded to a multiple */
3741 /* of the algorithms block size */
3742 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3744 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3745 plaintext_pad_len, 10, 0);
3747 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3749 /* Create KASUMI operation */
3750 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3751 tdata->cipher_iv.len,
3752 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3753 tdata->validCipherOffsetInBits.len);
3757 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3758 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3759 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
3761 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3763 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3765 ut_params->obuf = ut_params->op->sym->m_dst;
3767 if (ut_params->obuf)
3768 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3769 plaintext_len, buffer);
3771 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3772 tdata->validCipherOffsetInBits.len >> 3,
3773 plaintext_len, buffer);
3776 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3778 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3779 (tdata->validCipherOffsetInBits.len >> 3);
3781 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3783 reference_ciphertext,
3784 tdata->validCipherLenInBits.len,
3785 "KASUMI Ciphertext data not as expected");
3790 test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
3792 struct crypto_testsuite_params *ts_params = &testsuite_params;
3793 struct crypto_unittest_params *ut_params = &unittest_params;
3796 uint8_t *plaintext, *ciphertext;
3797 unsigned plaintext_pad_len;
3798 unsigned plaintext_len;
3800 /* Verify the capabilities */
3801 struct rte_cryptodev_sym_capability_idx cap_idx;
3802 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3803 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3804 /* Data-path service does not support OOP */
3805 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3807 return TEST_SKIPPED;
3809 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3810 return TEST_SKIPPED;
3812 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3813 return TEST_SKIPPED;
3815 /* Create KASUMI session */
3816 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3817 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3818 RTE_CRYPTO_CIPHER_KASUMI_F8,
3819 tdata->key.data, tdata->key.len,
3820 tdata->cipher_iv.len);
3824 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3825 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3827 /* Clear mbuf payload */
3828 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3829 rte_pktmbuf_tailroom(ut_params->ibuf));
3831 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3832 /* Append data which is padded to a multiple */
3833 /* of the algorithms block size */
3834 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3835 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3837 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3838 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3840 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3842 /* Create KASUMI operation */
3843 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3844 tdata->cipher_iv.len,
3845 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3846 tdata->validCipherOffsetInBits.len);
3850 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3852 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3854 ut_params->obuf = ut_params->op->sym->m_dst;
3855 if (ut_params->obuf)
3856 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3858 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3860 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3862 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3863 (tdata->validCipherOffsetInBits.len >> 3);
3865 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3867 reference_ciphertext,
3868 tdata->validCipherLenInBits.len,
3869 "KASUMI Ciphertext data not as expected");
3874 test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
3876 struct crypto_testsuite_params *ts_params = &testsuite_params;
3877 struct crypto_unittest_params *ut_params = &unittest_params;
3880 unsigned int plaintext_pad_len;
3881 unsigned int plaintext_len;
3883 const uint8_t *ciphertext;
3884 uint8_t buffer[2048];
3886 struct rte_cryptodev_info dev_info;
3888 /* Verify the capabilities */
3889 struct rte_cryptodev_sym_capability_idx cap_idx;
3890 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3891 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3892 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3894 return TEST_SKIPPED;
3896 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3897 return TEST_SKIPPED;
3899 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3900 return TEST_SKIPPED;
3902 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3904 uint64_t feat_flags = dev_info.feature_flags;
3905 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
3906 printf("Device doesn't support out-of-place scatter-gather "
3907 "in both input and output mbufs. "
3909 return TEST_SKIPPED;
3912 /* Create KASUMI session */
3913 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3914 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3915 RTE_CRYPTO_CIPHER_KASUMI_F8,
3916 tdata->key.data, tdata->key.len,
3917 tdata->cipher_iv.len);
3921 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3922 /* Append data which is padded to a multiple */
3923 /* of the algorithms block size */
3924 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3926 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3927 plaintext_pad_len, 10, 0);
3928 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
3929 plaintext_pad_len, 3, 0);
3931 /* Append data which is padded to a multiple */
3932 /* of the algorithms block size */
3933 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3935 /* Create KASUMI operation */
3936 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3937 tdata->cipher_iv.len,
3938 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3939 tdata->validCipherOffsetInBits.len);
3943 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3945 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3947 ut_params->obuf = ut_params->op->sym->m_dst;
3948 if (ut_params->obuf)
3949 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3950 plaintext_pad_len, buffer);
3952 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3953 tdata->validCipherOffsetInBits.len >> 3,
3954 plaintext_pad_len, buffer);
3956 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3957 (tdata->validCipherOffsetInBits.len >> 3);
3959 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3961 reference_ciphertext,
3962 tdata->validCipherLenInBits.len,
3963 "KASUMI Ciphertext data not as expected");
3969 test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
3971 struct crypto_testsuite_params *ts_params = &testsuite_params;
3972 struct crypto_unittest_params *ut_params = &unittest_params;
3975 uint8_t *ciphertext, *plaintext;
3976 unsigned ciphertext_pad_len;
3977 unsigned ciphertext_len;
3979 /* Verify the capabilities */
3980 struct rte_cryptodev_sym_capability_idx cap_idx;
3981 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3982 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3983 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3985 return TEST_SKIPPED;
3987 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3988 return TEST_SKIPPED;
3990 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3991 return TEST_SKIPPED;
3993 /* Create KASUMI session */
3994 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3995 RTE_CRYPTO_CIPHER_OP_DECRYPT,
3996 RTE_CRYPTO_CIPHER_KASUMI_F8,
3997 tdata->key.data, tdata->key.len,
3998 tdata->cipher_iv.len);
4002 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4003 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4005 /* Clear mbuf payload */
4006 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4007 rte_pktmbuf_tailroom(ut_params->ibuf));
4009 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4010 /* Append data which is padded to a multiple */
4011 /* of the algorithms block size */
4012 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
4013 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4014 ciphertext_pad_len);
4015 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4016 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4018 debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4020 /* Create KASUMI operation */
4021 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4022 tdata->cipher_iv.len,
4023 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
4024 tdata->validCipherOffsetInBits.len);
4028 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4030 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4032 ut_params->obuf = ut_params->op->sym->m_dst;
4033 if (ut_params->obuf)
4034 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4036 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
4038 debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4040 const uint8_t *reference_plaintext = tdata->plaintext.data +
4041 (tdata->validCipherOffsetInBits.len >> 3);
4043 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4045 reference_plaintext,
4046 tdata->validCipherLenInBits.len,
4047 "KASUMI Plaintext data not as expected");
4052 test_kasumi_decryption(const struct kasumi_test_data *tdata)
4054 struct crypto_testsuite_params *ts_params = &testsuite_params;
4055 struct crypto_unittest_params *ut_params = &unittest_params;
4058 uint8_t *ciphertext, *plaintext;
4059 unsigned ciphertext_pad_len;
4060 unsigned ciphertext_len;
4061 struct rte_cryptodev_info dev_info;
4063 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4064 uint64_t feat_flags = dev_info.feature_flags;
4066 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4067 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4068 printf("Device doesn't support RAW data-path APIs.\n");
4069 return TEST_SKIPPED;
4072 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4073 return TEST_SKIPPED;
4075 /* Verify the capabilities */
4076 struct rte_cryptodev_sym_capability_idx cap_idx;
4077 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4078 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
4079 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4081 return TEST_SKIPPED;
4083 /* Create KASUMI session */
4084 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4085 RTE_CRYPTO_CIPHER_OP_DECRYPT,
4086 RTE_CRYPTO_CIPHER_KASUMI_F8,
4087 tdata->key.data, tdata->key.len,
4088 tdata->cipher_iv.len);
4092 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4094 /* Clear mbuf payload */
4095 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4096 rte_pktmbuf_tailroom(ut_params->ibuf));
4098 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4099 /* Append data which is padded to a multiple */
4100 /* of the algorithms block size */
4101 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
4102 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4103 ciphertext_pad_len);
4104 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4106 debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4108 /* Create KASUMI operation */
4109 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4110 tdata->cipher_iv.len,
4111 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
4112 tdata->validCipherOffsetInBits.len);
4116 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4117 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4118 ut_params->op, 1, 0, 1, 0);
4120 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4122 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4124 ut_params->obuf = ut_params->op->sym->m_dst;
4125 if (ut_params->obuf)
4126 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4128 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
4130 debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4132 const uint8_t *reference_plaintext = tdata->plaintext.data +
4133 (tdata->validCipherOffsetInBits.len >> 3);
4135 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4137 reference_plaintext,
4138 tdata->validCipherLenInBits.len,
4139 "KASUMI Plaintext data not as expected");
4144 test_snow3g_encryption(const struct snow3g_test_data *tdata)
4146 struct crypto_testsuite_params *ts_params = &testsuite_params;
4147 struct crypto_unittest_params *ut_params = &unittest_params;
4150 uint8_t *plaintext, *ciphertext;
4151 unsigned plaintext_pad_len;
4152 unsigned plaintext_len;
4153 struct rte_cryptodev_info dev_info;
4155 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4156 uint64_t feat_flags = dev_info.feature_flags;
4158 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4159 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4160 printf("Device doesn't support RAW data-path APIs.\n");
4161 return TEST_SKIPPED;
4164 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4165 return TEST_SKIPPED;
4167 /* Verify the capabilities */
4168 struct rte_cryptodev_sym_capability_idx cap_idx;
4169 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4170 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4171 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4173 return TEST_SKIPPED;
4175 /* Create SNOW 3G session */
4176 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4177 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4178 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4179 tdata->key.data, tdata->key.len,
4180 tdata->cipher_iv.len);
4184 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4186 /* Clear mbuf payload */
4187 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4188 rte_pktmbuf_tailroom(ut_params->ibuf));
4190 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4191 /* Append data which is padded to a multiple of */
4192 /* the algorithms block size */
4193 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4194 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4196 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4198 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4200 /* Create SNOW 3G operation */
4201 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4202 tdata->cipher_iv.len,
4203 tdata->validCipherLenInBits.len,
4208 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4209 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4210 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4212 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4214 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4216 ut_params->obuf = ut_params->op->sym->m_dst;
4217 if (ut_params->obuf)
4218 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4220 ciphertext = plaintext;
4222 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4225 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4227 tdata->ciphertext.data,
4228 tdata->validDataLenInBits.len,
4229 "SNOW 3G Ciphertext data not as expected");
4235 test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
4237 struct crypto_testsuite_params *ts_params = &testsuite_params;
4238 struct crypto_unittest_params *ut_params = &unittest_params;
4239 uint8_t *plaintext, *ciphertext;
4242 unsigned plaintext_pad_len;
4243 unsigned plaintext_len;
4244 struct rte_cryptodev_info dev_info;
4246 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4247 uint64_t feat_flags = dev_info.feature_flags;
4249 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4250 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4251 printf("Device does not support RAW data-path APIs.\n");
4255 /* Verify the capabilities */
4256 struct rte_cryptodev_sym_capability_idx cap_idx;
4257 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4258 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4259 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4261 return TEST_SKIPPED;
4263 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4264 return TEST_SKIPPED;
4266 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4267 return TEST_SKIPPED;
4269 /* Create SNOW 3G session */
4270 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4271 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4272 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4273 tdata->key.data, tdata->key.len,
4274 tdata->cipher_iv.len);
4278 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4279 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4281 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4282 "Failed to allocate input buffer in mempool");
4283 TEST_ASSERT_NOT_NULL(ut_params->obuf,
4284 "Failed to allocate output buffer in mempool");
4286 /* Clear mbuf payload */
4287 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4288 rte_pktmbuf_tailroom(ut_params->ibuf));
4290 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4291 /* Append data which is padded to a multiple of */
4292 /* the algorithms block size */
4293 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4294 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4296 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4297 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4299 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4301 /* Create SNOW 3G operation */
4302 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4303 tdata->cipher_iv.len,
4304 tdata->validCipherLenInBits.len,
4309 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4310 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4311 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4313 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4315 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4317 ut_params->obuf = ut_params->op->sym->m_dst;
4318 if (ut_params->obuf)
4319 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4321 ciphertext = plaintext;
4323 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4326 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4328 tdata->ciphertext.data,
4329 tdata->validDataLenInBits.len,
4330 "SNOW 3G Ciphertext data not as expected");
4335 test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
4337 struct crypto_testsuite_params *ts_params = &testsuite_params;
4338 struct crypto_unittest_params *ut_params = &unittest_params;
4341 unsigned int plaintext_pad_len;
4342 unsigned int plaintext_len;
4343 uint8_t buffer[10000];
4344 const uint8_t *ciphertext;
4346 struct rte_cryptodev_info dev_info;
4348 /* Verify the capabilities */
4349 struct rte_cryptodev_sym_capability_idx cap_idx;
4350 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4351 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4352 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4354 return TEST_SKIPPED;
4356 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4357 return TEST_SKIPPED;
4359 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4360 return TEST_SKIPPED;
4362 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4364 uint64_t feat_flags = dev_info.feature_flags;
4366 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
4367 printf("Device doesn't support out-of-place scatter-gather "
4368 "in both input and output mbufs. "
4370 return TEST_SKIPPED;
4373 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4374 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4375 printf("Device does not support RAW data-path APIs.\n");
4379 /* Create SNOW 3G session */
4380 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4381 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4382 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4383 tdata->key.data, tdata->key.len,
4384 tdata->cipher_iv.len);
4388 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4389 /* Append data which is padded to a multiple of */
4390 /* the algorithms block size */
4391 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4393 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
4394 plaintext_pad_len, 10, 0);
4395 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
4396 plaintext_pad_len, 3, 0);
4398 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4399 "Failed to allocate input buffer in mempool");
4400 TEST_ASSERT_NOT_NULL(ut_params->obuf,
4401 "Failed to allocate output buffer in mempool");
4403 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
4405 /* Create SNOW 3G operation */
4406 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4407 tdata->cipher_iv.len,
4408 tdata->validCipherLenInBits.len,
4413 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4414 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4415 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4417 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4419 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4421 ut_params->obuf = ut_params->op->sym->m_dst;
4422 if (ut_params->obuf)
4423 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
4424 plaintext_len, buffer);
4426 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
4427 plaintext_len, buffer);
4429 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4432 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4434 tdata->ciphertext.data,
4435 tdata->validDataLenInBits.len,
4436 "SNOW 3G Ciphertext data not as expected");
4441 /* Shift right a buffer by "offset" bits, "offset" < 8 */
4443 buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset)
4445 uint8_t curr_byte, prev_byte;
4446 uint32_t length_in_bytes = ceil_byte_length(length + offset);
4447 uint8_t lower_byte_mask = (1 << offset) - 1;
4450 prev_byte = buffer[0];
4451 buffer[0] >>= offset;
4453 for (i = 1; i < length_in_bytes; i++) {
4454 curr_byte = buffer[i];
4455 buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) |
4456 (curr_byte >> offset);
4457 prev_byte = curr_byte;
4462 test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
4464 struct crypto_testsuite_params *ts_params = &testsuite_params;
4465 struct crypto_unittest_params *ut_params = &unittest_params;
4466 uint8_t *plaintext, *ciphertext;
4468 uint32_t plaintext_len;
4469 uint32_t plaintext_pad_len;
4470 uint8_t extra_offset = 4;
4471 uint8_t *expected_ciphertext_shifted;
4472 struct rte_cryptodev_info dev_info;
4474 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4475 uint64_t feat_flags = dev_info.feature_flags;
4477 if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
4478 ((tdata->validDataLenInBits.len % 8) != 0)) {
4479 printf("Device doesn't support NON-Byte Aligned Data.\n");
4480 return TEST_SKIPPED;
4483 /* Verify the capabilities */
4484 struct rte_cryptodev_sym_capability_idx cap_idx;
4485 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4486 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4487 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4489 return TEST_SKIPPED;
4491 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4492 return TEST_SKIPPED;
4494 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4495 return TEST_SKIPPED;
4497 /* Create SNOW 3G session */
4498 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4499 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4500 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4501 tdata->key.data, tdata->key.len,
4502 tdata->cipher_iv.len);
4506 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4507 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4509 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4510 "Failed to allocate input buffer in mempool");
4511 TEST_ASSERT_NOT_NULL(ut_params->obuf,
4512 "Failed to allocate output buffer in mempool");
4514 /* Clear mbuf payload */
4515 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4516 rte_pktmbuf_tailroom(ut_params->ibuf));
4518 plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset);
4520 * Append data which is padded to a
4521 * multiple of the algorithms block size
4523 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4525 plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf,
4528 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4530 memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3));
4531 buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset);
4533 #ifdef RTE_APP_TEST_DEBUG
4534 rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
4536 /* Create SNOW 3G operation */
4537 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4538 tdata->cipher_iv.len,
4539 tdata->validCipherLenInBits.len,
4544 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4545 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4546 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4548 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4550 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4552 ut_params->obuf = ut_params->op->sym->m_dst;
4553 if (ut_params->obuf)
4554 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4556 ciphertext = plaintext;
4558 #ifdef RTE_APP_TEST_DEBUG
4559 rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4562 expected_ciphertext_shifted = rte_malloc(NULL, plaintext_len, 8);
4564 TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted,
4565 "failed to reserve memory for ciphertext shifted\n");
4567 memcpy(expected_ciphertext_shifted, tdata->ciphertext.data,
4568 ceil_byte_length(tdata->ciphertext.len));
4569 buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len,
4572 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
4574 expected_ciphertext_shifted,
4575 tdata->validDataLenInBits.len,
4577 "SNOW 3G Ciphertext data not as expected");
4581 static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
4583 struct crypto_testsuite_params *ts_params = &testsuite_params;
4584 struct crypto_unittest_params *ut_params = &unittest_params;
4588 uint8_t *plaintext, *ciphertext;
4589 unsigned ciphertext_pad_len;
4590 unsigned ciphertext_len;
4591 struct rte_cryptodev_info dev_info;
4593 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4594 uint64_t feat_flags = dev_info.feature_flags;
4596 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4597 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4598 printf("Device doesn't support RAW data-path APIs.\n");
4599 return TEST_SKIPPED;
4602 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4603 return TEST_SKIPPED;
4605 /* Verify the capabilities */
4606 struct rte_cryptodev_sym_capability_idx cap_idx;
4607 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4608 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4609 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4611 return TEST_SKIPPED;
4613 /* Create SNOW 3G session */
4614 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4615 RTE_CRYPTO_CIPHER_OP_DECRYPT,
4616 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4617 tdata->key.data, tdata->key.len,
4618 tdata->cipher_iv.len);
4622 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4624 /* Clear mbuf payload */
4625 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4626 rte_pktmbuf_tailroom(ut_params->ibuf));
4628 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4629 /* Append data which is padded to a multiple of */
4630 /* the algorithms block size */
4631 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4632 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4633 ciphertext_pad_len);
4634 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4636 debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4638 /* Create SNOW 3G operation */
4639 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4640 tdata->cipher_iv.len,
4641 tdata->validCipherLenInBits.len,
4642 tdata->cipher.offset_bits);
4646 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4647 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4648 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4650 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4652 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4653 ut_params->obuf = ut_params->op->sym->m_dst;
4654 if (ut_params->obuf)
4655 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4657 plaintext = ciphertext;
4659 debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4662 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4663 tdata->plaintext.data,
4664 tdata->validDataLenInBits.len,
4665 "SNOW 3G Plaintext data not as expected");
4669 static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
4671 struct crypto_testsuite_params *ts_params = &testsuite_params;
4672 struct crypto_unittest_params *ut_params = &unittest_params;
4676 uint8_t *plaintext, *ciphertext;
4677 unsigned ciphertext_pad_len;
4678 unsigned ciphertext_len;
4679 struct rte_cryptodev_info dev_info;
4681 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4682 uint64_t feat_flags = dev_info.feature_flags;
4684 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4685 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4686 printf("Device does not support RAW data-path APIs.\n");
4689 /* Verify the capabilities */
4690 struct rte_cryptodev_sym_capability_idx cap_idx;
4691 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4692 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4693 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4695 return TEST_SKIPPED;
4697 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4698 return TEST_SKIPPED;
4700 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4701 return TEST_SKIPPED;
4703 /* Create SNOW 3G session */
4704 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4705 RTE_CRYPTO_CIPHER_OP_DECRYPT,
4706 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4707 tdata->key.data, tdata->key.len,
4708 tdata->cipher_iv.len);
4712 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4713 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4715 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4716 "Failed to allocate input buffer");
4717 TEST_ASSERT_NOT_NULL(ut_params->obuf,
4718 "Failed to allocate output buffer");
4720 /* Clear mbuf payload */
4721 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4722 rte_pktmbuf_tailroom(ut_params->ibuf));
4724 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
4725 rte_pktmbuf_tailroom(ut_params->obuf));
4727 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4728 /* Append data which is padded to a multiple of */
4729 /* the algorithms block size */
4730 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4731 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4732 ciphertext_pad_len);
4733 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4734 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4736 debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4738 /* Create SNOW 3G operation */
4739 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4740 tdata->cipher_iv.len,
4741 tdata->validCipherLenInBits.len,
4746 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4747 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4748 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4750 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4752 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4753 ut_params->obuf = ut_params->op->sym->m_dst;
4754 if (ut_params->obuf)
4755 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4757 plaintext = ciphertext;
4759 debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4762 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4763 tdata->plaintext.data,
4764 tdata->validDataLenInBits.len,
4765 "SNOW 3G Plaintext data not as expected");
4770 test_zuc_cipher_auth(const struct wireless_test_data *tdata)
4772 struct crypto_testsuite_params *ts_params = &testsuite_params;
4773 struct crypto_unittest_params *ut_params = &unittest_params;
4777 uint8_t *plaintext, *ciphertext;
4778 unsigned int plaintext_pad_len;
4779 unsigned int plaintext_len;
4781 struct rte_cryptodev_info dev_info;
4782 struct rte_cryptodev_sym_capability_idx cap_idx;
4784 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4785 uint64_t feat_flags = dev_info.feature_flags;
4787 if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
4788 ((tdata->validAuthLenInBits.len % 8 != 0) ||
4789 (tdata->validDataLenInBits.len % 8 != 0))) {
4790 printf("Device doesn't support NON-Byte Aligned Data.\n");
4791 return TEST_SKIPPED;
4794 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4795 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4796 printf("Device doesn't support RAW data-path APIs.\n");
4797 return TEST_SKIPPED;
4800 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4801 return TEST_SKIPPED;
4803 /* Check if device supports ZUC EEA3 */
4804 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4805 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
4807 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4809 return TEST_SKIPPED;
4811 /* Check if device supports ZUC EIA3 */
4812 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4813 cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
4815 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4817 return TEST_SKIPPED;
4819 /* Create ZUC session */
4820 retval = create_zuc_cipher_auth_encrypt_generate_session(
4821 ts_params->valid_devs[0],
4825 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4827 /* clear mbuf payload */
4828 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4829 rte_pktmbuf_tailroom(ut_params->ibuf));
4831 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4832 /* Append data which is padded to a multiple of */
4833 /* the algorithms block size */
4834 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4835 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4837 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4839 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4841 /* Create ZUC operation */
4842 retval = create_zuc_cipher_hash_generate_operation(tdata);
4846 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4847 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4848 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4850 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4852 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4853 ut_params->obuf = ut_params->op->sym->m_src;
4854 if (ut_params->obuf)
4855 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4857 ciphertext = plaintext;
4859 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4861 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4863 tdata->ciphertext.data,
4864 tdata->validDataLenInBits.len,
4865 "ZUC Ciphertext data not as expected");
4867 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4868 + plaintext_pad_len;
4871 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4875 "ZUC Generated auth tag not as expected");
4880 test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
4882 struct crypto_testsuite_params *ts_params = &testsuite_params;
4883 struct crypto_unittest_params *ut_params = &unittest_params;
4887 uint8_t *plaintext, *ciphertext;
4888 unsigned plaintext_pad_len;
4889 unsigned plaintext_len;
4890 struct rte_cryptodev_info dev_info;
4892 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4893 uint64_t feat_flags = dev_info.feature_flags;
4895 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4896 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4897 printf("Device doesn't support RAW data-path APIs.\n");
4898 return TEST_SKIPPED;
4901 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4902 return TEST_SKIPPED;
4904 /* Verify the capabilities */
4905 struct rte_cryptodev_sym_capability_idx cap_idx;
4906 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4907 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
4908 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4910 return TEST_SKIPPED;
4911 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4912 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4913 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4915 return TEST_SKIPPED;
4917 /* Create SNOW 3G session */
4918 retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0],
4919 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4920 RTE_CRYPTO_AUTH_OP_GENERATE,
4921 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4922 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4923 tdata->key.data, tdata->key.len,
4924 tdata->auth_iv.len, tdata->digest.len,
4925 tdata->cipher_iv.len);
4928 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4930 /* clear mbuf payload */
4931 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4932 rte_pktmbuf_tailroom(ut_params->ibuf));
4934 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4935 /* Append data which is padded to a multiple of */
4936 /* the algorithms block size */
4937 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4938 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4940 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4942 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4944 /* Create SNOW 3G operation */
4945 retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
4946 tdata->digest.len, tdata->auth_iv.data,
4948 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
4949 tdata->cipher_iv.data, tdata->cipher_iv.len,
4950 tdata->validCipherLenInBits.len,
4952 tdata->validAuthLenInBits.len,
4958 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4959 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4960 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4962 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4964 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4965 ut_params->obuf = ut_params->op->sym->m_src;
4966 if (ut_params->obuf)
4967 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4969 ciphertext = plaintext;
4971 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4973 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4975 tdata->ciphertext.data,
4976 tdata->validDataLenInBits.len,
4977 "SNOW 3G Ciphertext data not as expected");
4979 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4980 + plaintext_pad_len;
4983 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4986 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4987 "SNOW 3G Generated auth tag not as expected");
4992 test_snow3g_auth_cipher(const struct snow3g_test_data *tdata,
4993 uint8_t op_mode, uint8_t verify)
4995 struct crypto_testsuite_params *ts_params = &testsuite_params;
4996 struct crypto_unittest_params *ut_params = &unittest_params;
5000 uint8_t *plaintext = NULL, *ciphertext = NULL;
5001 unsigned int plaintext_pad_len;
5002 unsigned int plaintext_len;
5003 unsigned int ciphertext_pad_len;
5004 unsigned int ciphertext_len;
5006 struct rte_cryptodev_info dev_info;
5008 /* Verify the capabilities */
5009 struct rte_cryptodev_sym_capability_idx cap_idx;
5010 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5011 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
5012 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5014 return TEST_SKIPPED;
5015 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5016 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
5017 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5019 return TEST_SKIPPED;
5021 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5022 return TEST_SKIPPED;
5024 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5026 uint64_t feat_flags = dev_info.feature_flags;
5028 if (op_mode == OUT_OF_PLACE) {
5029 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5030 printf("Device doesn't support digest encrypted.\n");
5031 return TEST_SKIPPED;
5033 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5034 return TEST_SKIPPED;
5037 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5038 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5039 printf("Device doesn't support RAW data-path APIs.\n");
5040 return TEST_SKIPPED;
5043 /* Create SNOW 3G session */
5044 retval = create_wireless_algo_auth_cipher_session(
5045 ts_params->valid_devs[0],
5046 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5047 : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5048 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5049 : RTE_CRYPTO_AUTH_OP_GENERATE),
5050 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
5051 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
5052 tdata->key.data, tdata->key.len,
5053 tdata->auth_iv.len, tdata->digest.len,
5054 tdata->cipher_iv.len);
5058 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5059 if (op_mode == OUT_OF_PLACE)
5060 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5062 /* clear mbuf payload */
5063 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5064 rte_pktmbuf_tailroom(ut_params->ibuf));
5065 if (op_mode == OUT_OF_PLACE)
5066 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5067 rte_pktmbuf_tailroom(ut_params->obuf));
5069 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5070 plaintext_len = ceil_byte_length(tdata->plaintext.len);
5071 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5072 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5075 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5076 ciphertext_pad_len);
5077 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
5078 if (op_mode == OUT_OF_PLACE)
5079 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
5080 debug_hexdump(stdout, "ciphertext:", ciphertext,
5083 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5085 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5086 if (op_mode == OUT_OF_PLACE)
5087 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
5088 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5091 /* Create SNOW 3G operation */
5092 retval = create_wireless_algo_auth_cipher_operation(
5093 tdata->digest.data, tdata->digest.len,
5094 tdata->cipher_iv.data, tdata->cipher_iv.len,
5095 tdata->auth_iv.data, tdata->auth_iv.len,
5096 (tdata->digest.offset_bytes == 0 ?
5097 (verify ? ciphertext_pad_len : plaintext_pad_len)
5098 : tdata->digest.offset_bytes),
5099 tdata->validCipherLenInBits.len,
5100 tdata->cipher.offset_bits,
5101 tdata->validAuthLenInBits.len,
5102 tdata->auth.offset_bits,
5103 op_mode, 0, verify);
5108 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5109 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5110 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5112 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5115 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5117 ut_params->obuf = (op_mode == IN_PLACE ?
5118 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5121 if (ut_params->obuf)
5122 plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5125 plaintext = ciphertext +
5126 (tdata->cipher.offset_bits >> 3);
5128 debug_hexdump(stdout, "plaintext:", plaintext,
5129 (tdata->plaintext.len >> 3) - tdata->digest.len);
5130 debug_hexdump(stdout, "plaintext expected:",
5131 tdata->plaintext.data,
5132 (tdata->plaintext.len >> 3) - tdata->digest.len);
5134 if (ut_params->obuf)
5135 ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5138 ciphertext = plaintext;
5140 debug_hexdump(stdout, "ciphertext:", ciphertext,
5142 debug_hexdump(stdout, "ciphertext expected:",
5143 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5145 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5146 + (tdata->digest.offset_bytes == 0 ?
5147 plaintext_pad_len : tdata->digest.offset_bytes);
5149 debug_hexdump(stdout, "digest:", ut_params->digest,
5151 debug_hexdump(stdout, "digest expected:", tdata->digest.data,
5157 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5159 tdata->plaintext.data,
5160 (tdata->plaintext.len - tdata->cipher.offset_bits -
5161 (tdata->digest.len << 3)),
5162 tdata->cipher.offset_bits,
5163 "SNOW 3G Plaintext data not as expected");
5165 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5167 tdata->ciphertext.data,
5168 (tdata->validDataLenInBits.len -
5169 tdata->cipher.offset_bits),
5170 tdata->cipher.offset_bits,
5171 "SNOW 3G Ciphertext data not as expected");
5173 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5176 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5177 "SNOW 3G Generated auth tag not as expected");
5183 test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata,
5184 uint8_t op_mode, uint8_t verify)
5186 struct crypto_testsuite_params *ts_params = &testsuite_params;
5187 struct crypto_unittest_params *ut_params = &unittest_params;
5191 const uint8_t *plaintext = NULL;
5192 const uint8_t *ciphertext = NULL;
5193 const uint8_t *digest = NULL;
5194 unsigned int plaintext_pad_len;
5195 unsigned int plaintext_len;
5196 unsigned int ciphertext_pad_len;
5197 unsigned int ciphertext_len;
5198 uint8_t buffer[10000];
5199 uint8_t digest_buffer[10000];
5201 struct rte_cryptodev_info dev_info;
5203 /* Verify the capabilities */
5204 struct rte_cryptodev_sym_capability_idx cap_idx;
5205 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5206 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
5207 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5209 return TEST_SKIPPED;
5210 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5211 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
5212 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5214 return TEST_SKIPPED;
5216 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5217 return TEST_SKIPPED;
5219 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5221 uint64_t feat_flags = dev_info.feature_flags;
5223 if (op_mode == IN_PLACE) {
5224 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5225 printf("Device doesn't support in-place scatter-gather "
5226 "in both input and output mbufs.\n");
5227 return TEST_SKIPPED;
5229 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5230 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5231 printf("Device doesn't support RAW data-path APIs.\n");
5232 return TEST_SKIPPED;
5235 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5236 return TEST_SKIPPED;
5237 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5238 printf("Device doesn't support out-of-place scatter-gather "
5239 "in both input and output mbufs.\n");
5240 return TEST_SKIPPED;
5242 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5243 printf("Device doesn't support digest encrypted.\n");
5244 return TEST_SKIPPED;
5248 /* Create SNOW 3G session */
5249 retval = create_wireless_algo_auth_cipher_session(
5250 ts_params->valid_devs[0],
5251 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5252 : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5253 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5254 : RTE_CRYPTO_AUTH_OP_GENERATE),
5255 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
5256 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
5257 tdata->key.data, tdata->key.len,
5258 tdata->auth_iv.len, tdata->digest.len,
5259 tdata->cipher_iv.len);
5264 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5265 plaintext_len = ceil_byte_length(tdata->plaintext.len);
5266 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5267 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5269 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5270 plaintext_pad_len, 15, 0);
5271 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5272 "Failed to allocate input buffer in mempool");
5274 if (op_mode == OUT_OF_PLACE) {
5275 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5276 plaintext_pad_len, 15, 0);
5277 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5278 "Failed to allocate output buffer in mempool");
5282 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
5283 tdata->ciphertext.data);
5284 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5285 ciphertext_len, buffer);
5286 debug_hexdump(stdout, "ciphertext:", ciphertext,
5289 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5290 tdata->plaintext.data);
5291 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5292 plaintext_len, buffer);
5293 debug_hexdump(stdout, "plaintext:", plaintext,
5296 memset(buffer, 0, sizeof(buffer));
5298 /* Create SNOW 3G operation */
5299 retval = create_wireless_algo_auth_cipher_operation(
5300 tdata->digest.data, tdata->digest.len,
5301 tdata->cipher_iv.data, tdata->cipher_iv.len,
5302 tdata->auth_iv.data, tdata->auth_iv.len,
5303 (tdata->digest.offset_bytes == 0 ?
5304 (verify ? ciphertext_pad_len : plaintext_pad_len)
5305 : tdata->digest.offset_bytes),
5306 tdata->validCipherLenInBits.len,
5307 tdata->cipher.offset_bits,
5308 tdata->validAuthLenInBits.len,
5309 tdata->auth.offset_bits,
5310 op_mode, 1, verify);
5315 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5316 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5317 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5319 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5322 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5324 ut_params->obuf = (op_mode == IN_PLACE ?
5325 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5328 if (ut_params->obuf)
5329 plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
5330 plaintext_len, buffer);
5332 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5333 plaintext_len, buffer);
5335 debug_hexdump(stdout, "plaintext:", plaintext,
5336 (tdata->plaintext.len >> 3) - tdata->digest.len);
5337 debug_hexdump(stdout, "plaintext expected:",
5338 tdata->plaintext.data,
5339 (tdata->plaintext.len >> 3) - tdata->digest.len);
5341 if (ut_params->obuf)
5342 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
5343 ciphertext_len, buffer);
5345 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5346 ciphertext_len, buffer);
5348 debug_hexdump(stdout, "ciphertext:", ciphertext,
5350 debug_hexdump(stdout, "ciphertext expected:",
5351 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5353 if (ut_params->obuf)
5354 digest = rte_pktmbuf_read(ut_params->obuf,
5355 (tdata->digest.offset_bytes == 0 ?
5356 plaintext_pad_len : tdata->digest.offset_bytes),
5357 tdata->digest.len, digest_buffer);
5359 digest = rte_pktmbuf_read(ut_params->ibuf,
5360 (tdata->digest.offset_bytes == 0 ?
5361 plaintext_pad_len : tdata->digest.offset_bytes),
5362 tdata->digest.len, digest_buffer);
5364 debug_hexdump(stdout, "digest:", digest,
5366 debug_hexdump(stdout, "digest expected:",
5367 tdata->digest.data, tdata->digest.len);
5372 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5374 tdata->plaintext.data,
5375 (tdata->plaintext.len - tdata->cipher.offset_bits -
5376 (tdata->digest.len << 3)),
5377 tdata->cipher.offset_bits,
5378 "SNOW 3G Plaintext data not as expected");
5380 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5382 tdata->ciphertext.data,
5383 (tdata->validDataLenInBits.len -
5384 tdata->cipher.offset_bits),
5385 tdata->cipher.offset_bits,
5386 "SNOW 3G Ciphertext data not as expected");
5388 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5391 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5392 "SNOW 3G Generated auth tag not as expected");
5398 test_kasumi_auth_cipher(const struct kasumi_test_data *tdata,
5399 uint8_t op_mode, uint8_t verify)
5401 struct crypto_testsuite_params *ts_params = &testsuite_params;
5402 struct crypto_unittest_params *ut_params = &unittest_params;
5406 uint8_t *plaintext = NULL, *ciphertext = NULL;
5407 unsigned int plaintext_pad_len;
5408 unsigned int plaintext_len;
5409 unsigned int ciphertext_pad_len;
5410 unsigned int ciphertext_len;
5412 struct rte_cryptodev_info dev_info;
5414 /* Verify the capabilities */
5415 struct rte_cryptodev_sym_capability_idx cap_idx;
5416 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5417 cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5418 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5420 return TEST_SKIPPED;
5421 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5422 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5423 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5425 return TEST_SKIPPED;
5427 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5429 uint64_t feat_flags = dev_info.feature_flags;
5431 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5432 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5433 printf("Device doesn't support RAW data-path APIs.\n");
5434 return TEST_SKIPPED;
5437 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5438 return TEST_SKIPPED;
5440 if (op_mode == OUT_OF_PLACE) {
5441 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5442 return TEST_SKIPPED;
5443 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5444 printf("Device doesn't support digest encrypted.\n");
5445 return TEST_SKIPPED;
5449 /* Create KASUMI session */
5450 retval = create_wireless_algo_auth_cipher_session(
5451 ts_params->valid_devs[0],
5452 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5453 : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5454 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5455 : RTE_CRYPTO_AUTH_OP_GENERATE),
5456 RTE_CRYPTO_AUTH_KASUMI_F9,
5457 RTE_CRYPTO_CIPHER_KASUMI_F8,
5458 tdata->key.data, tdata->key.len,
5459 0, tdata->digest.len,
5460 tdata->cipher_iv.len);
5465 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5466 if (op_mode == OUT_OF_PLACE)
5467 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5469 /* clear mbuf payload */
5470 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5471 rte_pktmbuf_tailroom(ut_params->ibuf));
5472 if (op_mode == OUT_OF_PLACE)
5473 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5474 rte_pktmbuf_tailroom(ut_params->obuf));
5476 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5477 plaintext_len = ceil_byte_length(tdata->plaintext.len);
5478 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5479 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5482 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5483 ciphertext_pad_len);
5484 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
5485 if (op_mode == OUT_OF_PLACE)
5486 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
5487 debug_hexdump(stdout, "ciphertext:", ciphertext,
5490 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5492 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5493 if (op_mode == OUT_OF_PLACE)
5494 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
5495 debug_hexdump(stdout, "plaintext:", plaintext,
5499 /* Create KASUMI operation */
5500 retval = create_wireless_algo_auth_cipher_operation(
5501 tdata->digest.data, tdata->digest.len,
5502 tdata->cipher_iv.data, tdata->cipher_iv.len,
5504 (tdata->digest.offset_bytes == 0 ?
5505 (verify ? ciphertext_pad_len : plaintext_pad_len)
5506 : tdata->digest.offset_bytes),
5507 tdata->validCipherLenInBits.len,
5508 tdata->validCipherOffsetInBits.len,
5509 tdata->validAuthLenInBits.len,
5511 op_mode, 0, verify);
5516 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5517 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5518 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5520 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5523 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5525 ut_params->obuf = (op_mode == IN_PLACE ?
5526 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5530 if (ut_params->obuf)
5531 plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5534 plaintext = ciphertext;
5536 debug_hexdump(stdout, "plaintext:", plaintext,
5537 (tdata->plaintext.len >> 3) - tdata->digest.len);
5538 debug_hexdump(stdout, "plaintext expected:",
5539 tdata->plaintext.data,
5540 (tdata->plaintext.len >> 3) - tdata->digest.len);
5542 if (ut_params->obuf)
5543 ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5546 ciphertext = plaintext;
5548 debug_hexdump(stdout, "ciphertext:", ciphertext,
5550 debug_hexdump(stdout, "ciphertext expected:",
5551 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5553 ut_params->digest = rte_pktmbuf_mtod(
5554 ut_params->obuf, uint8_t *) +
5555 (tdata->digest.offset_bytes == 0 ?
5556 plaintext_pad_len : tdata->digest.offset_bytes);
5558 debug_hexdump(stdout, "digest:", ut_params->digest,
5560 debug_hexdump(stdout, "digest expected:",
5561 tdata->digest.data, tdata->digest.len);
5566 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5568 tdata->plaintext.data,
5569 tdata->plaintext.len >> 3,
5570 "KASUMI Plaintext data not as expected");
5572 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5574 tdata->ciphertext.data,
5575 tdata->ciphertext.len >> 3,
5576 "KASUMI Ciphertext data not as expected");
5578 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5581 DIGEST_BYTE_LENGTH_KASUMI_F9,
5582 "KASUMI Generated auth tag not as expected");
5588 test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata,
5589 uint8_t op_mode, uint8_t verify)
5591 struct crypto_testsuite_params *ts_params = &testsuite_params;
5592 struct crypto_unittest_params *ut_params = &unittest_params;
5596 const uint8_t *plaintext = NULL;
5597 const uint8_t *ciphertext = NULL;
5598 const uint8_t *digest = NULL;
5599 unsigned int plaintext_pad_len;
5600 unsigned int plaintext_len;
5601 unsigned int ciphertext_pad_len;
5602 unsigned int ciphertext_len;
5603 uint8_t buffer[10000];
5604 uint8_t digest_buffer[10000];
5606 struct rte_cryptodev_info dev_info;
5608 /* Verify the capabilities */
5609 struct rte_cryptodev_sym_capability_idx cap_idx;
5610 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5611 cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5612 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5614 return TEST_SKIPPED;
5615 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5616 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5617 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5619 return TEST_SKIPPED;
5621 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5622 return TEST_SKIPPED;
5624 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5626 uint64_t feat_flags = dev_info.feature_flags;
5628 if (op_mode == IN_PLACE) {
5629 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5630 printf("Device doesn't support in-place scatter-gather "
5631 "in both input and output mbufs.\n");
5632 return TEST_SKIPPED;
5634 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5635 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5636 printf("Device doesn't support RAW data-path APIs.\n");
5637 return TEST_SKIPPED;
5640 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5641 return TEST_SKIPPED;
5642 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5643 printf("Device doesn't support out-of-place scatter-gather "
5644 "in both input and output mbufs.\n");
5645 return TEST_SKIPPED;
5647 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5648 printf("Device doesn't support digest encrypted.\n");
5649 return TEST_SKIPPED;
5653 /* Create KASUMI session */
5654 retval = create_wireless_algo_auth_cipher_session(
5655 ts_params->valid_devs[0],
5656 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5657 : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5658 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5659 : RTE_CRYPTO_AUTH_OP_GENERATE),
5660 RTE_CRYPTO_AUTH_KASUMI_F9,
5661 RTE_CRYPTO_CIPHER_KASUMI_F8,
5662 tdata->key.data, tdata->key.len,
5663 0, tdata->digest.len,
5664 tdata->cipher_iv.len);
5669 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5670 plaintext_len = ceil_byte_length(tdata->plaintext.len);
5671 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5672 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5674 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5675 plaintext_pad_len, 15, 0);
5676 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5677 "Failed to allocate input buffer in mempool");
5679 if (op_mode == OUT_OF_PLACE) {
5680 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5681 plaintext_pad_len, 15, 0);
5682 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5683 "Failed to allocate output buffer in mempool");
5687 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
5688 tdata->ciphertext.data);
5689 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5690 ciphertext_len, buffer);
5691 debug_hexdump(stdout, "ciphertext:", ciphertext,
5694 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5695 tdata->plaintext.data);
5696 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5697 plaintext_len, buffer);
5698 debug_hexdump(stdout, "plaintext:", plaintext,
5701 memset(buffer, 0, sizeof(buffer));
5703 /* Create KASUMI operation */
5704 retval = create_wireless_algo_auth_cipher_operation(
5705 tdata->digest.data, tdata->digest.len,
5706 tdata->cipher_iv.data, tdata->cipher_iv.len,
5708 (tdata->digest.offset_bytes == 0 ?
5709 (verify ? ciphertext_pad_len : plaintext_pad_len)
5710 : tdata->digest.offset_bytes),
5711 tdata->validCipherLenInBits.len,
5712 tdata->validCipherOffsetInBits.len,
5713 tdata->validAuthLenInBits.len,
5715 op_mode, 1, verify);
5720 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5721 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5722 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5724 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5727 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5729 ut_params->obuf = (op_mode == IN_PLACE ?
5730 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5733 if (ut_params->obuf)
5734 plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
5735 plaintext_len, buffer);
5737 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5738 plaintext_len, buffer);
5740 debug_hexdump(stdout, "plaintext:", plaintext,
5741 (tdata->plaintext.len >> 3) - tdata->digest.len);
5742 debug_hexdump(stdout, "plaintext expected:",
5743 tdata->plaintext.data,
5744 (tdata->plaintext.len >> 3) - tdata->digest.len);
5746 if (ut_params->obuf)
5747 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
5748 ciphertext_len, buffer);
5750 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5751 ciphertext_len, buffer);
5753 debug_hexdump(stdout, "ciphertext:", ciphertext,
5755 debug_hexdump(stdout, "ciphertext expected:",
5756 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5758 if (ut_params->obuf)
5759 digest = rte_pktmbuf_read(ut_params->obuf,
5760 (tdata->digest.offset_bytes == 0 ?
5761 plaintext_pad_len : tdata->digest.offset_bytes),
5762 tdata->digest.len, digest_buffer);
5764 digest = rte_pktmbuf_read(ut_params->ibuf,
5765 (tdata->digest.offset_bytes == 0 ?
5766 plaintext_pad_len : tdata->digest.offset_bytes),
5767 tdata->digest.len, digest_buffer);
5769 debug_hexdump(stdout, "digest:", digest,
5771 debug_hexdump(stdout, "digest expected:",
5772 tdata->digest.data, tdata->digest.len);
5777 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5779 tdata->plaintext.data,
5780 tdata->plaintext.len >> 3,
5781 "KASUMI Plaintext data not as expected");
5783 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5785 tdata->ciphertext.data,
5786 tdata->validDataLenInBits.len,
5787 "KASUMI Ciphertext data not as expected");
5789 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5792 DIGEST_BYTE_LENGTH_KASUMI_F9,
5793 "KASUMI Generated auth tag not as expected");
5799 test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
5801 struct crypto_testsuite_params *ts_params = &testsuite_params;
5802 struct crypto_unittest_params *ut_params = &unittest_params;
5806 uint8_t *plaintext, *ciphertext;
5807 unsigned plaintext_pad_len;
5808 unsigned plaintext_len;
5809 struct rte_cryptodev_info dev_info;
5811 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5812 uint64_t feat_flags = dev_info.feature_flags;
5814 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5815 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5816 printf("Device doesn't support RAW data-path APIs.\n");
5817 return TEST_SKIPPED;
5820 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5821 return TEST_SKIPPED;
5823 /* Verify the capabilities */
5824 struct rte_cryptodev_sym_capability_idx cap_idx;
5825 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5826 cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5827 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5829 return TEST_SKIPPED;
5830 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5831 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5832 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5834 return TEST_SKIPPED;
5836 /* Create KASUMI session */
5837 retval = create_wireless_algo_cipher_auth_session(
5838 ts_params->valid_devs[0],
5839 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5840 RTE_CRYPTO_AUTH_OP_GENERATE,
5841 RTE_CRYPTO_AUTH_KASUMI_F9,
5842 RTE_CRYPTO_CIPHER_KASUMI_F8,
5843 tdata->key.data, tdata->key.len,
5844 0, tdata->digest.len,
5845 tdata->cipher_iv.len);
5849 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5851 /* clear mbuf payload */
5852 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5853 rte_pktmbuf_tailroom(ut_params->ibuf));
5855 plaintext_len = ceil_byte_length(tdata->plaintext.len);
5856 /* Append data which is padded to a multiple of */
5857 /* the algorithms block size */
5858 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5859 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5861 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5863 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5865 /* Create KASUMI operation */
5866 retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
5867 tdata->digest.len, NULL, 0,
5868 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
5869 tdata->cipher_iv.data, tdata->cipher_iv.len,
5870 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
5871 tdata->validCipherOffsetInBits.len,
5872 tdata->validAuthLenInBits.len,
5878 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5879 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5880 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5882 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5884 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5886 if (ut_params->op->sym->m_dst)
5887 ut_params->obuf = ut_params->op->sym->m_dst;
5889 ut_params->obuf = ut_params->op->sym->m_src;
5891 ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
5892 tdata->validCipherOffsetInBits.len >> 3);
5894 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5895 + plaintext_pad_len;
5897 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
5898 (tdata->validCipherOffsetInBits.len >> 3);
5900 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5902 reference_ciphertext,
5903 tdata->validCipherLenInBits.len,
5904 "KASUMI Ciphertext data not as expected");
5907 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5910 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5911 "KASUMI Generated auth tag not as expected");
5916 check_cipher_capability(const struct crypto_testsuite_params *ts_params,
5917 const enum rte_crypto_cipher_algorithm cipher_algo,
5918 const uint16_t key_size, const uint16_t iv_size)
5920 struct rte_cryptodev_sym_capability_idx cap_idx;
5921 const struct rte_cryptodev_symmetric_capability *cap;
5923 /* Check if device supports the algorithm */
5924 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5925 cap_idx.algo.cipher = cipher_algo;
5927 cap = rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5933 /* Check if device supports key size and IV size */
5934 if (rte_cryptodev_sym_capability_check_cipher(cap, key_size,
5943 check_auth_capability(const struct crypto_testsuite_params *ts_params,
5944 const enum rte_crypto_auth_algorithm auth_algo,
5945 const uint16_t key_size, const uint16_t iv_size,
5946 const uint16_t tag_size)
5948 struct rte_cryptodev_sym_capability_idx cap_idx;
5949 const struct rte_cryptodev_symmetric_capability *cap;
5951 /* Check if device supports the algorithm */
5952 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5953 cap_idx.algo.auth = auth_algo;
5955 cap = rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5961 /* Check if device supports key size and IV size */
5962 if (rte_cryptodev_sym_capability_check_auth(cap, key_size,
5963 tag_size, iv_size) < 0) {
5971 test_zuc_encryption(const struct wireless_test_data *tdata)
5973 struct crypto_testsuite_params *ts_params = &testsuite_params;
5974 struct crypto_unittest_params *ut_params = &unittest_params;
5977 uint8_t *plaintext, *ciphertext;
5978 unsigned plaintext_pad_len;
5979 unsigned plaintext_len;
5980 struct rte_cryptodev_info dev_info;
5982 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5983 uint64_t feat_flags = dev_info.feature_flags;
5985 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5986 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5987 printf("Device doesn't support RAW data-path APIs.\n");
5988 return TEST_SKIPPED;
5991 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5992 return TEST_SKIPPED;
5994 /* Check if device supports ZUC EEA3 */
5995 if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
5996 tdata->key.len, tdata->cipher_iv.len) < 0)
5997 return TEST_SKIPPED;
5999 /* Create ZUC session */
6000 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
6001 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
6002 RTE_CRYPTO_CIPHER_ZUC_EEA3,
6003 tdata->key.data, tdata->key.len,
6004 tdata->cipher_iv.len);
6008 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6010 /* Clear mbuf payload */
6011 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6012 rte_pktmbuf_tailroom(ut_params->ibuf));
6014 plaintext_len = ceil_byte_length(tdata->plaintext.len);
6015 /* Append data which is padded to a multiple */
6016 /* of the algorithms block size */
6017 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
6018 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6020 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6022 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
6024 /* Create ZUC operation */
6025 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
6026 tdata->cipher_iv.len,
6027 tdata->plaintext.len,
6032 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6033 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6034 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
6036 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6038 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6040 ut_params->obuf = ut_params->op->sym->m_dst;
6041 if (ut_params->obuf)
6042 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
6044 ciphertext = plaintext;
6046 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
6049 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6051 tdata->ciphertext.data,
6052 tdata->validCipherLenInBits.len,
6053 "ZUC Ciphertext data not as expected");
6058 test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
6060 struct crypto_testsuite_params *ts_params = &testsuite_params;
6061 struct crypto_unittest_params *ut_params = &unittest_params;
6065 unsigned int plaintext_pad_len;
6066 unsigned int plaintext_len;
6067 const uint8_t *ciphertext;
6068 uint8_t ciphertext_buffer[2048];
6069 struct rte_cryptodev_info dev_info;
6071 /* Check if device supports ZUC EEA3 */
6072 if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
6073 tdata->key.len, tdata->cipher_iv.len) < 0)
6074 return TEST_SKIPPED;
6076 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
6077 return TEST_SKIPPED;
6079 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6081 uint64_t feat_flags = dev_info.feature_flags;
6083 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6084 printf("Device doesn't support in-place scatter-gather. "
6086 return TEST_SKIPPED;
6089 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6090 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6091 printf("Device doesn't support RAW data-path APIs.\n");
6092 return TEST_SKIPPED;
6095 plaintext_len = ceil_byte_length(tdata->plaintext.len);
6097 /* Append data which is padded to a multiple */
6098 /* of the algorithms block size */
6099 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
6101 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
6102 plaintext_pad_len, 10, 0);
6104 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
6105 tdata->plaintext.data);
6107 /* Create ZUC session */
6108 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
6109 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
6110 RTE_CRYPTO_CIPHER_ZUC_EEA3,
6111 tdata->key.data, tdata->key.len,
6112 tdata->cipher_iv.len);
6116 /* Clear mbuf payload */
6118 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
6120 /* Create ZUC operation */
6121 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
6122 tdata->cipher_iv.len, tdata->plaintext.len,
6127 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6128 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6129 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
6131 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6133 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6135 ut_params->obuf = ut_params->op->sym->m_dst;
6136 if (ut_params->obuf)
6137 ciphertext = rte_pktmbuf_read(ut_params->obuf,
6138 0, plaintext_len, ciphertext_buffer);
6140 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
6141 0, plaintext_len, ciphertext_buffer);
6144 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
6147 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6149 tdata->ciphertext.data,
6150 tdata->validCipherLenInBits.len,
6151 "ZUC Ciphertext data not as expected");
6157 test_zuc_authentication(const struct wireless_test_data *tdata)
6159 struct crypto_testsuite_params *ts_params = &testsuite_params;
6160 struct crypto_unittest_params *ut_params = &unittest_params;
6163 unsigned plaintext_pad_len;
6164 unsigned plaintext_len;
6167 struct rte_cryptodev_info dev_info;
6169 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6170 uint64_t feat_flags = dev_info.feature_flags;
6172 if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
6173 (tdata->validAuthLenInBits.len % 8 != 0)) {
6174 printf("Device doesn't support NON-Byte Aligned Data.\n");
6175 return TEST_SKIPPED;
6178 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6179 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6180 printf("Device doesn't support RAW data-path APIs.\n");
6181 return TEST_SKIPPED;
6184 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
6185 return TEST_SKIPPED;
6187 /* Check if device supports ZUC EIA3 */
6188 if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3,
6189 tdata->key.len, tdata->auth_iv.len,
6190 tdata->digest.len) < 0)
6191 return TEST_SKIPPED;
6193 /* Create ZUC session */
6194 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
6195 tdata->key.data, tdata->key.len,
6196 tdata->auth_iv.len, tdata->digest.len,
6197 RTE_CRYPTO_AUTH_OP_GENERATE,
6198 RTE_CRYPTO_AUTH_ZUC_EIA3);
6202 /* alloc mbuf and set payload */
6203 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6205 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6206 rte_pktmbuf_tailroom(ut_params->ibuf));
6208 plaintext_len = ceil_byte_length(tdata->plaintext.len);
6209 /* Append data which is padded to a multiple of */
6210 /* the algorithms block size */
6211 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
6212 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6214 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6216 /* Create ZUC operation */
6217 retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
6218 tdata->auth_iv.data, tdata->auth_iv.len,
6219 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
6220 tdata->validAuthLenInBits.len,
6225 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6226 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6227 ut_params->op, 0, 1, 1, 0);
6229 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6231 ut_params->obuf = ut_params->op->sym->m_src;
6232 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6233 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
6234 + plaintext_pad_len;
6237 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6241 "ZUC Generated auth tag not as expected");
6247 test_zuc_auth_cipher(const struct wireless_test_data *tdata,
6248 uint8_t op_mode, uint8_t verify)
6250 struct crypto_testsuite_params *ts_params = &testsuite_params;
6251 struct crypto_unittest_params *ut_params = &unittest_params;
6255 uint8_t *plaintext = NULL, *ciphertext = NULL;
6256 unsigned int plaintext_pad_len;
6257 unsigned int plaintext_len;
6258 unsigned int ciphertext_pad_len;
6259 unsigned int ciphertext_len;
6261 struct rte_cryptodev_info dev_info;
6263 /* Check if device supports ZUC EEA3 */
6264 if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
6265 tdata->key.len, tdata->cipher_iv.len) < 0)
6266 return TEST_SKIPPED;
6268 /* Check if device supports ZUC EIA3 */
6269 if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3,
6270 tdata->key.len, tdata->auth_iv.len,
6271 tdata->digest.len) < 0)
6272 return TEST_SKIPPED;
6274 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6276 uint64_t feat_flags = dev_info.feature_flags;
6278 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6279 printf("Device doesn't support digest encrypted.\n");
6280 return TEST_SKIPPED;
6282 if (op_mode == IN_PLACE) {
6283 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6284 printf("Device doesn't support in-place scatter-gather "
6285 "in both input and output mbufs.\n");
6286 return TEST_SKIPPED;
6289 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6290 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6291 printf("Device doesn't support RAW data-path APIs.\n");
6292 return TEST_SKIPPED;
6295 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6296 return TEST_SKIPPED;
6297 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
6298 printf("Device doesn't support out-of-place scatter-gather "
6299 "in both input and output mbufs.\n");
6300 return TEST_SKIPPED;
6304 /* Create ZUC session */
6305 retval = create_wireless_algo_auth_cipher_session(
6306 ts_params->valid_devs[0],
6307 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
6308 : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
6309 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
6310 : RTE_CRYPTO_AUTH_OP_GENERATE),
6311 RTE_CRYPTO_AUTH_ZUC_EIA3,
6312 RTE_CRYPTO_CIPHER_ZUC_EEA3,
6313 tdata->key.data, tdata->key.len,
6314 tdata->auth_iv.len, tdata->digest.len,
6315 tdata->cipher_iv.len);
6320 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6321 if (op_mode == OUT_OF_PLACE)
6322 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6324 /* clear mbuf payload */
6325 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6326 rte_pktmbuf_tailroom(ut_params->ibuf));
6327 if (op_mode == OUT_OF_PLACE)
6328 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
6329 rte_pktmbuf_tailroom(ut_params->obuf));
6331 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
6332 plaintext_len = ceil_byte_length(tdata->plaintext.len);
6333 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6334 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6337 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6338 ciphertext_pad_len);
6339 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
6340 debug_hexdump(stdout, "ciphertext:", ciphertext,
6343 /* make sure enough space to cover partial digest verify case */
6344 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6345 ciphertext_pad_len);
6346 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6347 debug_hexdump(stdout, "plaintext:", plaintext,
6351 if (op_mode == OUT_OF_PLACE)
6352 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
6354 /* Create ZUC operation */
6355 retval = create_wireless_algo_auth_cipher_operation(
6356 tdata->digest.data, tdata->digest.len,
6357 tdata->cipher_iv.data, tdata->cipher_iv.len,
6358 tdata->auth_iv.data, tdata->auth_iv.len,
6359 (tdata->digest.offset_bytes == 0 ?
6360 (verify ? ciphertext_pad_len : plaintext_pad_len)
6361 : tdata->digest.offset_bytes),
6362 tdata->validCipherLenInBits.len,
6363 tdata->validCipherOffsetInBits.len,
6364 tdata->validAuthLenInBits.len,
6366 op_mode, 0, verify);
6371 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6372 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6373 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
6375 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6378 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6380 ut_params->obuf = (op_mode == IN_PLACE ?
6381 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6385 if (ut_params->obuf)
6386 plaintext = rte_pktmbuf_mtod(ut_params->obuf,
6389 plaintext = ciphertext;
6391 debug_hexdump(stdout, "plaintext:", plaintext,
6392 (tdata->plaintext.len >> 3) - tdata->digest.len);
6393 debug_hexdump(stdout, "plaintext expected:",
6394 tdata->plaintext.data,
6395 (tdata->plaintext.len >> 3) - tdata->digest.len);
6397 if (ut_params->obuf)
6398 ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
6401 ciphertext = plaintext;
6403 debug_hexdump(stdout, "ciphertext:", ciphertext,
6405 debug_hexdump(stdout, "ciphertext expected:",
6406 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
6408 ut_params->digest = rte_pktmbuf_mtod(
6409 ut_params->obuf, uint8_t *) +
6410 (tdata->digest.offset_bytes == 0 ?
6411 plaintext_pad_len : tdata->digest.offset_bytes);
6413 debug_hexdump(stdout, "digest:", ut_params->digest,
6415 debug_hexdump(stdout, "digest expected:",
6416 tdata->digest.data, tdata->digest.len);
6421 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6423 tdata->plaintext.data,
6424 tdata->plaintext.len >> 3,
6425 "ZUC Plaintext data not as expected");
6427 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6429 tdata->ciphertext.data,
6430 tdata->ciphertext.len >> 3,
6431 "ZUC Ciphertext data not as expected");
6433 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6436 DIGEST_BYTE_LENGTH_KASUMI_F9,
6437 "ZUC Generated auth tag not as expected");
6443 test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata,
6444 uint8_t op_mode, uint8_t verify)
6446 struct crypto_testsuite_params *ts_params = &testsuite_params;
6447 struct crypto_unittest_params *ut_params = &unittest_params;
6451 const uint8_t *plaintext = NULL;
6452 const uint8_t *ciphertext = NULL;
6453 const uint8_t *digest = NULL;
6454 unsigned int plaintext_pad_len;
6455 unsigned int plaintext_len;
6456 unsigned int ciphertext_pad_len;
6457 unsigned int ciphertext_len;
6458 uint8_t buffer[10000];
6459 uint8_t digest_buffer[10000];
6461 struct rte_cryptodev_info dev_info;
6463 /* Check if device supports ZUC EEA3 */
6464 if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
6465 tdata->key.len, tdata->cipher_iv.len) < 0)
6466 return TEST_SKIPPED;
6468 /* Check if device supports ZUC EIA3 */
6469 if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3,
6470 tdata->key.len, tdata->auth_iv.len,
6471 tdata->digest.len) < 0)
6472 return TEST_SKIPPED;
6474 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6476 uint64_t feat_flags = dev_info.feature_flags;
6478 if (op_mode == IN_PLACE) {
6479 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6480 printf("Device doesn't support in-place scatter-gather "
6481 "in both input and output mbufs.\n");
6482 return TEST_SKIPPED;
6485 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6486 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6487 printf("Device doesn't support RAW data-path APIs.\n");
6488 return TEST_SKIPPED;
6491 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6492 return TEST_SKIPPED;
6493 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
6494 printf("Device doesn't support out-of-place scatter-gather "
6495 "in both input and output mbufs.\n");
6496 return TEST_SKIPPED;
6498 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6499 printf("Device doesn't support digest encrypted.\n");
6500 return TEST_SKIPPED;
6504 /* Create ZUC session */
6505 retval = create_wireless_algo_auth_cipher_session(
6506 ts_params->valid_devs[0],
6507 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
6508 : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
6509 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
6510 : RTE_CRYPTO_AUTH_OP_GENERATE),
6511 RTE_CRYPTO_AUTH_ZUC_EIA3,
6512 RTE_CRYPTO_CIPHER_ZUC_EEA3,
6513 tdata->key.data, tdata->key.len,
6514 tdata->auth_iv.len, tdata->digest.len,
6515 tdata->cipher_iv.len);
6520 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
6521 plaintext_len = ceil_byte_length(tdata->plaintext.len);
6522 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6523 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6525 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
6526 plaintext_pad_len, 15, 0);
6527 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
6528 "Failed to allocate input buffer in mempool");
6530 if (op_mode == OUT_OF_PLACE) {
6531 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
6532 plaintext_pad_len, 15, 0);
6533 TEST_ASSERT_NOT_NULL(ut_params->obuf,
6534 "Failed to allocate output buffer in mempool");
6538 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
6539 tdata->ciphertext.data);
6540 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6541 ciphertext_len, buffer);
6542 debug_hexdump(stdout, "ciphertext:", ciphertext,
6545 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
6546 tdata->plaintext.data);
6547 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6548 plaintext_len, buffer);
6549 debug_hexdump(stdout, "plaintext:", plaintext,
6552 memset(buffer, 0, sizeof(buffer));
6554 /* Create ZUC operation */
6555 retval = create_wireless_algo_auth_cipher_operation(
6556 tdata->digest.data, tdata->digest.len,
6557 tdata->cipher_iv.data, tdata->cipher_iv.len,
6559 (tdata->digest.offset_bytes == 0 ?
6560 (verify ? ciphertext_pad_len : plaintext_pad_len)
6561 : tdata->digest.offset_bytes),
6562 tdata->validCipherLenInBits.len,
6563 tdata->validCipherOffsetInBits.len,
6564 tdata->validAuthLenInBits.len,
6566 op_mode, 1, verify);
6571 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6572 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6573 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
6575 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6578 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6580 ut_params->obuf = (op_mode == IN_PLACE ?
6581 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6584 if (ut_params->obuf)
6585 plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
6586 plaintext_len, buffer);
6588 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6589 plaintext_len, buffer);
6591 debug_hexdump(stdout, "plaintext:", plaintext,
6592 (tdata->plaintext.len >> 3) - tdata->digest.len);
6593 debug_hexdump(stdout, "plaintext expected:",
6594 tdata->plaintext.data,
6595 (tdata->plaintext.len >> 3) - tdata->digest.len);
6597 if (ut_params->obuf)
6598 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
6599 ciphertext_len, buffer);
6601 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6602 ciphertext_len, buffer);
6604 debug_hexdump(stdout, "ciphertext:", ciphertext,
6606 debug_hexdump(stdout, "ciphertext expected:",
6607 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
6609 if (ut_params->obuf)
6610 digest = rte_pktmbuf_read(ut_params->obuf,
6611 (tdata->digest.offset_bytes == 0 ?
6612 plaintext_pad_len : tdata->digest.offset_bytes),
6613 tdata->digest.len, digest_buffer);
6615 digest = rte_pktmbuf_read(ut_params->ibuf,
6616 (tdata->digest.offset_bytes == 0 ?
6617 plaintext_pad_len : tdata->digest.offset_bytes),
6618 tdata->digest.len, digest_buffer);
6620 debug_hexdump(stdout, "digest:", digest,
6622 debug_hexdump(stdout, "digest expected:",
6623 tdata->digest.data, tdata->digest.len);
6628 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6630 tdata->plaintext.data,
6631 tdata->plaintext.len >> 3,
6632 "ZUC Plaintext data not as expected");
6634 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6636 tdata->ciphertext.data,
6637 tdata->validDataLenInBits.len,
6638 "ZUC Ciphertext data not as expected");
6640 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6643 DIGEST_BYTE_LENGTH_KASUMI_F9,
6644 "ZUC Generated auth tag not as expected");
6650 test_kasumi_encryption_test_case_1(void)
6652 return test_kasumi_encryption(&kasumi_test_case_1);
6656 test_kasumi_encryption_test_case_1_sgl(void)
6658 return test_kasumi_encryption_sgl(&kasumi_test_case_1);
6662 test_kasumi_encryption_test_case_1_oop(void)
6664 return test_kasumi_encryption_oop(&kasumi_test_case_1);
6668 test_kasumi_encryption_test_case_1_oop_sgl(void)
6670 return test_kasumi_encryption_oop_sgl(&kasumi_test_case_1);
6674 test_kasumi_encryption_test_case_2(void)
6676 return test_kasumi_encryption(&kasumi_test_case_2);
6680 test_kasumi_encryption_test_case_3(void)
6682 return test_kasumi_encryption(&kasumi_test_case_3);
6686 test_kasumi_encryption_test_case_4(void)
6688 return test_kasumi_encryption(&kasumi_test_case_4);
6692 test_kasumi_encryption_test_case_5(void)
6694 return test_kasumi_encryption(&kasumi_test_case_5);
6698 test_kasumi_decryption_test_case_1(void)
6700 return test_kasumi_decryption(&kasumi_test_case_1);
6704 test_kasumi_decryption_test_case_1_oop(void)
6706 return test_kasumi_decryption_oop(&kasumi_test_case_1);
6710 test_kasumi_decryption_test_case_2(void)
6712 return test_kasumi_decryption(&kasumi_test_case_2);
6716 test_kasumi_decryption_test_case_3(void)
6718 /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6719 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6720 return TEST_SKIPPED;
6721 return test_kasumi_decryption(&kasumi_test_case_3);
6725 test_kasumi_decryption_test_case_4(void)
6727 return test_kasumi_decryption(&kasumi_test_case_4);
6731 test_kasumi_decryption_test_case_5(void)
6733 return test_kasumi_decryption(&kasumi_test_case_5);
6736 test_snow3g_encryption_test_case_1(void)
6738 return test_snow3g_encryption(&snow3g_test_case_1);
6742 test_snow3g_encryption_test_case_1_oop(void)
6744 return test_snow3g_encryption_oop(&snow3g_test_case_1);
6748 test_snow3g_encryption_test_case_1_oop_sgl(void)
6750 return test_snow3g_encryption_oop_sgl(&snow3g_test_case_1);
6755 test_snow3g_encryption_test_case_1_offset_oop(void)
6757 return test_snow3g_encryption_offset_oop(&snow3g_test_case_1);
6761 test_snow3g_encryption_test_case_2(void)
6763 return test_snow3g_encryption(&snow3g_test_case_2);
6767 test_snow3g_encryption_test_case_3(void)
6769 return test_snow3g_encryption(&snow3g_test_case_3);
6773 test_snow3g_encryption_test_case_4(void)
6775 return test_snow3g_encryption(&snow3g_test_case_4);
6779 test_snow3g_encryption_test_case_5(void)
6781 return test_snow3g_encryption(&snow3g_test_case_5);
6785 test_snow3g_decryption_test_case_1(void)
6787 return test_snow3g_decryption(&snow3g_test_case_1);
6791 test_snow3g_decryption_test_case_1_oop(void)
6793 return test_snow3g_decryption_oop(&snow3g_test_case_1);
6797 test_snow3g_decryption_test_case_2(void)
6799 return test_snow3g_decryption(&snow3g_test_case_2);
6803 test_snow3g_decryption_test_case_3(void)
6805 return test_snow3g_decryption(&snow3g_test_case_3);
6809 test_snow3g_decryption_test_case_4(void)
6811 return test_snow3g_decryption(&snow3g_test_case_4);
6815 test_snow3g_decryption_test_case_5(void)
6817 return test_snow3g_decryption(&snow3g_test_case_5);
6821 * Function prepares snow3g_hash_test_data from snow3g_test_data.
6822 * Pattern digest from snow3g_test_data must be allocated as
6823 * 4 last bytes in plaintext.
6826 snow3g_hash_test_vector_setup(const struct snow3g_test_data *pattern,
6827 struct snow3g_hash_test_data *output)
6829 if ((pattern != NULL) && (output != NULL)) {
6830 output->key.len = pattern->key.len;
6832 memcpy(output->key.data,
6833 pattern->key.data, pattern->key.len);
6835 output->auth_iv.len = pattern->auth_iv.len;
6837 memcpy(output->auth_iv.data,
6838 pattern->auth_iv.data, pattern->auth_iv.len);
6840 output->plaintext.len = pattern->plaintext.len;
6842 memcpy(output->plaintext.data,
6843 pattern->plaintext.data, pattern->plaintext.len >> 3);
6845 output->digest.len = pattern->digest.len;
6847 memcpy(output->digest.data,
6848 &pattern->plaintext.data[pattern->digest.offset_bytes],
6849 pattern->digest.len);
6851 output->validAuthLenInBits.len =
6852 pattern->validAuthLenInBits.len;
6857 * Test case verify computed cipher and digest from snow3g_test_case_7 data.
6860 test_snow3g_decryption_with_digest_test_case_1(void)
6862 struct snow3g_hash_test_data snow3g_hash_data;
6863 struct rte_cryptodev_info dev_info;
6864 struct crypto_testsuite_params *ts_params = &testsuite_params;
6866 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6867 uint64_t feat_flags = dev_info.feature_flags;
6869 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6870 printf("Device doesn't support encrypted digest operations.\n");
6871 return TEST_SKIPPED;
6875 * Function prepare data for hash verification test case.
6876 * Digest is allocated in 4 last bytes in plaintext, pattern.
6878 snow3g_hash_test_vector_setup(&snow3g_test_case_7, &snow3g_hash_data);
6880 return test_snow3g_decryption(&snow3g_test_case_7) &
6881 test_snow3g_authentication_verify(&snow3g_hash_data);
6885 test_snow3g_cipher_auth_test_case_1(void)
6887 return test_snow3g_cipher_auth(&snow3g_test_case_3);
6891 test_snow3g_auth_cipher_test_case_1(void)
6893 return test_snow3g_auth_cipher(
6894 &snow3g_auth_cipher_test_case_1, IN_PLACE, 0);
6898 test_snow3g_auth_cipher_test_case_2(void)
6900 return test_snow3g_auth_cipher(
6901 &snow3g_auth_cipher_test_case_2, IN_PLACE, 0);
6905 test_snow3g_auth_cipher_test_case_2_oop(void)
6907 return test_snow3g_auth_cipher(
6908 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
6912 test_snow3g_auth_cipher_part_digest_enc(void)
6914 return test_snow3g_auth_cipher(
6915 &snow3g_auth_cipher_partial_digest_encryption,
6920 test_snow3g_auth_cipher_part_digest_enc_oop(void)
6922 return test_snow3g_auth_cipher(
6923 &snow3g_auth_cipher_partial_digest_encryption,
6928 test_snow3g_auth_cipher_test_case_3_sgl(void)
6930 /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6931 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6932 return TEST_SKIPPED;
6933 return test_snow3g_auth_cipher_sgl(
6934 &snow3g_auth_cipher_test_case_3, IN_PLACE, 0);
6938 test_snow3g_auth_cipher_test_case_3_oop_sgl(void)
6940 return test_snow3g_auth_cipher_sgl(
6941 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 0);
6945 test_snow3g_auth_cipher_part_digest_enc_sgl(void)
6947 /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6948 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6949 return TEST_SKIPPED;
6950 return test_snow3g_auth_cipher_sgl(
6951 &snow3g_auth_cipher_partial_digest_encryption,
6956 test_snow3g_auth_cipher_part_digest_enc_oop_sgl(void)
6958 return test_snow3g_auth_cipher_sgl(
6959 &snow3g_auth_cipher_partial_digest_encryption,
6964 test_snow3g_auth_cipher_verify_test_case_1(void)
6966 return test_snow3g_auth_cipher(
6967 &snow3g_auth_cipher_test_case_1, IN_PLACE, 1);
6971 test_snow3g_auth_cipher_verify_test_case_2(void)
6973 return test_snow3g_auth_cipher(
6974 &snow3g_auth_cipher_test_case_2, IN_PLACE, 1);
6978 test_snow3g_auth_cipher_verify_test_case_2_oop(void)
6980 return test_snow3g_auth_cipher(
6981 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
6985 test_snow3g_auth_cipher_verify_part_digest_enc(void)
6987 return test_snow3g_auth_cipher(
6988 &snow3g_auth_cipher_partial_digest_encryption,
6993 test_snow3g_auth_cipher_verify_part_digest_enc_oop(void)
6995 return test_snow3g_auth_cipher(
6996 &snow3g_auth_cipher_partial_digest_encryption,
7001 test_snow3g_auth_cipher_verify_test_case_3_sgl(void)
7003 return test_snow3g_auth_cipher_sgl(
7004 &snow3g_auth_cipher_test_case_3, IN_PLACE, 1);
7008 test_snow3g_auth_cipher_verify_test_case_3_oop_sgl(void)
7010 return test_snow3g_auth_cipher_sgl(
7011 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 1);
7015 test_snow3g_auth_cipher_verify_part_digest_enc_sgl(void)
7017 return test_snow3g_auth_cipher_sgl(
7018 &snow3g_auth_cipher_partial_digest_encryption,
7023 test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl(void)
7025 return test_snow3g_auth_cipher_sgl(
7026 &snow3g_auth_cipher_partial_digest_encryption,
7031 test_snow3g_auth_cipher_with_digest_test_case_1(void)
7033 return test_snow3g_auth_cipher(
7034 &snow3g_test_case_7, IN_PLACE, 0);
7038 test_kasumi_auth_cipher_test_case_1(void)
7040 return test_kasumi_auth_cipher(
7041 &kasumi_test_case_3, IN_PLACE, 0);
7045 test_kasumi_auth_cipher_test_case_2(void)
7047 return test_kasumi_auth_cipher(
7048 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
7052 test_kasumi_auth_cipher_test_case_2_oop(void)
7054 return test_kasumi_auth_cipher(
7055 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
7059 test_kasumi_auth_cipher_test_case_2_sgl(void)
7061 return test_kasumi_auth_cipher_sgl(
7062 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
7066 test_kasumi_auth_cipher_test_case_2_oop_sgl(void)
7068 return test_kasumi_auth_cipher_sgl(
7069 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
7073 test_kasumi_auth_cipher_verify_test_case_1(void)
7075 return test_kasumi_auth_cipher(
7076 &kasumi_test_case_3, IN_PLACE, 1);
7080 test_kasumi_auth_cipher_verify_test_case_2(void)
7082 return test_kasumi_auth_cipher(
7083 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
7087 test_kasumi_auth_cipher_verify_test_case_2_oop(void)
7089 return test_kasumi_auth_cipher(
7090 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
7094 test_kasumi_auth_cipher_verify_test_case_2_sgl(void)
7096 return test_kasumi_auth_cipher_sgl(
7097 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
7101 test_kasumi_auth_cipher_verify_test_case_2_oop_sgl(void)
7103 return test_kasumi_auth_cipher_sgl(
7104 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
7108 test_kasumi_cipher_auth_test_case_1(void)
7110 return test_kasumi_cipher_auth(&kasumi_test_case_6);
7114 test_zuc_encryption_test_case_1(void)
7116 return test_zuc_encryption(&zuc_test_case_cipher_193b);
7120 test_zuc_encryption_test_case_2(void)
7122 return test_zuc_encryption(&zuc_test_case_cipher_800b);
7126 test_zuc_encryption_test_case_3(void)
7128 return test_zuc_encryption(&zuc_test_case_cipher_1570b);
7132 test_zuc_encryption_test_case_4(void)
7134 return test_zuc_encryption(&zuc_test_case_cipher_2798b);
7138 test_zuc_encryption_test_case_5(void)
7140 return test_zuc_encryption(&zuc_test_case_cipher_4019b);
7144 test_zuc_encryption_test_case_6_sgl(void)
7146 return test_zuc_encryption_sgl(&zuc_test_case_cipher_193b);
7150 test_zuc_hash_generate_test_case_1(void)
7152 return test_zuc_authentication(&zuc_test_case_auth_1b);
7156 test_zuc_hash_generate_test_case_2(void)
7158 return test_zuc_authentication(&zuc_test_case_auth_90b);
7162 test_zuc_hash_generate_test_case_3(void)
7164 return test_zuc_authentication(&zuc_test_case_auth_577b);
7168 test_zuc_hash_generate_test_case_4(void)
7170 return test_zuc_authentication(&zuc_test_case_auth_2079b);
7174 test_zuc_hash_generate_test_case_5(void)
7176 return test_zuc_authentication(&zuc_test_auth_5670b);
7180 test_zuc_hash_generate_test_case_6(void)
7182 return test_zuc_authentication(&zuc_test_case_auth_128b);
7186 test_zuc_hash_generate_test_case_7(void)
7188 return test_zuc_authentication(&zuc_test_case_auth_2080b);
7192 test_zuc_hash_generate_test_case_8(void)
7194 return test_zuc_authentication(&zuc_test_case_auth_584b);
7198 test_zuc_hash_generate_test_case_9(void)
7200 return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_32b);
7204 test_zuc_hash_generate_test_case_10(void)
7206 return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_64b);
7210 test_zuc_hash_generate_test_case_11(void)
7212 return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_128b);
7216 test_zuc_cipher_auth_test_case_1(void)
7218 return test_zuc_cipher_auth(&zuc_test_case_cipher_200b_auth_200b);
7222 test_zuc_cipher_auth_test_case_2(void)
7224 return test_zuc_cipher_auth(&zuc_test_case_cipher_800b_auth_120b);
7228 test_zuc_auth_cipher_test_case_1(void)
7230 return test_zuc_auth_cipher(
7231 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
7235 test_zuc_auth_cipher_test_case_1_oop(void)
7237 return test_zuc_auth_cipher(
7238 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
7242 test_zuc_auth_cipher_test_case_1_sgl(void)
7244 return test_zuc_auth_cipher_sgl(
7245 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
7249 test_zuc_auth_cipher_test_case_1_oop_sgl(void)
7251 return test_zuc_auth_cipher_sgl(
7252 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
7256 test_zuc_auth_cipher_verify_test_case_1(void)
7258 return test_zuc_auth_cipher(
7259 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
7263 test_zuc_auth_cipher_verify_test_case_1_oop(void)
7265 return test_zuc_auth_cipher(
7266 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
7270 test_zuc_auth_cipher_verify_test_case_1_sgl(void)
7272 return test_zuc_auth_cipher_sgl(
7273 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
7277 test_zuc_auth_cipher_verify_test_case_1_oop_sgl(void)
7279 return test_zuc_auth_cipher_sgl(
7280 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
7284 test_zuc256_encryption_test_case_1(void)
7286 return test_zuc_encryption(&zuc256_test_case_cipher_1);
7290 test_zuc256_encryption_test_case_2(void)
7292 return test_zuc_encryption(&zuc256_test_case_cipher_2);
7296 test_zuc256_authentication_test_case_1(void)
7298 return test_zuc_authentication(&zuc256_test_case_auth_1);
7302 test_zuc256_authentication_test_case_2(void)
7304 return test_zuc_authentication(&zuc256_test_case_auth_2);
7308 test_mixed_check_if_unsupported(const struct mixed_cipher_auth_test_data *tdata)
7310 uint8_t dev_id = testsuite_params.valid_devs[0];
7312 struct rte_cryptodev_sym_capability_idx cap_idx;
7314 /* Check if device supports particular cipher algorithm */
7315 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
7316 cap_idx.algo.cipher = tdata->cipher_algo;
7317 if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
7318 return TEST_SKIPPED;
7320 /* Check if device supports particular hash algorithm */
7321 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
7322 cap_idx.algo.auth = tdata->auth_algo;
7323 if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
7324 return TEST_SKIPPED;
7330 test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata,
7331 uint8_t op_mode, uint8_t verify)
7333 struct crypto_testsuite_params *ts_params = &testsuite_params;
7334 struct crypto_unittest_params *ut_params = &unittest_params;
7338 uint8_t *plaintext = NULL, *ciphertext = NULL;
7339 unsigned int plaintext_pad_len;
7340 unsigned int plaintext_len;
7341 unsigned int ciphertext_pad_len;
7342 unsigned int ciphertext_len;
7344 struct rte_cryptodev_info dev_info;
7345 struct rte_crypto_op *op;
7347 /* Check if device supports particular algorithms separately */
7348 if (test_mixed_check_if_unsupported(tdata))
7349 return TEST_SKIPPED;
7350 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
7351 return TEST_SKIPPED;
7353 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
7355 uint64_t feat_flags = dev_info.feature_flags;
7357 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
7358 printf("Device doesn't support digest encrypted.\n");
7359 return TEST_SKIPPED;
7362 /* Create the session */
7364 retval = create_wireless_algo_cipher_auth_session(
7365 ts_params->valid_devs[0],
7366 RTE_CRYPTO_CIPHER_OP_DECRYPT,
7367 RTE_CRYPTO_AUTH_OP_VERIFY,
7370 tdata->auth_key.data, tdata->auth_key.len,
7371 tdata->auth_iv.len, tdata->digest_enc.len,
7372 tdata->cipher_iv.len);
7374 retval = create_wireless_algo_auth_cipher_session(
7375 ts_params->valid_devs[0],
7376 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7377 RTE_CRYPTO_AUTH_OP_GENERATE,
7380 tdata->auth_key.data, tdata->auth_key.len,
7381 tdata->auth_iv.len, tdata->digest_enc.len,
7382 tdata->cipher_iv.len);
7386 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7387 if (op_mode == OUT_OF_PLACE)
7388 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7390 /* clear mbuf payload */
7391 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7392 rte_pktmbuf_tailroom(ut_params->ibuf));
7393 if (op_mode == OUT_OF_PLACE) {
7395 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
7396 rte_pktmbuf_tailroom(ut_params->obuf));
7399 ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
7400 plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
7401 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
7402 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
7405 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7406 ciphertext_pad_len);
7407 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
7408 debug_hexdump(stdout, "ciphertext:", ciphertext,
7411 /* make sure enough space to cover partial digest verify case */
7412 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7413 ciphertext_pad_len);
7414 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
7415 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
7418 if (op_mode == OUT_OF_PLACE)
7419 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
7421 /* Create the operation */
7422 retval = create_wireless_algo_auth_cipher_operation(
7423 tdata->digest_enc.data, tdata->digest_enc.len,
7424 tdata->cipher_iv.data, tdata->cipher_iv.len,
7425 tdata->auth_iv.data, tdata->auth_iv.len,
7426 (tdata->digest_enc.offset == 0 ?
7428 : tdata->digest_enc.offset),
7429 tdata->validCipherLen.len_bits,
7430 tdata->cipher.offset_bits,
7431 tdata->validAuthLen.len_bits,
7432 tdata->auth.offset_bits,
7433 op_mode, 0, verify);
7438 op = process_crypto_request(ts_params->valid_devs[0], ut_params->op);
7440 /* Check if the op failed because the device doesn't */
7441 /* support this particular combination of algorithms */
7442 if (op == NULL && ut_params->op->status ==
7443 RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
7444 printf("Device doesn't support this mixed combination. "
7446 return TEST_SKIPPED;
7450 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
7452 ut_params->obuf = (op_mode == IN_PLACE ?
7453 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
7456 if (ut_params->obuf)
7457 plaintext = rte_pktmbuf_mtod(ut_params->obuf,
7460 plaintext = ciphertext +
7461 (tdata->cipher.offset_bits >> 3);
7463 debug_hexdump(stdout, "plaintext:", plaintext,
7464 tdata->plaintext.len_bits >> 3);
7465 debug_hexdump(stdout, "plaintext expected:",
7466 tdata->plaintext.data,
7467 tdata->plaintext.len_bits >> 3);
7469 if (ut_params->obuf)
7470 ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
7473 ciphertext = plaintext;
7475 debug_hexdump(stdout, "ciphertext:", ciphertext,
7477 debug_hexdump(stdout, "ciphertext expected:",
7478 tdata->ciphertext.data,
7479 tdata->ciphertext.len_bits >> 3);
7481 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
7482 + (tdata->digest_enc.offset == 0 ?
7483 plaintext_pad_len : tdata->digest_enc.offset);
7485 debug_hexdump(stdout, "digest:", ut_params->digest,
7486 tdata->digest_enc.len);
7487 debug_hexdump(stdout, "digest expected:",
7488 tdata->digest_enc.data,
7489 tdata->digest_enc.len);
7493 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7495 tdata->digest_enc.data,
7496 tdata->digest_enc.len,
7497 "Generated auth tag not as expected");
7500 if (tdata->cipher_algo != RTE_CRYPTO_CIPHER_NULL) {
7502 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7504 tdata->plaintext.data,
7505 tdata->plaintext.len_bits >> 3,
7506 "Plaintext data not as expected");
7508 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7510 tdata->ciphertext.data,
7511 tdata->validDataLen.len_bits,
7512 "Ciphertext data not as expected");
7516 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7517 "crypto op processing failed");
7523 test_mixed_auth_cipher_sgl(const struct mixed_cipher_auth_test_data *tdata,
7524 uint8_t op_mode, uint8_t verify)
7526 struct crypto_testsuite_params *ts_params = &testsuite_params;
7527 struct crypto_unittest_params *ut_params = &unittest_params;
7531 const uint8_t *plaintext = NULL;
7532 const uint8_t *ciphertext = NULL;
7533 const uint8_t *digest = NULL;
7534 unsigned int plaintext_pad_len;
7535 unsigned int plaintext_len;
7536 unsigned int ciphertext_pad_len;
7537 unsigned int ciphertext_len;
7538 uint8_t buffer[10000];
7539 uint8_t digest_buffer[10000];
7541 struct rte_cryptodev_info dev_info;
7542 struct rte_crypto_op *op;
7544 /* Check if device supports particular algorithms */
7545 if (test_mixed_check_if_unsupported(tdata))
7546 return TEST_SKIPPED;
7547 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
7548 return TEST_SKIPPED;
7550 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
7552 uint64_t feat_flags = dev_info.feature_flags;
7554 if (op_mode == IN_PLACE) {
7555 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
7556 printf("Device doesn't support in-place scatter-gather "
7557 "in both input and output mbufs.\n");
7558 return TEST_SKIPPED;
7561 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
7562 printf("Device doesn't support out-of-place scatter-gather "
7563 "in both input and output mbufs.\n");
7564 return TEST_SKIPPED;
7566 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
7567 printf("Device doesn't support digest encrypted.\n");
7568 return TEST_SKIPPED;
7572 /* Create the session */
7574 retval = create_wireless_algo_cipher_auth_session(
7575 ts_params->valid_devs[0],
7576 RTE_CRYPTO_CIPHER_OP_DECRYPT,
7577 RTE_CRYPTO_AUTH_OP_VERIFY,
7580 tdata->auth_key.data, tdata->auth_key.len,
7581 tdata->auth_iv.len, tdata->digest_enc.len,
7582 tdata->cipher_iv.len);
7584 retval = create_wireless_algo_auth_cipher_session(
7585 ts_params->valid_devs[0],
7586 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7587 RTE_CRYPTO_AUTH_OP_GENERATE,
7590 tdata->auth_key.data, tdata->auth_key.len,
7591 tdata->auth_iv.len, tdata->digest_enc.len,
7592 tdata->cipher_iv.len);
7596 ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
7597 plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
7598 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
7599 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
7601 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
7602 ciphertext_pad_len, 15, 0);
7603 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
7604 "Failed to allocate input buffer in mempool");
7606 if (op_mode == OUT_OF_PLACE) {
7607 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
7608 plaintext_pad_len, 15, 0);
7609 TEST_ASSERT_NOT_NULL(ut_params->obuf,
7610 "Failed to allocate output buffer in mempool");
7614 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
7615 tdata->ciphertext.data);
7616 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
7617 ciphertext_len, buffer);
7618 debug_hexdump(stdout, "ciphertext:", ciphertext,
7621 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
7622 tdata->plaintext.data);
7623 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
7624 plaintext_len, buffer);
7625 debug_hexdump(stdout, "plaintext:", plaintext,
7628 memset(buffer, 0, sizeof(buffer));
7630 /* Create the operation */
7631 retval = create_wireless_algo_auth_cipher_operation(
7632 tdata->digest_enc.data, tdata->digest_enc.len,
7633 tdata->cipher_iv.data, tdata->cipher_iv.len,
7634 tdata->auth_iv.data, tdata->auth_iv.len,
7635 (tdata->digest_enc.offset == 0 ?
7637 : tdata->digest_enc.offset),
7638 tdata->validCipherLen.len_bits,
7639 tdata->cipher.offset_bits,
7640 tdata->validAuthLen.len_bits,
7641 tdata->auth.offset_bits,
7642 op_mode, 1, verify);
7647 op = process_crypto_request(ts_params->valid_devs[0], ut_params->op);
7649 /* Check if the op failed because the device doesn't */
7650 /* support this particular combination of algorithms */
7651 if (op == NULL && ut_params->op->status ==
7652 RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
7653 printf("Device doesn't support this mixed combination. "
7655 return TEST_SKIPPED;
7659 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
7661 ut_params->obuf = (op_mode == IN_PLACE ?
7662 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
7665 if (ut_params->obuf)
7666 plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
7667 plaintext_len, buffer);
7669 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
7670 plaintext_len, buffer);
7672 debug_hexdump(stdout, "plaintext:", plaintext,
7673 (tdata->plaintext.len_bits >> 3) -
7674 tdata->digest_enc.len);
7675 debug_hexdump(stdout, "plaintext expected:",
7676 tdata->plaintext.data,
7677 (tdata->plaintext.len_bits >> 3) -
7678 tdata->digest_enc.len);
7680 if (ut_params->obuf)
7681 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
7682 ciphertext_len, buffer);
7684 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
7685 ciphertext_len, buffer);
7687 debug_hexdump(stdout, "ciphertext:", ciphertext,
7689 debug_hexdump(stdout, "ciphertext expected:",
7690 tdata->ciphertext.data,
7691 tdata->ciphertext.len_bits >> 3);
7693 if (ut_params->obuf)
7694 digest = rte_pktmbuf_read(ut_params->obuf,
7695 (tdata->digest_enc.offset == 0 ?
7697 tdata->digest_enc.offset),
7698 tdata->digest_enc.len, digest_buffer);
7700 digest = rte_pktmbuf_read(ut_params->ibuf,
7701 (tdata->digest_enc.offset == 0 ?
7703 tdata->digest_enc.offset),
7704 tdata->digest_enc.len, digest_buffer);
7706 debug_hexdump(stdout, "digest:", digest,
7707 tdata->digest_enc.len);
7708 debug_hexdump(stdout, "digest expected:",
7709 tdata->digest_enc.data, tdata->digest_enc.len);
7713 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7715 tdata->digest_enc.data,
7716 tdata->digest_enc.len,
7717 "Generated auth tag not as expected");
7720 if (tdata->cipher_algo != RTE_CRYPTO_CIPHER_NULL) {
7722 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7724 tdata->plaintext.data,
7725 tdata->plaintext.len_bits >> 3,
7726 "Plaintext data not as expected");
7728 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7730 tdata->ciphertext.data,
7731 tdata->validDataLen.len_bits,
7732 "Ciphertext data not as expected");
7736 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7737 "crypto op processing failed");
7742 /** AUTH AES CMAC + CIPHER AES CTR */
7745 test_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7747 return test_mixed_auth_cipher(
7748 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7752 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7754 return test_mixed_auth_cipher(
7755 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7759 test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7761 return test_mixed_auth_cipher_sgl(
7762 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7766 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7768 return test_mixed_auth_cipher_sgl(
7769 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7773 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7775 return test_mixed_auth_cipher(
7776 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7780 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7782 return test_mixed_auth_cipher(
7783 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7787 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7789 return test_mixed_auth_cipher_sgl(
7790 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7794 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7796 return test_mixed_auth_cipher_sgl(
7797 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7800 /** MIXED AUTH + CIPHER */
7803 test_auth_zuc_cipher_snow_test_case_1(void)
7805 return test_mixed_auth_cipher(
7806 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7810 test_verify_auth_zuc_cipher_snow_test_case_1(void)
7812 return test_mixed_auth_cipher(
7813 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7817 test_auth_aes_cmac_cipher_snow_test_case_1(void)
7819 return test_mixed_auth_cipher(
7820 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7824 test_verify_auth_aes_cmac_cipher_snow_test_case_1(void)
7826 return test_mixed_auth_cipher(
7827 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7831 test_auth_zuc_cipher_aes_ctr_test_case_1(void)
7833 return test_mixed_auth_cipher(
7834 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7838 test_verify_auth_zuc_cipher_aes_ctr_test_case_1(void)
7840 return test_mixed_auth_cipher(
7841 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7845 test_auth_snow_cipher_aes_ctr_test_case_1(void)
7847 return test_mixed_auth_cipher(
7848 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7852 test_verify_auth_snow_cipher_aes_ctr_test_case_1(void)
7854 return test_mixed_auth_cipher(
7855 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7859 test_auth_snow_cipher_zuc_test_case_1(void)
7861 return test_mixed_auth_cipher(
7862 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7866 test_verify_auth_snow_cipher_zuc_test_case_1(void)
7868 return test_mixed_auth_cipher(
7869 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7873 test_auth_aes_cmac_cipher_zuc_test_case_1(void)
7875 return test_mixed_auth_cipher(
7876 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7880 test_verify_auth_aes_cmac_cipher_zuc_test_case_1(void)
7882 return test_mixed_auth_cipher(
7883 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7887 test_auth_null_cipher_snow_test_case_1(void)
7889 return test_mixed_auth_cipher(
7890 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7894 test_verify_auth_null_cipher_snow_test_case_1(void)
7896 return test_mixed_auth_cipher(
7897 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7901 test_auth_null_cipher_zuc_test_case_1(void)
7903 return test_mixed_auth_cipher(
7904 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7908 test_verify_auth_null_cipher_zuc_test_case_1(void)
7910 return test_mixed_auth_cipher(
7911 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7915 test_auth_snow_cipher_null_test_case_1(void)
7917 return test_mixed_auth_cipher(
7918 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7922 test_verify_auth_snow_cipher_null_test_case_1(void)
7924 return test_mixed_auth_cipher(
7925 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7929 test_auth_zuc_cipher_null_test_case_1(void)
7931 return test_mixed_auth_cipher(
7932 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7936 test_verify_auth_zuc_cipher_null_test_case_1(void)
7938 return test_mixed_auth_cipher(
7939 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7943 test_auth_null_cipher_aes_ctr_test_case_1(void)
7945 return test_mixed_auth_cipher(
7946 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7950 test_verify_auth_null_cipher_aes_ctr_test_case_1(void)
7952 return test_mixed_auth_cipher(
7953 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7957 test_auth_aes_cmac_cipher_null_test_case_1(void)
7959 return test_mixed_auth_cipher(
7960 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7964 test_verify_auth_aes_cmac_cipher_null_test_case_1(void)
7966 return test_mixed_auth_cipher(
7967 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7970 /* ***** AEAD algorithm Tests ***** */
7973 create_aead_session(uint8_t dev_id, enum rte_crypto_aead_algorithm algo,
7974 enum rte_crypto_aead_operation op,
7975 const uint8_t *key, const uint8_t key_len,
7976 const uint16_t aad_len, const uint8_t auth_len,
7979 uint8_t aead_key[key_len];
7982 struct crypto_testsuite_params *ts_params = &testsuite_params;
7983 struct crypto_unittest_params *ut_params = &unittest_params;
7985 memcpy(aead_key, key, key_len);
7987 /* Setup AEAD Parameters */
7988 ut_params->aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD;
7989 ut_params->aead_xform.next = NULL;
7990 ut_params->aead_xform.aead.algo = algo;
7991 ut_params->aead_xform.aead.op = op;
7992 ut_params->aead_xform.aead.key.data = aead_key;
7993 ut_params->aead_xform.aead.key.length = key_len;
7994 ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
7995 ut_params->aead_xform.aead.iv.length = iv_len;
7996 ut_params->aead_xform.aead.digest_length = auth_len;
7997 ut_params->aead_xform.aead.aad_length = aad_len;
7999 debug_hexdump(stdout, "key:", key, key_len);
8001 /* Create Crypto session*/
8002 ut_params->sess = rte_cryptodev_sym_session_create(
8003 ts_params->session_mpool);
8004 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
8006 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
8007 &ut_params->aead_xform,
8008 ts_params->session_priv_mpool);
8014 create_aead_xform(struct rte_crypto_op *op,
8015 enum rte_crypto_aead_algorithm algo,
8016 enum rte_crypto_aead_operation aead_op,
8017 uint8_t *key, const uint8_t key_len,
8018 const uint8_t aad_len, const uint8_t auth_len,
8021 TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 1),
8022 "failed to allocate space for crypto transform");
8024 struct rte_crypto_sym_op *sym_op = op->sym;
8026 /* Setup AEAD Parameters */
8027 sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_AEAD;
8028 sym_op->xform->next = NULL;
8029 sym_op->xform->aead.algo = algo;
8030 sym_op->xform->aead.op = aead_op;
8031 sym_op->xform->aead.key.data = key;
8032 sym_op->xform->aead.key.length = key_len;
8033 sym_op->xform->aead.iv.offset = IV_OFFSET;
8034 sym_op->xform->aead.iv.length = iv_len;
8035 sym_op->xform->aead.digest_length = auth_len;
8036 sym_op->xform->aead.aad_length = aad_len;
8038 debug_hexdump(stdout, "key:", key, key_len);
8044 create_aead_operation(enum rte_crypto_aead_operation op,
8045 const struct aead_test_data *tdata)
8047 struct crypto_testsuite_params *ts_params = &testsuite_params;
8048 struct crypto_unittest_params *ut_params = &unittest_params;
8050 uint8_t *plaintext, *ciphertext;
8051 unsigned int aad_pad_len, plaintext_pad_len;
8053 /* Generate Crypto op data structure */
8054 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8055 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8056 TEST_ASSERT_NOT_NULL(ut_params->op,
8057 "Failed to allocate symmetric crypto operation struct");
8059 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
8061 /* Append aad data */
8062 if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
8063 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len + 18, 16);
8064 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8066 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
8067 "no room to append aad");
8069 sym_op->aead.aad.phys_addr =
8070 rte_pktmbuf_iova(ut_params->ibuf);
8071 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
8072 memcpy(sym_op->aead.aad.data + 18, tdata->aad.data, tdata->aad.len);
8073 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
8076 /* Append IV at the end of the crypto operation*/
8077 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
8078 uint8_t *, IV_OFFSET);
8080 /* Copy IV 1 byte after the IV pointer, according to the API */
8081 rte_memcpy(iv_ptr + 1, tdata->iv.data, tdata->iv.len);
8082 debug_hexdump(stdout, "iv:", iv_ptr,
8085 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
8086 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8088 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
8089 "no room to append aad");
8091 sym_op->aead.aad.phys_addr =
8092 rte_pktmbuf_iova(ut_params->ibuf);
8093 memcpy(sym_op->aead.aad.data, tdata->aad.data, tdata->aad.len);
8094 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
8097 /* Append IV at the end of the crypto operation*/
8098 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
8099 uint8_t *, IV_OFFSET);
8101 if (tdata->iv.len == 0) {
8102 rte_memcpy(iv_ptr, tdata->iv.data, AES_GCM_J0_LENGTH);
8103 debug_hexdump(stdout, "iv:", iv_ptr,
8106 rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
8107 debug_hexdump(stdout, "iv:", iv_ptr,
8112 /* Append plaintext/ciphertext */
8113 if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
8114 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
8115 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8117 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
8119 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
8120 debug_hexdump(stdout, "plaintext:", plaintext,
8121 tdata->plaintext.len);
8123 if (ut_params->obuf) {
8124 ciphertext = (uint8_t *)rte_pktmbuf_append(
8126 plaintext_pad_len + aad_pad_len);
8127 TEST_ASSERT_NOT_NULL(ciphertext,
8128 "no room to append ciphertext");
8130 memset(ciphertext + aad_pad_len, 0,
8131 tdata->ciphertext.len);
8134 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16);
8135 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8137 TEST_ASSERT_NOT_NULL(ciphertext,
8138 "no room to append ciphertext");
8140 memcpy(ciphertext, tdata->ciphertext.data,
8141 tdata->ciphertext.len);
8142 debug_hexdump(stdout, "ciphertext:", ciphertext,
8143 tdata->ciphertext.len);
8145 if (ut_params->obuf) {
8146 plaintext = (uint8_t *)rte_pktmbuf_append(
8148 plaintext_pad_len + aad_pad_len);
8149 TEST_ASSERT_NOT_NULL(plaintext,
8150 "no room to append plaintext");
8152 memset(plaintext + aad_pad_len, 0,
8153 tdata->plaintext.len);
8157 /* Append digest data */
8158 if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
8159 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
8160 ut_params->obuf ? ut_params->obuf :
8162 tdata->auth_tag.len);
8163 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
8164 "no room to append digest");
8165 memset(sym_op->aead.digest.data, 0, tdata->auth_tag.len);
8166 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
8167 ut_params->obuf ? ut_params->obuf :
8172 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
8173 ut_params->ibuf, tdata->auth_tag.len);
8174 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
8175 "no room to append digest");
8176 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
8178 plaintext_pad_len + aad_pad_len);
8180 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
8181 tdata->auth_tag.len);
8182 debug_hexdump(stdout, "digest:",
8183 sym_op->aead.digest.data,
8184 tdata->auth_tag.len);
8187 sym_op->aead.data.length = tdata->plaintext.len;
8188 sym_op->aead.data.offset = aad_pad_len;
8194 test_authenticated_encryption(const struct aead_test_data *tdata)
8196 struct crypto_testsuite_params *ts_params = &testsuite_params;
8197 struct crypto_unittest_params *ut_params = &unittest_params;
8200 uint8_t *ciphertext, *auth_tag;
8201 uint16_t plaintext_pad_len;
8203 struct rte_cryptodev_info dev_info;
8205 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8206 uint64_t feat_flags = dev_info.feature_flags;
8208 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
8209 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
8210 printf("Device doesn't support RAW data-path APIs.\n");
8211 return TEST_SKIPPED;
8214 /* Verify the capabilities */
8215 struct rte_cryptodev_sym_capability_idx cap_idx;
8216 const struct rte_cryptodev_symmetric_capability *capability;
8217 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
8218 cap_idx.algo.aead = tdata->algo;
8219 capability = rte_cryptodev_sym_capability_get(
8220 ts_params->valid_devs[0], &cap_idx);
8221 if (capability == NULL)
8222 return TEST_SKIPPED;
8223 if (rte_cryptodev_sym_capability_check_aead(
8224 capability, tdata->key.len, tdata->auth_tag.len,
8225 tdata->aad.len, tdata->iv.len))
8226 return TEST_SKIPPED;
8228 /* Create AEAD session */
8229 retval = create_aead_session(ts_params->valid_devs[0],
8231 RTE_CRYPTO_AEAD_OP_ENCRYPT,
8232 tdata->key.data, tdata->key.len,
8233 tdata->aad.len, tdata->auth_tag.len,
8238 if (tdata->aad.len > MBUF_SIZE) {
8239 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
8240 /* Populate full size of add data */
8241 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
8242 memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
8244 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8246 /* clear mbuf payload */
8247 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8248 rte_pktmbuf_tailroom(ut_params->ibuf));
8250 /* Create AEAD operation */
8251 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
8255 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
8257 ut_params->op->sym->m_src = ut_params->ibuf;
8259 /* Process crypto operation */
8260 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
8261 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
8262 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
8263 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
8264 ut_params->op, 0, 0, 0, 0);
8266 TEST_ASSERT_NOT_NULL(
8267 process_crypto_request(ts_params->valid_devs[0],
8268 ut_params->op), "failed to process sym crypto op");
8270 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8271 "crypto op processing failed");
8273 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
8275 if (ut_params->op->sym->m_dst) {
8276 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8278 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
8279 uint8_t *, plaintext_pad_len);
8281 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
8283 ut_params->op->sym->cipher.data.offset);
8284 auth_tag = ciphertext + plaintext_pad_len;
8287 debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
8288 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
8291 TEST_ASSERT_BUFFERS_ARE_EQUAL(
8293 tdata->ciphertext.data,
8294 tdata->ciphertext.len,
8295 "Ciphertext data not as expected");
8297 TEST_ASSERT_BUFFERS_ARE_EQUAL(
8299 tdata->auth_tag.data,
8300 tdata->auth_tag.len,
8301 "Generated auth tag not as expected");
8307 #ifdef RTE_LIB_SECURITY
8309 security_proto_supported(enum rte_security_session_action_type action,
8310 enum rte_security_session_protocol proto)
8312 struct crypto_testsuite_params *ts_params = &testsuite_params;
8314 const struct rte_security_capability *capabilities;
8315 const struct rte_security_capability *capability;
8318 struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8319 rte_cryptodev_get_sec_ctx(
8320 ts_params->valid_devs[0]);
8323 capabilities = rte_security_capabilities_get(ctx);
8325 if (capabilities == NULL)
8328 while ((capability = &capabilities[i++])->action !=
8329 RTE_SECURITY_ACTION_TYPE_NONE) {
8330 if (capability->action == action &&
8331 capability->protocol == proto)
8338 /* Basic algorithm run function for async inplace mode.
8339 * Creates a session from input parameters and runs one operation
8340 * on input_vec. Checks the output of the crypto operation against
8343 static int test_pdcp_proto(int i, int oop, enum rte_crypto_cipher_operation opc,
8344 enum rte_crypto_auth_operation opa,
8345 const uint8_t *input_vec, unsigned int input_vec_len,
8346 const uint8_t *output_vec,
8347 unsigned int output_vec_len,
8348 enum rte_crypto_cipher_algorithm cipher_alg,
8349 const uint8_t *cipher_key, uint32_t cipher_key_len,
8350 enum rte_crypto_auth_algorithm auth_alg,
8351 const uint8_t *auth_key, uint32_t auth_key_len,
8352 uint8_t bearer, enum rte_security_pdcp_domain domain,
8353 uint8_t packet_direction, uint8_t sn_size,
8354 uint32_t hfn, uint32_t hfn_threshold, uint8_t sdap)
8356 struct crypto_testsuite_params *ts_params = &testsuite_params;
8357 struct crypto_unittest_params *ut_params = &unittest_params;
8359 int ret = TEST_SUCCESS;
8360 struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8361 rte_cryptodev_get_sec_ctx(
8362 ts_params->valid_devs[0]);
8364 /* Verify the capabilities */
8365 struct rte_security_capability_idx sec_cap_idx;
8367 sec_cap_idx.action = ut_params->type;
8368 sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
8369 sec_cap_idx.pdcp.domain = domain;
8370 if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
8371 return TEST_SKIPPED;
8373 /* Generate test mbuf data */
8374 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8376 /* clear mbuf payload */
8377 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8378 rte_pktmbuf_tailroom(ut_params->ibuf));
8380 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8382 memcpy(plaintext, input_vec, input_vec_len);
8384 /* Out of place support */
8387 * For out-op-place we need to alloc another mbuf
8389 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8390 rte_pktmbuf_append(ut_params->obuf, output_vec_len);
8393 /* Setup Cipher Parameters */
8394 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8395 ut_params->cipher_xform.cipher.algo = cipher_alg;
8396 ut_params->cipher_xform.cipher.op = opc;
8397 ut_params->cipher_xform.cipher.key.data = cipher_key;
8398 ut_params->cipher_xform.cipher.key.length = cipher_key_len;
8399 ut_params->cipher_xform.cipher.iv.length =
8400 packet_direction ? 4 : 0;
8401 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
8403 /* Setup HMAC Parameters if ICV header is required */
8404 if (auth_alg != 0) {
8405 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8406 ut_params->auth_xform.next = NULL;
8407 ut_params->auth_xform.auth.algo = auth_alg;
8408 ut_params->auth_xform.auth.op = opa;
8409 ut_params->auth_xform.auth.key.data = auth_key;
8410 ut_params->auth_xform.auth.key.length = auth_key_len;
8412 ut_params->cipher_xform.next = &ut_params->auth_xform;
8414 ut_params->cipher_xform.next = NULL;
8417 struct rte_security_session_conf sess_conf = {
8418 .action_type = ut_params->type,
8419 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
8423 .pkt_dir = packet_direction,
8425 .hfn = packet_direction ? 0 : hfn,
8427 * hfn can be set as pdcp_test_hfn[i]
8428 * if hfn_ovrd is not set. Here, PDCP
8429 * packet direction is just used to
8430 * run half of the cases with session
8431 * HFN and other half with per packet
8434 .hfn_threshold = hfn_threshold,
8435 .hfn_ovrd = packet_direction ? 1 : 0,
8436 .sdap_enabled = sdap,
8438 .crypto_xform = &ut_params->cipher_xform
8441 /* Create security session */
8442 ut_params->sec_session = rte_security_session_create(ctx,
8443 &sess_conf, ts_params->session_mpool,
8444 ts_params->session_priv_mpool);
8446 if (!ut_params->sec_session) {
8447 printf("TestCase %s()-%d line %d failed %s: ",
8448 __func__, i, __LINE__, "Failed to allocate session");
8453 /* Generate crypto op data structure */
8454 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8455 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8456 if (!ut_params->op) {
8457 printf("TestCase %s()-%d line %d failed %s: ",
8458 __func__, i, __LINE__,
8459 "Failed to allocate symmetric crypto operation struct");
8464 uint32_t *per_pkt_hfn = rte_crypto_op_ctod_offset(ut_params->op,
8465 uint32_t *, IV_OFFSET);
8466 *per_pkt_hfn = packet_direction ? hfn : 0;
8468 rte_security_attach_session(ut_params->op, ut_params->sec_session);
8470 /* set crypto operation source mbuf */
8471 ut_params->op->sym->m_src = ut_params->ibuf;
8473 ut_params->op->sym->m_dst = ut_params->obuf;
8475 /* Process crypto operation */
8476 if (process_crypto_request(ts_params->valid_devs[0], ut_params->op)
8478 printf("TestCase %s()-%d line %d failed %s: ",
8479 __func__, i, __LINE__,
8480 "failed to process sym crypto op");
8485 if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8486 printf("TestCase %s()-%d line %d failed %s: ",
8487 __func__, i, __LINE__, "crypto op processing failed");
8493 uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
8496 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8500 if (memcmp(ciphertext, output_vec, output_vec_len)) {
8501 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8502 rte_hexdump(stdout, "encrypted", ciphertext, output_vec_len);
8503 rte_hexdump(stdout, "reference", output_vec, output_vec_len);
8509 rte_crypto_op_free(ut_params->op);
8510 ut_params->op = NULL;
8512 if (ut_params->sec_session)
8513 rte_security_session_destroy(ctx, ut_params->sec_session);
8514 ut_params->sec_session = NULL;
8516 rte_pktmbuf_free(ut_params->ibuf);
8517 ut_params->ibuf = NULL;
8519 rte_pktmbuf_free(ut_params->obuf);
8520 ut_params->obuf = NULL;
8527 test_pdcp_proto_SGL(int i, int oop,
8528 enum rte_crypto_cipher_operation opc,
8529 enum rte_crypto_auth_operation opa,
8531 unsigned int input_vec_len,
8532 uint8_t *output_vec,
8533 unsigned int output_vec_len,
8535 uint32_t fragsz_oop)
8537 struct crypto_testsuite_params *ts_params = &testsuite_params;
8538 struct crypto_unittest_params *ut_params = &unittest_params;
8540 struct rte_mbuf *buf, *buf_oop = NULL;
8541 int ret = TEST_SUCCESS;
8545 unsigned int trn_data = 0;
8546 struct rte_cryptodev_info dev_info;
8547 uint64_t feat_flags;
8548 struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8549 rte_cryptodev_get_sec_ctx(
8550 ts_params->valid_devs[0]);
8551 struct rte_mbuf *temp_mbuf;
8553 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8554 feat_flags = dev_info.feature_flags;
8556 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
8557 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
8558 printf("Device does not support RAW data-path APIs.\n");
8561 /* Verify the capabilities */
8562 struct rte_security_capability_idx sec_cap_idx;
8564 sec_cap_idx.action = ut_params->type;
8565 sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
8566 sec_cap_idx.pdcp.domain = pdcp_test_params[i].domain;
8567 if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
8568 return TEST_SKIPPED;
8570 if (fragsz > input_vec_len)
8571 fragsz = input_vec_len;
8573 uint16_t plaintext_len = fragsz;
8574 uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
8576 if (fragsz_oop > output_vec_len)
8577 frag_size_oop = output_vec_len;
8580 if (input_vec_len % fragsz != 0) {
8581 if (input_vec_len / fragsz + 1 > 16)
8583 } else if (input_vec_len / fragsz > 16)
8586 /* Out of place support */
8589 * For out-op-place we need to alloc another mbuf
8591 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8592 rte_pktmbuf_append(ut_params->obuf, frag_size_oop);
8593 buf_oop = ut_params->obuf;
8596 /* Generate test mbuf data */
8597 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8599 /* clear mbuf payload */
8600 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8601 rte_pktmbuf_tailroom(ut_params->ibuf));
8603 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8605 memcpy(plaintext, input_vec, plaintext_len);
8606 trn_data += plaintext_len;
8608 buf = ut_params->ibuf;
8611 * Loop until no more fragments
8614 while (trn_data < input_vec_len) {
8616 to_trn = (input_vec_len - trn_data < fragsz) ?
8617 (input_vec_len - trn_data) : fragsz;
8619 to_trn_tbl[ecx++] = to_trn;
8621 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8624 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
8625 rte_pktmbuf_tailroom(buf));
8628 if (oop && !fragsz_oop) {
8630 rte_pktmbuf_alloc(ts_params->mbuf_pool);
8631 buf_oop = buf_oop->next;
8632 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8633 0, rte_pktmbuf_tailroom(buf_oop));
8634 rte_pktmbuf_append(buf_oop, to_trn);
8637 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
8640 memcpy(plaintext, input_vec + trn_data, to_trn);
8644 ut_params->ibuf->nb_segs = segs;
8647 if (fragsz_oop && oop) {
8651 trn_data = frag_size_oop;
8652 while (trn_data < output_vec_len) {
8655 (output_vec_len - trn_data <
8657 (output_vec_len - trn_data) :
8660 to_trn_tbl[ecx++] = to_trn;
8663 rte_pktmbuf_alloc(ts_params->mbuf_pool);
8664 buf_oop = buf_oop->next;
8665 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8666 0, rte_pktmbuf_tailroom(buf_oop));
8667 rte_pktmbuf_append(buf_oop, to_trn);
8671 ut_params->obuf->nb_segs = segs;
8674 /* Setup Cipher Parameters */
8675 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8676 ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg;
8677 ut_params->cipher_xform.cipher.op = opc;
8678 ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i];
8679 ut_params->cipher_xform.cipher.key.length =
8680 pdcp_test_params[i].cipher_key_len;
8681 ut_params->cipher_xform.cipher.iv.length = 0;
8683 /* Setup HMAC Parameters if ICV header is required */
8684 if (pdcp_test_params[i].auth_alg != 0) {
8685 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8686 ut_params->auth_xform.next = NULL;
8687 ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg;
8688 ut_params->auth_xform.auth.op = opa;
8689 ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i];
8690 ut_params->auth_xform.auth.key.length =
8691 pdcp_test_params[i].auth_key_len;
8693 ut_params->cipher_xform.next = &ut_params->auth_xform;
8695 ut_params->cipher_xform.next = NULL;
8698 struct rte_security_session_conf sess_conf = {
8699 .action_type = ut_params->type,
8700 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
8702 .bearer = pdcp_test_bearer[i],
8703 .domain = pdcp_test_params[i].domain,
8704 .pkt_dir = pdcp_test_packet_direction[i],
8705 .sn_size = pdcp_test_data_sn_size[i],
8706 .hfn = pdcp_test_hfn[i],
8707 .hfn_threshold = pdcp_test_hfn_threshold[i],
8710 .crypto_xform = &ut_params->cipher_xform
8713 /* Create security session */
8714 ut_params->sec_session = rte_security_session_create(ctx,
8715 &sess_conf, ts_params->session_mpool,
8716 ts_params->session_priv_mpool);
8718 if (!ut_params->sec_session) {
8719 printf("TestCase %s()-%d line %d failed %s: ",
8720 __func__, i, __LINE__, "Failed to allocate session");
8725 /* Generate crypto op data structure */
8726 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8727 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8728 if (!ut_params->op) {
8729 printf("TestCase %s()-%d line %d failed %s: ",
8730 __func__, i, __LINE__,
8731 "Failed to allocate symmetric crypto operation struct");
8736 rte_security_attach_session(ut_params->op, ut_params->sec_session);
8738 /* set crypto operation source mbuf */
8739 ut_params->op->sym->m_src = ut_params->ibuf;
8741 ut_params->op->sym->m_dst = ut_params->obuf;
8743 /* Process crypto operation */
8744 temp_mbuf = ut_params->op->sym->m_src;
8745 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) {
8746 /* filling lengths */
8748 ut_params->op->sym->cipher.data.length
8749 += temp_mbuf->pkt_len;
8750 ut_params->op->sym->auth.data.length
8751 += temp_mbuf->pkt_len;
8752 temp_mbuf = temp_mbuf->next;
8754 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
8755 ut_params->op, 1, 1, 0, 0);
8757 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
8760 if (ut_params->op == NULL) {
8761 printf("TestCase %s()-%d line %d failed %s: ",
8762 __func__, i, __LINE__,
8763 "failed to process sym crypto op");
8768 if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8769 printf("TestCase %s()-%d line %d failed %s: ",
8770 __func__, i, __LINE__, "crypto op processing failed");
8776 uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
8779 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8783 fragsz = frag_size_oop;
8784 if (memcmp(ciphertext, output_vec, fragsz)) {
8785 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8786 rte_hexdump(stdout, "encrypted", ciphertext, fragsz);
8787 rte_hexdump(stdout, "reference", output_vec, fragsz);
8792 buf = ut_params->op->sym->m_src->next;
8794 buf = ut_params->op->sym->m_dst->next;
8796 unsigned int off = fragsz;
8800 ciphertext = rte_pktmbuf_mtod(buf,
8802 if (memcmp(ciphertext, output_vec + off, to_trn_tbl[ecx])) {
8803 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8804 rte_hexdump(stdout, "encrypted", ciphertext, to_trn_tbl[ecx]);
8805 rte_hexdump(stdout, "reference", output_vec + off,
8810 off += to_trn_tbl[ecx++];
8814 rte_crypto_op_free(ut_params->op);
8815 ut_params->op = NULL;
8817 if (ut_params->sec_session)
8818 rte_security_session_destroy(ctx, ut_params->sec_session);
8819 ut_params->sec_session = NULL;
8821 rte_pktmbuf_free(ut_params->ibuf);
8822 ut_params->ibuf = NULL;
8824 rte_pktmbuf_free(ut_params->obuf);
8825 ut_params->obuf = NULL;
8832 test_pdcp_proto_cplane_encap(int i)
8834 return test_pdcp_proto(
8835 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8836 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8837 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8838 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8839 pdcp_test_params[i].cipher_key_len,
8840 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8841 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8842 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8843 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8844 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8848 test_pdcp_proto_uplane_encap(int i)
8850 return test_pdcp_proto(
8851 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8852 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8853 pdcp_test_data_out[i], pdcp_test_data_in_len[i],
8854 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8855 pdcp_test_params[i].cipher_key_len,
8856 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8857 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8858 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8859 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8860 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8864 test_pdcp_proto_uplane_encap_with_int(int i)
8866 return test_pdcp_proto(
8867 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8868 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8869 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8870 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8871 pdcp_test_params[i].cipher_key_len,
8872 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8873 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8874 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8875 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8876 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8880 test_pdcp_proto_cplane_decap(int i)
8882 return test_pdcp_proto(
8883 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8884 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8885 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8886 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8887 pdcp_test_params[i].cipher_key_len,
8888 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8889 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8890 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8891 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8892 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8896 test_pdcp_proto_uplane_decap(int i)
8898 return test_pdcp_proto(
8899 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8900 pdcp_test_data_out[i], pdcp_test_data_in_len[i],
8901 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8902 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8903 pdcp_test_params[i].cipher_key_len,
8904 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8905 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8906 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8907 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8908 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8912 test_pdcp_proto_uplane_decap_with_int(int i)
8914 return test_pdcp_proto(
8915 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8916 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8917 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8918 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8919 pdcp_test_params[i].cipher_key_len,
8920 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8921 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8922 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8923 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8924 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8928 test_PDCP_PROTO_SGL_in_place_32B(void)
8930 /* i can be used for running any PDCP case
8931 * In this case it is uplane 12-bit AES-SNOW DL encap
8933 int i = PDCP_UPLANE_12BIT_OFFSET + AES_ENC + SNOW_AUTH + DOWNLINK;
8934 return test_pdcp_proto_SGL(i, IN_PLACE,
8935 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8936 RTE_CRYPTO_AUTH_OP_GENERATE,
8937 pdcp_test_data_in[i],
8938 pdcp_test_data_in_len[i],
8939 pdcp_test_data_out[i],
8940 pdcp_test_data_in_len[i]+4,
8944 test_PDCP_PROTO_SGL_oop_32B_128B(void)
8946 /* i can be used for running any PDCP case
8947 * In this case it is uplane 18-bit NULL-NULL DL encap
8949 int i = PDCP_UPLANE_18BIT_OFFSET + NULL_ENC + NULL_AUTH + DOWNLINK;
8950 return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8951 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8952 RTE_CRYPTO_AUTH_OP_GENERATE,
8953 pdcp_test_data_in[i],
8954 pdcp_test_data_in_len[i],
8955 pdcp_test_data_out[i],
8956 pdcp_test_data_in_len[i]+4,
8960 test_PDCP_PROTO_SGL_oop_32B_40B(void)
8962 /* i can be used for running any PDCP case
8963 * In this case it is uplane 18-bit AES DL encap
8965 int i = PDCP_UPLANE_OFFSET + AES_ENC + EIGHTEEN_BIT_SEQ_NUM_OFFSET
8967 return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8968 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8969 RTE_CRYPTO_AUTH_OP_GENERATE,
8970 pdcp_test_data_in[i],
8971 pdcp_test_data_in_len[i],
8972 pdcp_test_data_out[i],
8973 pdcp_test_data_in_len[i],
8977 test_PDCP_PROTO_SGL_oop_128B_32B(void)
8979 /* i can be used for running any PDCP case
8980 * In this case it is cplane 12-bit AES-ZUC DL encap
8982 int i = PDCP_CPLANE_LONG_SN_OFFSET + AES_ENC + ZUC_AUTH + DOWNLINK;
8983 return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8984 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8985 RTE_CRYPTO_AUTH_OP_GENERATE,
8986 pdcp_test_data_in[i],
8987 pdcp_test_data_in_len[i],
8988 pdcp_test_data_out[i],
8989 pdcp_test_data_in_len[i]+4,
8994 test_PDCP_SDAP_PROTO_encap_all(void)
8996 int i = 0, size = 0;
8997 int err, all_err = TEST_SUCCESS;
8998 const struct pdcp_sdap_test *cur_test;
9000 size = RTE_DIM(list_pdcp_sdap_tests);
9002 for (i = 0; i < size; i++) {
9003 cur_test = &list_pdcp_sdap_tests[i];
9004 err = test_pdcp_proto(
9005 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT,
9006 RTE_CRYPTO_AUTH_OP_GENERATE, cur_test->data_in,
9007 cur_test->in_len, cur_test->data_out,
9008 cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
9009 cur_test->param.cipher_alg, cur_test->cipher_key,
9010 cur_test->param.cipher_key_len,
9011 cur_test->param.auth_alg,
9012 cur_test->auth_key, cur_test->param.auth_key_len,
9013 cur_test->bearer, cur_test->param.domain,
9014 cur_test->packet_direction, cur_test->sn_size,
9016 cur_test->hfn_threshold, SDAP_ENABLED);
9018 printf("\t%d) %s: Encapsulation failed\n",
9020 cur_test->param.name);
9023 printf("\t%d) %s: Encap PASS\n", cur_test->test_idx,
9024 cur_test->param.name);
9030 printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
9032 return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
9036 test_PDCP_PROTO_short_mac(void)
9038 int i = 0, size = 0;
9039 int err, all_err = TEST_SUCCESS;
9040 const struct pdcp_short_mac_test *cur_test;
9042 size = RTE_DIM(list_pdcp_smac_tests);
9044 for (i = 0; i < size; i++) {
9045 cur_test = &list_pdcp_smac_tests[i];
9046 err = test_pdcp_proto(
9047 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT,
9048 RTE_CRYPTO_AUTH_OP_GENERATE, cur_test->data_in,
9049 cur_test->in_len, cur_test->data_out,
9050 cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
9051 RTE_CRYPTO_CIPHER_NULL, NULL,
9052 0, cur_test->param.auth_alg,
9053 cur_test->auth_key, cur_test->param.auth_key_len,
9054 0, cur_test->param.domain, 0, 0,
9057 printf("\t%d) %s: Short MAC test failed\n",
9059 cur_test->param.name);
9062 printf("\t%d) %s: Short MAC test PASS\n",
9064 cur_test->param.name);
9065 rte_hexdump(stdout, "MAC I",
9066 cur_test->data_out + cur_test->in_len + 2,
9073 printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
9075 return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
9080 test_PDCP_SDAP_PROTO_decap_all(void)
9082 int i = 0, size = 0;
9083 int err, all_err = TEST_SUCCESS;
9084 const struct pdcp_sdap_test *cur_test;
9086 size = RTE_DIM(list_pdcp_sdap_tests);
9088 for (i = 0; i < size; i++) {
9089 cur_test = &list_pdcp_sdap_tests[i];
9090 err = test_pdcp_proto(
9091 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT,
9092 RTE_CRYPTO_AUTH_OP_VERIFY,
9094 cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
9095 cur_test->data_in, cur_test->in_len,
9096 cur_test->param.cipher_alg,
9097 cur_test->cipher_key, cur_test->param.cipher_key_len,
9098 cur_test->param.auth_alg, cur_test->auth_key,
9099 cur_test->param.auth_key_len, cur_test->bearer,
9100 cur_test->param.domain, cur_test->packet_direction,
9101 cur_test->sn_size, cur_test->hfn,
9102 cur_test->hfn_threshold, SDAP_ENABLED);
9104 printf("\t%d) %s: Decapsulation failed\n",
9106 cur_test->param.name);
9109 printf("\t%d) %s: Decap PASS\n", cur_test->test_idx,
9110 cur_test->param.name);
9116 printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
9118 return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
9122 test_ipsec_proto_process(const struct ipsec_test_data td[],
9123 struct ipsec_test_data res_d[],
9126 const struct ipsec_test_flags *flags)
9128 uint16_t v6_src[8] = {0x2607, 0xf8b0, 0x400c, 0x0c03, 0x0000, 0x0000,
9130 uint16_t v6_dst[8] = {0x2001, 0x0470, 0xe5bf, 0xdead, 0x4957, 0x2174,
9132 struct crypto_testsuite_params *ts_params = &testsuite_params;
9133 struct crypto_unittest_params *ut_params = &unittest_params;
9134 struct rte_security_capability_idx sec_cap_idx;
9135 const struct rte_security_capability *sec_cap;
9136 struct rte_security_ipsec_xform ipsec_xform;
9137 uint8_t dev_id = ts_params->valid_devs[0];
9138 enum rte_security_ipsec_sa_direction dir;
9139 struct ipsec_test_data *res_d_tmp = NULL;
9140 uint32_t src = RTE_IPV4(192, 168, 1, 0);
9141 uint32_t dst = RTE_IPV4(192, 168, 1, 1);
9142 int salt_len, i, ret = TEST_SUCCESS;
9143 struct rte_security_ctx *ctx;
9144 uint8_t *input_text;
9147 ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
9148 gbl_action_type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
9150 /* Use first test data to create session */
9152 /* Copy IPsec xform */
9153 memcpy(&ipsec_xform, &td[0].ipsec_xform, sizeof(ipsec_xform));
9155 dir = ipsec_xform.direction;
9156 verify = flags->tunnel_hdr_verify;
9158 if ((dir == RTE_SECURITY_IPSEC_SA_DIR_INGRESS) && verify) {
9159 if (verify == RTE_SECURITY_IPSEC_TUNNEL_VERIFY_SRC_DST_ADDR)
9161 else if (verify == RTE_SECURITY_IPSEC_TUNNEL_VERIFY_DST_ADDR)
9165 if (td->ipsec_xform.mode == RTE_SECURITY_IPSEC_SA_MODE_TUNNEL) {
9166 if (td->ipsec_xform.tunnel.type ==
9167 RTE_SECURITY_IPSEC_TUNNEL_IPV4) {
9168 memcpy(&ipsec_xform.tunnel.ipv4.src_ip, &src,
9170 memcpy(&ipsec_xform.tunnel.ipv4.dst_ip, &dst,
9173 memcpy(&ipsec_xform.tunnel.ipv6.src_addr, &v6_src,
9175 memcpy(&ipsec_xform.tunnel.ipv6.dst_addr, &v6_dst,
9180 ctx = rte_cryptodev_get_sec_ctx(dev_id);
9182 sec_cap_idx.action = ut_params->type;
9183 sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_IPSEC;
9184 sec_cap_idx.ipsec.proto = ipsec_xform.proto;
9185 sec_cap_idx.ipsec.mode = ipsec_xform.mode;
9186 sec_cap_idx.ipsec.direction = ipsec_xform.direction;
9188 if (flags->udp_encap)
9189 ipsec_xform.options.udp_encap = 1;
9191 sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
9192 if (sec_cap == NULL)
9193 return TEST_SKIPPED;
9195 /* Copy cipher session parameters */
9197 memcpy(&ut_params->aead_xform, &td[0].xform.aead,
9198 sizeof(ut_params->aead_xform));
9199 ut_params->aead_xform.aead.key.data = td[0].key.data;
9200 ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
9202 /* Verify crypto capabilities */
9203 if (test_ipsec_crypto_caps_aead_verify(
9205 &ut_params->aead_xform) != 0) {
9207 RTE_LOG(INFO, USER1,
9208 "Crypto capabilities not supported\n");
9209 return TEST_SKIPPED;
9212 memcpy(&ut_params->cipher_xform, &td[0].xform.chain.cipher,
9213 sizeof(ut_params->cipher_xform));
9214 memcpy(&ut_params->auth_xform, &td[0].xform.chain.auth,
9215 sizeof(ut_params->auth_xform));
9216 ut_params->cipher_xform.cipher.key.data = td[0].key.data;
9217 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
9218 ut_params->auth_xform.auth.key.data = td[0].auth_key.data;
9220 /* Verify crypto capabilities */
9222 if (test_ipsec_crypto_caps_cipher_verify(
9224 &ut_params->cipher_xform) != 0) {
9226 RTE_LOG(INFO, USER1,
9227 "Cipher crypto capabilities not supported\n");
9228 return TEST_SKIPPED;
9231 if (test_ipsec_crypto_caps_auth_verify(
9233 &ut_params->auth_xform) != 0) {
9235 RTE_LOG(INFO, USER1,
9236 "Auth crypto capabilities not supported\n");
9237 return TEST_SKIPPED;
9241 if (test_ipsec_sec_caps_verify(&ipsec_xform, sec_cap, silent) != 0)
9242 return TEST_SKIPPED;
9244 struct rte_security_session_conf sess_conf = {
9245 .action_type = ut_params->type,
9246 .protocol = RTE_SECURITY_PROTOCOL_IPSEC,
9250 salt_len = RTE_MIN(sizeof(ipsec_xform.salt), td[0].salt.len);
9251 memcpy(&ipsec_xform.salt, td[0].salt.data, salt_len);
9252 sess_conf.ipsec = ipsec_xform;
9253 sess_conf.crypto_xform = &ut_params->aead_xform;
9255 sess_conf.ipsec = ipsec_xform;
9256 if (dir == RTE_SECURITY_IPSEC_SA_DIR_EGRESS) {
9257 sess_conf.crypto_xform = &ut_params->cipher_xform;
9258 ut_params->cipher_xform.next = &ut_params->auth_xform;
9260 sess_conf.crypto_xform = &ut_params->auth_xform;
9261 ut_params->auth_xform.next = &ut_params->cipher_xform;
9265 /* Create security session */
9266 ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
9267 ts_params->session_mpool,
9268 ts_params->session_priv_mpool);
9270 if (ut_params->sec_session == NULL)
9271 return TEST_SKIPPED;
9273 for (i = 0; i < nb_td; i++) {
9274 /* Setup source mbuf payload */
9275 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9276 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9277 rte_pktmbuf_tailroom(ut_params->ibuf));
9279 input_text = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9280 td[i].input_text.len);
9282 memcpy(input_text, td[i].input_text.data,
9283 td[i].input_text.len);
9285 /* Generate crypto op data structure */
9286 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9287 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9288 if (!ut_params->op) {
9289 printf("TestCase %s line %d: %s\n",
9291 "failed to allocate crypto op");
9293 goto crypto_op_free;
9296 /* Attach session to operation */
9297 rte_security_attach_session(ut_params->op,
9298 ut_params->sec_session);
9300 /* Set crypto operation mbufs */
9301 ut_params->op->sym->m_src = ut_params->ibuf;
9302 ut_params->op->sym->m_dst = NULL;
9304 /* Copy IV in crypto operation when IV generation is disabled */
9305 if (dir == RTE_SECURITY_IPSEC_SA_DIR_EGRESS &&
9306 ipsec_xform.options.iv_gen_disable == 1) {
9307 uint8_t *iv = rte_crypto_op_ctod_offset(ut_params->op,
9313 len = td[i].xform.aead.aead.iv.length;
9315 len = td[i].xform.chain.cipher.cipher.iv.length;
9317 memcpy(iv, td[i].iv.data, len);
9320 /* Process crypto operation */
9321 process_crypto_request(dev_id, ut_params->op);
9323 ret = test_ipsec_status_check(ut_params->op, flags, dir, i + 1);
9324 if (ret != TEST_SUCCESS)
9325 goto crypto_op_free;
9328 res_d_tmp = &res_d[i];
9330 ret = test_ipsec_post_process(ut_params->ibuf, &td[i],
9331 res_d_tmp, silent, flags);
9332 if (ret != TEST_SUCCESS)
9333 goto crypto_op_free;
9335 ret = test_ipsec_stats_verify(ctx, ut_params->sec_session,
9337 if (ret != TEST_SUCCESS)
9338 goto crypto_op_free;
9340 rte_crypto_op_free(ut_params->op);
9341 ut_params->op = NULL;
9343 rte_pktmbuf_free(ut_params->ibuf);
9344 ut_params->ibuf = NULL;
9348 rte_crypto_op_free(ut_params->op);
9349 ut_params->op = NULL;
9351 rte_pktmbuf_free(ut_params->ibuf);
9352 ut_params->ibuf = NULL;
9354 if (ut_params->sec_session)
9355 rte_security_session_destroy(ctx, ut_params->sec_session);
9356 ut_params->sec_session = NULL;
9362 test_ipsec_proto_known_vec(const void *test_data)
9364 struct ipsec_test_data td_outb;
9365 struct ipsec_test_flags flags;
9367 memset(&flags, 0, sizeof(flags));
9369 memcpy(&td_outb, test_data, sizeof(td_outb));
9372 td_outb.xform.chain.cipher.cipher.algo != RTE_CRYPTO_CIPHER_NULL) {
9373 /* Disable IV gen to be able to test with known vectors */
9374 td_outb.ipsec_xform.options.iv_gen_disable = 1;
9377 return test_ipsec_proto_process(&td_outb, NULL, 1, false, &flags);
9381 test_ipsec_proto_known_vec_inb(const void *test_data)
9383 const struct ipsec_test_data *td = test_data;
9384 struct ipsec_test_flags flags;
9385 struct ipsec_test_data td_inb;
9387 memset(&flags, 0, sizeof(flags));
9389 if (td->ipsec_xform.direction == RTE_SECURITY_IPSEC_SA_DIR_EGRESS)
9390 test_ipsec_td_in_from_out(td, &td_inb);
9392 memcpy(&td_inb, td, sizeof(td_inb));
9394 return test_ipsec_proto_process(&td_inb, NULL, 1, false, &flags);
9398 test_ipsec_proto_known_vec_fragmented(const void *test_data)
9400 struct ipsec_test_data td_outb;
9401 struct ipsec_test_flags flags;
9403 memset(&flags, 0, sizeof(flags));
9404 flags.fragment = true;
9406 memcpy(&td_outb, test_data, sizeof(td_outb));
9408 /* Disable IV gen to be able to test with known vectors */
9409 td_outb.ipsec_xform.options.iv_gen_disable = 1;
9411 return test_ipsec_proto_process(&td_outb, NULL, 1, false, &flags);
9415 test_ipsec_proto_all(const struct ipsec_test_flags *flags)
9417 struct ipsec_test_data td_outb[IPSEC_TEST_PACKETS_MAX];
9418 struct ipsec_test_data td_inb[IPSEC_TEST_PACKETS_MAX];
9419 unsigned int i, nb_pkts = 1, pass_cnt = 0;
9422 if (flags->iv_gen ||
9423 flags->sa_expiry_pkts_soft ||
9424 flags->sa_expiry_pkts_hard)
9425 nb_pkts = IPSEC_TEST_PACKETS_MAX;
9427 for (i = 0; i < RTE_DIM(alg_list); i++) {
9428 test_ipsec_td_prepare(alg_list[i].param1,
9434 if (!td_outb->aead) {
9435 enum rte_crypto_cipher_algorithm cipher_alg;
9436 enum rte_crypto_auth_algorithm auth_alg;
9438 cipher_alg = td_outb->xform.chain.cipher.cipher.algo;
9439 auth_alg = td_outb->xform.chain.auth.auth.algo;
9441 /* ICV is not applicable for NULL auth */
9442 if (flags->icv_corrupt &&
9443 auth_alg == RTE_CRYPTO_AUTH_NULL)
9446 /* IV is not applicable for NULL cipher */
9447 if (flags->iv_gen &&
9448 cipher_alg == RTE_CRYPTO_CIPHER_NULL)
9452 ret = test_ipsec_proto_process(td_outb, td_inb, nb_pkts, true,
9454 if (ret == TEST_SKIPPED)
9457 if (ret == TEST_FAILED)
9460 test_ipsec_td_update(td_inb, td_outb, nb_pkts, flags);
9462 ret = test_ipsec_proto_process(td_inb, NULL, nb_pkts, true,
9464 if (ret == TEST_SKIPPED)
9467 if (ret == TEST_FAILED)
9470 if (flags->display_alg)
9471 test_ipsec_display_alg(alg_list[i].param1,
9472 alg_list[i].param2);
9478 return TEST_SUCCESS;
9480 return TEST_SKIPPED;
9484 test_ipsec_proto_display_list(const void *data __rte_unused)
9486 struct ipsec_test_flags flags;
9488 memset(&flags, 0, sizeof(flags));
9490 flags.display_alg = true;
9492 return test_ipsec_proto_all(&flags);
9496 test_ipsec_proto_iv_gen(const void *data __rte_unused)
9498 struct ipsec_test_flags flags;
9500 memset(&flags, 0, sizeof(flags));
9502 flags.iv_gen = true;
9504 return test_ipsec_proto_all(&flags);
9508 test_ipsec_proto_sa_exp_pkts_soft(const void *data __rte_unused)
9510 struct ipsec_test_flags flags;
9512 memset(&flags, 0, sizeof(flags));
9514 flags.sa_expiry_pkts_soft = true;
9516 return test_ipsec_proto_all(&flags);
9520 test_ipsec_proto_sa_exp_pkts_hard(const void *data __rte_unused)
9522 struct ipsec_test_flags flags;
9524 memset(&flags, 0, sizeof(flags));
9526 flags.sa_expiry_pkts_hard = true;
9528 return test_ipsec_proto_all(&flags);
9532 test_ipsec_proto_err_icv_corrupt(const void *data __rte_unused)
9534 struct ipsec_test_flags flags;
9536 memset(&flags, 0, sizeof(flags));
9538 flags.icv_corrupt = true;
9540 return test_ipsec_proto_all(&flags);
9544 test_ipsec_proto_udp_encap(const void *data __rte_unused)
9546 struct ipsec_test_flags flags;
9548 memset(&flags, 0, sizeof(flags));
9550 flags.udp_encap = true;
9552 return test_ipsec_proto_all(&flags);
9556 test_ipsec_proto_tunnel_src_dst_addr_verify(const void *data __rte_unused)
9558 struct ipsec_test_flags flags;
9560 memset(&flags, 0, sizeof(flags));
9562 flags.tunnel_hdr_verify = RTE_SECURITY_IPSEC_TUNNEL_VERIFY_SRC_DST_ADDR;
9564 return test_ipsec_proto_all(&flags);
9568 test_ipsec_proto_tunnel_dst_addr_verify(const void *data __rte_unused)
9570 struct ipsec_test_flags flags;
9572 memset(&flags, 0, sizeof(flags));
9574 flags.tunnel_hdr_verify = RTE_SECURITY_IPSEC_TUNNEL_VERIFY_DST_ADDR;
9576 return test_ipsec_proto_all(&flags);
9580 test_ipsec_proto_udp_ports_verify(const void *data __rte_unused)
9582 struct ipsec_test_flags flags;
9584 memset(&flags, 0, sizeof(flags));
9586 flags.udp_encap = true;
9587 flags.udp_ports_verify = true;
9589 return test_ipsec_proto_all(&flags);
9593 test_ipsec_proto_inner_ip_csum(const void *data __rte_unused)
9595 struct ipsec_test_flags flags;
9597 memset(&flags, 0, sizeof(flags));
9599 flags.ip_csum = true;
9601 return test_ipsec_proto_all(&flags);
9605 test_ipsec_proto_inner_l4_csum(const void *data __rte_unused)
9607 struct ipsec_test_flags flags;
9609 memset(&flags, 0, sizeof(flags));
9611 flags.l4_csum = true;
9613 return test_ipsec_proto_all(&flags);
9617 test_ipsec_proto_tunnel_v4_in_v4(const void *data __rte_unused)
9619 struct ipsec_test_flags flags;
9621 memset(&flags, 0, sizeof(flags));
9624 flags.tunnel_ipv6 = false;
9626 return test_ipsec_proto_all(&flags);
9630 test_ipsec_proto_tunnel_v6_in_v6(const void *data __rte_unused)
9632 struct ipsec_test_flags flags;
9634 memset(&flags, 0, sizeof(flags));
9637 flags.tunnel_ipv6 = true;
9639 return test_ipsec_proto_all(&flags);
9643 test_ipsec_proto_tunnel_v4_in_v6(const void *data __rte_unused)
9645 struct ipsec_test_flags flags;
9647 memset(&flags, 0, sizeof(flags));
9650 flags.tunnel_ipv6 = true;
9652 return test_ipsec_proto_all(&flags);
9656 test_ipsec_proto_tunnel_v6_in_v4(const void *data __rte_unused)
9658 struct ipsec_test_flags flags;
9660 memset(&flags, 0, sizeof(flags));
9663 flags.tunnel_ipv6 = false;
9665 return test_ipsec_proto_all(&flags);
9669 test_ipsec_proto_transport_v4(const void *data __rte_unused)
9671 struct ipsec_test_flags flags;
9673 memset(&flags, 0, sizeof(flags));
9676 flags.transport = true;
9678 return test_ipsec_proto_all(&flags);
9682 test_ipsec_proto_stats(const void *data __rte_unused)
9684 struct ipsec_test_flags flags;
9686 memset(&flags, 0, sizeof(flags));
9688 flags.stats_success = true;
9690 return test_ipsec_proto_all(&flags);
9694 test_ipsec_proto_pkt_fragment(const void *data __rte_unused)
9696 struct ipsec_test_flags flags;
9698 memset(&flags, 0, sizeof(flags));
9700 flags.fragment = true;
9702 return test_ipsec_proto_all(&flags);
9706 test_PDCP_PROTO_all(void)
9708 struct crypto_testsuite_params *ts_params = &testsuite_params;
9709 struct crypto_unittest_params *ut_params = &unittest_params;
9710 struct rte_cryptodev_info dev_info;
9713 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
9714 uint64_t feat_flags = dev_info.feature_flags;
9716 if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY))
9717 return TEST_SKIPPED;
9719 /* Set action type */
9720 ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
9721 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
9724 if (security_proto_supported(ut_params->type,
9725 RTE_SECURITY_PROTOCOL_PDCP) < 0)
9726 return TEST_SKIPPED;
9728 status = test_PDCP_PROTO_cplane_encap_all();
9729 status += test_PDCP_PROTO_cplane_decap_all();
9730 status += test_PDCP_PROTO_uplane_encap_all();
9731 status += test_PDCP_PROTO_uplane_decap_all();
9732 status += test_PDCP_PROTO_SGL_in_place_32B();
9733 status += test_PDCP_PROTO_SGL_oop_32B_128B();
9734 status += test_PDCP_PROTO_SGL_oop_32B_40B();
9735 status += test_PDCP_PROTO_SGL_oop_128B_32B();
9736 status += test_PDCP_SDAP_PROTO_encap_all();
9737 status += test_PDCP_SDAP_PROTO_decap_all();
9738 status += test_PDCP_PROTO_short_mac();
9743 return TEST_SUCCESS;
9747 test_docsis_proto_uplink(const void *data)
9749 const struct docsis_test_data *d_td = data;
9750 struct crypto_testsuite_params *ts_params = &testsuite_params;
9751 struct crypto_unittest_params *ut_params = &unittest_params;
9752 uint8_t *plaintext = NULL;
9753 uint8_t *ciphertext = NULL;
9755 int32_t cipher_len, crc_len;
9756 uint32_t crc_data_len;
9757 int ret = TEST_SUCCESS;
9759 struct rte_security_ctx *ctx = (struct rte_security_ctx *)
9760 rte_cryptodev_get_sec_ctx(
9761 ts_params->valid_devs[0]);
9763 /* Verify the capabilities */
9764 struct rte_security_capability_idx sec_cap_idx;
9765 const struct rte_security_capability *sec_cap;
9766 const struct rte_cryptodev_capabilities *crypto_cap;
9767 const struct rte_cryptodev_symmetric_capability *sym_cap;
9770 /* Set action type */
9771 ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
9772 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
9775 if (security_proto_supported(ut_params->type,
9776 RTE_SECURITY_PROTOCOL_DOCSIS) < 0)
9777 return TEST_SKIPPED;
9779 sec_cap_idx.action = ut_params->type;
9780 sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
9781 sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_UPLINK;
9783 sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
9784 if (sec_cap == NULL)
9785 return TEST_SKIPPED;
9787 while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
9788 RTE_CRYPTO_OP_TYPE_UNDEFINED) {
9789 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
9790 crypto_cap->sym.xform_type ==
9791 RTE_CRYPTO_SYM_XFORM_CIPHER &&
9792 crypto_cap->sym.cipher.algo ==
9793 RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
9794 sym_cap = &crypto_cap->sym;
9795 if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
9802 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
9803 return TEST_SKIPPED;
9805 /* Setup source mbuf payload */
9806 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9807 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9808 rte_pktmbuf_tailroom(ut_params->ibuf));
9810 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9811 d_td->ciphertext.len);
9813 memcpy(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len);
9815 /* Setup cipher session parameters */
9816 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
9817 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
9818 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
9819 ut_params->cipher_xform.cipher.key.data = d_td->key.data;
9820 ut_params->cipher_xform.cipher.key.length = d_td->key.len;
9821 ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
9822 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
9823 ut_params->cipher_xform.next = NULL;
9825 /* Setup DOCSIS session parameters */
9826 ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_UPLINK;
9828 struct rte_security_session_conf sess_conf = {
9829 .action_type = ut_params->type,
9830 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
9831 .docsis = ut_params->docsis_xform,
9832 .crypto_xform = &ut_params->cipher_xform,
9835 /* Create security session */
9836 ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
9837 ts_params->session_mpool,
9838 ts_params->session_priv_mpool);
9840 if (!ut_params->sec_session) {
9841 printf("Test function %s line %u: failed to allocate session\n",
9842 __func__, __LINE__);
9847 /* Generate crypto op data structure */
9848 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9849 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9850 if (!ut_params->op) {
9851 printf("Test function %s line %u: failed to allocate symmetric "
9852 "crypto operation\n", __func__, __LINE__);
9857 /* Setup CRC operation parameters */
9858 crc_len = d_td->ciphertext.no_crc == false ?
9859 (d_td->ciphertext.len -
9860 d_td->ciphertext.crc_offset -
9861 RTE_ETHER_CRC_LEN) :
9863 crc_len = crc_len > 0 ? crc_len : 0;
9864 crc_data_len = crc_len == 0 ? 0 : RTE_ETHER_CRC_LEN;
9865 ut_params->op->sym->auth.data.length = crc_len;
9866 ut_params->op->sym->auth.data.offset = d_td->ciphertext.crc_offset;
9868 /* Setup cipher operation parameters */
9869 cipher_len = d_td->ciphertext.no_cipher == false ?
9870 (d_td->ciphertext.len -
9871 d_td->ciphertext.cipher_offset) :
9873 cipher_len = cipher_len > 0 ? cipher_len : 0;
9874 ut_params->op->sym->cipher.data.length = cipher_len;
9875 ut_params->op->sym->cipher.data.offset = d_td->ciphertext.cipher_offset;
9877 /* Setup cipher IV */
9878 iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
9879 rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
9881 /* Attach session to operation */
9882 rte_security_attach_session(ut_params->op, ut_params->sec_session);
9884 /* Set crypto operation mbufs */
9885 ut_params->op->sym->m_src = ut_params->ibuf;
9886 ut_params->op->sym->m_dst = NULL;
9888 /* Process crypto operation */
9889 if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
9891 printf("Test function %s line %u: failed to process security "
9892 "crypto op\n", __func__, __LINE__);
9897 if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
9898 printf("Test function %s line %u: failed to process crypto op\n",
9899 __func__, __LINE__);
9904 /* Validate plaintext */
9905 plaintext = ciphertext;
9907 if (memcmp(plaintext, d_td->plaintext.data,
9908 d_td->plaintext.len - crc_data_len)) {
9909 printf("Test function %s line %u: plaintext not as expected\n",
9910 __func__, __LINE__);
9911 rte_hexdump(stdout, "expected", d_td->plaintext.data,
9912 d_td->plaintext.len);
9913 rte_hexdump(stdout, "actual", plaintext, d_td->plaintext.len);
9919 rte_crypto_op_free(ut_params->op);
9920 ut_params->op = NULL;
9922 if (ut_params->sec_session)
9923 rte_security_session_destroy(ctx, ut_params->sec_session);
9924 ut_params->sec_session = NULL;
9926 rte_pktmbuf_free(ut_params->ibuf);
9927 ut_params->ibuf = NULL;
9933 test_docsis_proto_downlink(const void *data)
9935 const struct docsis_test_data *d_td = data;
9936 struct crypto_testsuite_params *ts_params = &testsuite_params;
9937 struct crypto_unittest_params *ut_params = &unittest_params;
9938 uint8_t *plaintext = NULL;
9939 uint8_t *ciphertext = NULL;
9941 int32_t cipher_len, crc_len;
9942 int ret = TEST_SUCCESS;
9944 struct rte_security_ctx *ctx = (struct rte_security_ctx *)
9945 rte_cryptodev_get_sec_ctx(
9946 ts_params->valid_devs[0]);
9948 /* Verify the capabilities */
9949 struct rte_security_capability_idx sec_cap_idx;
9950 const struct rte_security_capability *sec_cap;
9951 const struct rte_cryptodev_capabilities *crypto_cap;
9952 const struct rte_cryptodev_symmetric_capability *sym_cap;
9955 /* Set action type */
9956 ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
9957 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
9960 if (security_proto_supported(ut_params->type,
9961 RTE_SECURITY_PROTOCOL_DOCSIS) < 0)
9962 return TEST_SKIPPED;
9964 sec_cap_idx.action = ut_params->type;
9965 sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
9966 sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
9968 sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
9969 if (sec_cap == NULL)
9970 return TEST_SKIPPED;
9972 while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
9973 RTE_CRYPTO_OP_TYPE_UNDEFINED) {
9974 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
9975 crypto_cap->sym.xform_type ==
9976 RTE_CRYPTO_SYM_XFORM_CIPHER &&
9977 crypto_cap->sym.cipher.algo ==
9978 RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
9979 sym_cap = &crypto_cap->sym;
9980 if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
9987 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
9988 return TEST_SKIPPED;
9990 /* Setup source mbuf payload */
9991 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9992 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9993 rte_pktmbuf_tailroom(ut_params->ibuf));
9995 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9996 d_td->plaintext.len);
9998 memcpy(plaintext, d_td->plaintext.data, d_td->plaintext.len);
10000 /* Setup cipher session parameters */
10001 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10002 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
10003 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
10004 ut_params->cipher_xform.cipher.key.data = d_td->key.data;
10005 ut_params->cipher_xform.cipher.key.length = d_td->key.len;
10006 ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
10007 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
10008 ut_params->cipher_xform.next = NULL;
10010 /* Setup DOCSIS session parameters */
10011 ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
10013 struct rte_security_session_conf sess_conf = {
10014 .action_type = ut_params->type,
10015 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
10016 .docsis = ut_params->docsis_xform,
10017 .crypto_xform = &ut_params->cipher_xform,
10020 /* Create security session */
10021 ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
10022 ts_params->session_mpool,
10023 ts_params->session_priv_mpool);
10025 if (!ut_params->sec_session) {
10026 printf("Test function %s line %u: failed to allocate session\n",
10027 __func__, __LINE__);
10032 /* Generate crypto op data structure */
10033 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10034 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10035 if (!ut_params->op) {
10036 printf("Test function %s line %u: failed to allocate symmetric "
10037 "crypto operation\n", __func__, __LINE__);
10042 /* Setup CRC operation parameters */
10043 crc_len = d_td->plaintext.no_crc == false ?
10044 (d_td->plaintext.len -
10045 d_td->plaintext.crc_offset -
10046 RTE_ETHER_CRC_LEN) :
10048 crc_len = crc_len > 0 ? crc_len : 0;
10049 ut_params->op->sym->auth.data.length = crc_len;
10050 ut_params->op->sym->auth.data.offset = d_td->plaintext.crc_offset;
10052 /* Setup cipher operation parameters */
10053 cipher_len = d_td->plaintext.no_cipher == false ?
10054 (d_td->plaintext.len -
10055 d_td->plaintext.cipher_offset) :
10057 cipher_len = cipher_len > 0 ? cipher_len : 0;
10058 ut_params->op->sym->cipher.data.length = cipher_len;
10059 ut_params->op->sym->cipher.data.offset = d_td->plaintext.cipher_offset;
10061 /* Setup cipher IV */
10062 iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
10063 rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
10065 /* Attach session to operation */
10066 rte_security_attach_session(ut_params->op, ut_params->sec_session);
10068 /* Set crypto operation mbufs */
10069 ut_params->op->sym->m_src = ut_params->ibuf;
10070 ut_params->op->sym->m_dst = NULL;
10072 /* Process crypto operation */
10073 if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
10075 printf("Test function %s line %u: failed to process crypto op\n",
10076 __func__, __LINE__);
10081 if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
10082 printf("Test function %s line %u: crypto op processing failed\n",
10083 __func__, __LINE__);
10088 /* Validate ciphertext */
10089 ciphertext = plaintext;
10091 if (memcmp(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len)) {
10092 printf("Test function %s line %u: plaintext not as expected\n",
10093 __func__, __LINE__);
10094 rte_hexdump(stdout, "expected", d_td->ciphertext.data,
10095 d_td->ciphertext.len);
10096 rte_hexdump(stdout, "actual", ciphertext, d_td->ciphertext.len);
10102 rte_crypto_op_free(ut_params->op);
10103 ut_params->op = NULL;
10105 if (ut_params->sec_session)
10106 rte_security_session_destroy(ctx, ut_params->sec_session);
10107 ut_params->sec_session = NULL;
10109 rte_pktmbuf_free(ut_params->ibuf);
10110 ut_params->ibuf = NULL;
10117 test_AES_GCM_authenticated_encryption_test_case_1(void)
10119 return test_authenticated_encryption(&gcm_test_case_1);
10123 test_AES_GCM_authenticated_encryption_test_case_2(void)
10125 return test_authenticated_encryption(&gcm_test_case_2);
10129 test_AES_GCM_authenticated_encryption_test_case_3(void)
10131 return test_authenticated_encryption(&gcm_test_case_3);
10135 test_AES_GCM_authenticated_encryption_test_case_4(void)
10137 return test_authenticated_encryption(&gcm_test_case_4);
10141 test_AES_GCM_authenticated_encryption_test_case_5(void)
10143 return test_authenticated_encryption(&gcm_test_case_5);
10147 test_AES_GCM_authenticated_encryption_test_case_6(void)
10149 return test_authenticated_encryption(&gcm_test_case_6);
10153 test_AES_GCM_authenticated_encryption_test_case_7(void)
10155 return test_authenticated_encryption(&gcm_test_case_7);
10159 test_AES_GCM_authenticated_encryption_test_case_8(void)
10161 return test_authenticated_encryption(&gcm_test_case_8);
10165 test_AES_GCM_J0_authenticated_encryption_test_case_1(void)
10167 return test_authenticated_encryption(&gcm_J0_test_case_1);
10171 test_AES_GCM_auth_encryption_test_case_192_1(void)
10173 return test_authenticated_encryption(&gcm_test_case_192_1);
10177 test_AES_GCM_auth_encryption_test_case_192_2(void)
10179 return test_authenticated_encryption(&gcm_test_case_192_2);
10183 test_AES_GCM_auth_encryption_test_case_192_3(void)
10185 return test_authenticated_encryption(&gcm_test_case_192_3);
10189 test_AES_GCM_auth_encryption_test_case_192_4(void)
10191 return test_authenticated_encryption(&gcm_test_case_192_4);
10195 test_AES_GCM_auth_encryption_test_case_192_5(void)
10197 return test_authenticated_encryption(&gcm_test_case_192_5);
10201 test_AES_GCM_auth_encryption_test_case_192_6(void)
10203 return test_authenticated_encryption(&gcm_test_case_192_6);
10207 test_AES_GCM_auth_encryption_test_case_192_7(void)
10209 return test_authenticated_encryption(&gcm_test_case_192_7);
10213 test_AES_GCM_auth_encryption_test_case_256_1(void)
10215 return test_authenticated_encryption(&gcm_test_case_256_1);
10219 test_AES_GCM_auth_encryption_test_case_256_2(void)
10221 return test_authenticated_encryption(&gcm_test_case_256_2);
10225 test_AES_GCM_auth_encryption_test_case_256_3(void)
10227 return test_authenticated_encryption(&gcm_test_case_256_3);
10231 test_AES_GCM_auth_encryption_test_case_256_4(void)
10233 return test_authenticated_encryption(&gcm_test_case_256_4);
10237 test_AES_GCM_auth_encryption_test_case_256_5(void)
10239 return test_authenticated_encryption(&gcm_test_case_256_5);
10243 test_AES_GCM_auth_encryption_test_case_256_6(void)
10245 return test_authenticated_encryption(&gcm_test_case_256_6);
10249 test_AES_GCM_auth_encryption_test_case_256_7(void)
10251 return test_authenticated_encryption(&gcm_test_case_256_7);
10255 test_AES_GCM_auth_encryption_test_case_aad_1(void)
10257 return test_authenticated_encryption(&gcm_test_case_aad_1);
10261 test_AES_GCM_auth_encryption_test_case_aad_2(void)
10263 return test_authenticated_encryption(&gcm_test_case_aad_2);
10267 test_AES_GCM_auth_encryption_fail_iv_corrupt(void)
10269 struct aead_test_data tdata;
10272 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10273 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10274 tdata.iv.data[0] += 1;
10275 res = test_authenticated_encryption(&tdata);
10276 if (res == TEST_SKIPPED)
10278 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10279 return TEST_SUCCESS;
10283 test_AES_GCM_auth_encryption_fail_in_data_corrupt(void)
10285 struct aead_test_data tdata;
10288 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10289 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10290 tdata.plaintext.data[0] += 1;
10291 res = test_authenticated_encryption(&tdata);
10292 if (res == TEST_SKIPPED)
10294 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10295 return TEST_SUCCESS;
10299 test_AES_GCM_auth_encryption_fail_out_data_corrupt(void)
10301 struct aead_test_data tdata;
10304 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10305 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10306 tdata.ciphertext.data[0] += 1;
10307 res = test_authenticated_encryption(&tdata);
10308 if (res == TEST_SKIPPED)
10310 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10311 return TEST_SUCCESS;
10315 test_AES_GCM_auth_encryption_fail_aad_len_corrupt(void)
10317 struct aead_test_data tdata;
10320 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10321 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10322 tdata.aad.len += 1;
10323 res = test_authenticated_encryption(&tdata);
10324 if (res == TEST_SKIPPED)
10326 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10327 return TEST_SUCCESS;
10331 test_AES_GCM_auth_encryption_fail_aad_corrupt(void)
10333 struct aead_test_data tdata;
10334 uint8_t aad[gcm_test_case_7.aad.len];
10337 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10338 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10339 memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
10341 tdata.aad.data = aad;
10342 res = test_authenticated_encryption(&tdata);
10343 if (res == TEST_SKIPPED)
10345 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10346 return TEST_SUCCESS;
10350 test_AES_GCM_auth_encryption_fail_tag_corrupt(void)
10352 struct aead_test_data tdata;
10355 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10356 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10357 tdata.auth_tag.data[0] += 1;
10358 res = test_authenticated_encryption(&tdata);
10359 if (res == TEST_SKIPPED)
10361 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10362 return TEST_SUCCESS;
10366 test_authenticated_decryption(const struct aead_test_data *tdata)
10368 struct crypto_testsuite_params *ts_params = &testsuite_params;
10369 struct crypto_unittest_params *ut_params = &unittest_params;
10372 uint8_t *plaintext;
10374 struct rte_cryptodev_info dev_info;
10376 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10377 uint64_t feat_flags = dev_info.feature_flags;
10379 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10380 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10381 printf("Device doesn't support RAW data-path APIs.\n");
10382 return TEST_SKIPPED;
10385 /* Verify the capabilities */
10386 struct rte_cryptodev_sym_capability_idx cap_idx;
10387 const struct rte_cryptodev_symmetric_capability *capability;
10388 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10389 cap_idx.algo.aead = tdata->algo;
10390 capability = rte_cryptodev_sym_capability_get(
10391 ts_params->valid_devs[0], &cap_idx);
10392 if (capability == NULL)
10393 return TEST_SKIPPED;
10394 if (rte_cryptodev_sym_capability_check_aead(
10395 capability, tdata->key.len, tdata->auth_tag.len,
10396 tdata->aad.len, tdata->iv.len))
10397 return TEST_SKIPPED;
10399 /* Create AEAD session */
10400 retval = create_aead_session(ts_params->valid_devs[0],
10402 RTE_CRYPTO_AEAD_OP_DECRYPT,
10403 tdata->key.data, tdata->key.len,
10404 tdata->aad.len, tdata->auth_tag.len,
10409 /* alloc mbuf and set payload */
10410 if (tdata->aad.len > MBUF_SIZE) {
10411 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
10412 /* Populate full size of add data */
10413 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
10414 memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
10416 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10418 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10419 rte_pktmbuf_tailroom(ut_params->ibuf));
10421 /* Create AEAD operation */
10422 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
10426 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10428 ut_params->op->sym->m_src = ut_params->ibuf;
10430 /* Process crypto operation */
10431 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10432 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
10433 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10434 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10435 ut_params->op, 0, 0, 0, 0);
10437 TEST_ASSERT_NOT_NULL(
10438 process_crypto_request(ts_params->valid_devs[0],
10439 ut_params->op), "failed to process sym crypto op");
10441 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10442 "crypto op processing failed");
10444 if (ut_params->op->sym->m_dst)
10445 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
10448 plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
10450 ut_params->op->sym->cipher.data.offset);
10452 debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
10454 /* Validate obuf */
10455 TEST_ASSERT_BUFFERS_ARE_EQUAL(
10457 tdata->plaintext.data,
10458 tdata->plaintext.len,
10459 "Plaintext data not as expected");
10461 TEST_ASSERT_EQUAL(ut_params->op->status,
10462 RTE_CRYPTO_OP_STATUS_SUCCESS,
10463 "Authentication failed");
10469 test_AES_GCM_authenticated_decryption_test_case_1(void)
10471 return test_authenticated_decryption(&gcm_test_case_1);
10475 test_AES_GCM_authenticated_decryption_test_case_2(void)
10477 return test_authenticated_decryption(&gcm_test_case_2);
10481 test_AES_GCM_authenticated_decryption_test_case_3(void)
10483 return test_authenticated_decryption(&gcm_test_case_3);
10487 test_AES_GCM_authenticated_decryption_test_case_4(void)
10489 return test_authenticated_decryption(&gcm_test_case_4);
10493 test_AES_GCM_authenticated_decryption_test_case_5(void)
10495 return test_authenticated_decryption(&gcm_test_case_5);
10499 test_AES_GCM_authenticated_decryption_test_case_6(void)
10501 return test_authenticated_decryption(&gcm_test_case_6);
10505 test_AES_GCM_authenticated_decryption_test_case_7(void)
10507 return test_authenticated_decryption(&gcm_test_case_7);
10511 test_AES_GCM_authenticated_decryption_test_case_8(void)
10513 return test_authenticated_decryption(&gcm_test_case_8);
10517 test_AES_GCM_J0_authenticated_decryption_test_case_1(void)
10519 return test_authenticated_decryption(&gcm_J0_test_case_1);
10523 test_AES_GCM_auth_decryption_test_case_192_1(void)
10525 return test_authenticated_decryption(&gcm_test_case_192_1);
10529 test_AES_GCM_auth_decryption_test_case_192_2(void)
10531 return test_authenticated_decryption(&gcm_test_case_192_2);
10535 test_AES_GCM_auth_decryption_test_case_192_3(void)
10537 return test_authenticated_decryption(&gcm_test_case_192_3);
10541 test_AES_GCM_auth_decryption_test_case_192_4(void)
10543 return test_authenticated_decryption(&gcm_test_case_192_4);
10547 test_AES_GCM_auth_decryption_test_case_192_5(void)
10549 return test_authenticated_decryption(&gcm_test_case_192_5);
10553 test_AES_GCM_auth_decryption_test_case_192_6(void)
10555 return test_authenticated_decryption(&gcm_test_case_192_6);
10559 test_AES_GCM_auth_decryption_test_case_192_7(void)
10561 return test_authenticated_decryption(&gcm_test_case_192_7);
10565 test_AES_GCM_auth_decryption_test_case_256_1(void)
10567 return test_authenticated_decryption(&gcm_test_case_256_1);
10571 test_AES_GCM_auth_decryption_test_case_256_2(void)
10573 return test_authenticated_decryption(&gcm_test_case_256_2);
10577 test_AES_GCM_auth_decryption_test_case_256_3(void)
10579 return test_authenticated_decryption(&gcm_test_case_256_3);
10583 test_AES_GCM_auth_decryption_test_case_256_4(void)
10585 return test_authenticated_decryption(&gcm_test_case_256_4);
10589 test_AES_GCM_auth_decryption_test_case_256_5(void)
10591 return test_authenticated_decryption(&gcm_test_case_256_5);
10595 test_AES_GCM_auth_decryption_test_case_256_6(void)
10597 return test_authenticated_decryption(&gcm_test_case_256_6);
10601 test_AES_GCM_auth_decryption_test_case_256_7(void)
10603 return test_authenticated_decryption(&gcm_test_case_256_7);
10607 test_AES_GCM_auth_decryption_test_case_aad_1(void)
10609 return test_authenticated_decryption(&gcm_test_case_aad_1);
10613 test_AES_GCM_auth_decryption_test_case_aad_2(void)
10615 return test_authenticated_decryption(&gcm_test_case_aad_2);
10619 test_AES_GCM_auth_decryption_fail_iv_corrupt(void)
10621 struct aead_test_data tdata;
10624 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10625 tdata.iv.data[0] += 1;
10626 res = test_authenticated_decryption(&tdata);
10627 if (res == TEST_SKIPPED)
10629 TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10630 return TEST_SUCCESS;
10634 test_AES_GCM_auth_decryption_fail_in_data_corrupt(void)
10636 struct aead_test_data tdata;
10639 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10640 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10641 tdata.plaintext.data[0] += 1;
10642 res = test_authenticated_decryption(&tdata);
10643 if (res == TEST_SKIPPED)
10645 TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10646 return TEST_SUCCESS;
10650 test_AES_GCM_auth_decryption_fail_out_data_corrupt(void)
10652 struct aead_test_data tdata;
10655 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10656 tdata.ciphertext.data[0] += 1;
10657 res = test_authenticated_decryption(&tdata);
10658 if (res == TEST_SKIPPED)
10660 TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10661 return TEST_SUCCESS;
10665 test_AES_GCM_auth_decryption_fail_aad_len_corrupt(void)
10667 struct aead_test_data tdata;
10670 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10671 tdata.aad.len += 1;
10672 res = test_authenticated_decryption(&tdata);
10673 if (res == TEST_SKIPPED)
10675 TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10676 return TEST_SUCCESS;
10680 test_AES_GCM_auth_decryption_fail_aad_corrupt(void)
10682 struct aead_test_data tdata;
10683 uint8_t aad[gcm_test_case_7.aad.len];
10686 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10687 memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
10689 tdata.aad.data = aad;
10690 res = test_authenticated_decryption(&tdata);
10691 if (res == TEST_SKIPPED)
10693 TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10694 return TEST_SUCCESS;
10698 test_AES_GCM_auth_decryption_fail_tag_corrupt(void)
10700 struct aead_test_data tdata;
10703 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10704 tdata.auth_tag.data[0] += 1;
10705 res = test_authenticated_decryption(&tdata);
10706 if (res == TEST_SKIPPED)
10708 TEST_ASSERT_EQUAL(res, TEST_FAILED, "authentication not failed");
10709 return TEST_SUCCESS;
10713 test_authenticated_encryption_oop(const struct aead_test_data *tdata)
10715 struct crypto_testsuite_params *ts_params = &testsuite_params;
10716 struct crypto_unittest_params *ut_params = &unittest_params;
10719 uint8_t *ciphertext, *auth_tag;
10720 uint16_t plaintext_pad_len;
10721 struct rte_cryptodev_info dev_info;
10723 /* Verify the capabilities */
10724 struct rte_cryptodev_sym_capability_idx cap_idx;
10725 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10726 cap_idx.algo.aead = tdata->algo;
10727 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10729 return TEST_SKIPPED;
10731 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10732 uint64_t feat_flags = dev_info.feature_flags;
10734 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10735 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP)))
10736 return TEST_SKIPPED;
10738 /* not supported with CPU crypto */
10739 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10740 return TEST_SKIPPED;
10742 /* Create AEAD session */
10743 retval = create_aead_session(ts_params->valid_devs[0],
10745 RTE_CRYPTO_AEAD_OP_ENCRYPT,
10746 tdata->key.data, tdata->key.len,
10747 tdata->aad.len, tdata->auth_tag.len,
10752 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10753 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10755 /* clear mbuf payload */
10756 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10757 rte_pktmbuf_tailroom(ut_params->ibuf));
10758 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
10759 rte_pktmbuf_tailroom(ut_params->obuf));
10761 /* Create AEAD operation */
10762 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
10766 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10768 ut_params->op->sym->m_src = ut_params->ibuf;
10769 ut_params->op->sym->m_dst = ut_params->obuf;
10771 /* Process crypto operation */
10772 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10773 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10774 ut_params->op, 0, 0, 0, 0);
10776 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
10777 ut_params->op), "failed to process sym crypto op");
10779 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10780 "crypto op processing failed");
10782 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
10784 ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
10785 ut_params->op->sym->cipher.data.offset);
10786 auth_tag = ciphertext + plaintext_pad_len;
10788 debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
10789 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
10791 /* Validate obuf */
10792 TEST_ASSERT_BUFFERS_ARE_EQUAL(
10794 tdata->ciphertext.data,
10795 tdata->ciphertext.len,
10796 "Ciphertext data not as expected");
10798 TEST_ASSERT_BUFFERS_ARE_EQUAL(
10800 tdata->auth_tag.data,
10801 tdata->auth_tag.len,
10802 "Generated auth tag not as expected");
10809 test_AES_GCM_authenticated_encryption_oop_test_case_1(void)
10811 return test_authenticated_encryption_oop(&gcm_test_case_5);
10815 test_authenticated_decryption_oop(const struct aead_test_data *tdata)
10817 struct crypto_testsuite_params *ts_params = &testsuite_params;
10818 struct crypto_unittest_params *ut_params = &unittest_params;
10821 uint8_t *plaintext;
10822 struct rte_cryptodev_info dev_info;
10824 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10825 uint64_t feat_flags = dev_info.feature_flags;
10827 /* Verify the capabilities */
10828 struct rte_cryptodev_sym_capability_idx cap_idx;
10829 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10830 cap_idx.algo.aead = tdata->algo;
10831 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10833 return TEST_SKIPPED;
10835 /* not supported with CPU crypto and raw data-path APIs*/
10836 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO ||
10837 global_api_test_type == CRYPTODEV_RAW_API_TEST)
10838 return TEST_SKIPPED;
10840 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10841 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10842 printf("Device does not support RAW data-path APIs.\n");
10843 return TEST_SKIPPED;
10846 /* Create AEAD session */
10847 retval = create_aead_session(ts_params->valid_devs[0],
10849 RTE_CRYPTO_AEAD_OP_DECRYPT,
10850 tdata->key.data, tdata->key.len,
10851 tdata->aad.len, tdata->auth_tag.len,
10856 /* alloc mbuf and set payload */
10857 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10858 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10860 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10861 rte_pktmbuf_tailroom(ut_params->ibuf));
10862 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
10863 rte_pktmbuf_tailroom(ut_params->obuf));
10865 /* Create AEAD operation */
10866 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
10870 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10872 ut_params->op->sym->m_src = ut_params->ibuf;
10873 ut_params->op->sym->m_dst = ut_params->obuf;
10875 /* Process crypto operation */
10876 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10877 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10878 ut_params->op, 0, 0, 0, 0);
10880 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
10881 ut_params->op), "failed to process sym crypto op");
10883 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10884 "crypto op processing failed");
10886 plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
10887 ut_params->op->sym->cipher.data.offset);
10889 debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
10891 /* Validate obuf */
10892 TEST_ASSERT_BUFFERS_ARE_EQUAL(
10894 tdata->plaintext.data,
10895 tdata->plaintext.len,
10896 "Plaintext data not as expected");
10898 TEST_ASSERT_EQUAL(ut_params->op->status,
10899 RTE_CRYPTO_OP_STATUS_SUCCESS,
10900 "Authentication failed");
10905 test_AES_GCM_authenticated_decryption_oop_test_case_1(void)
10907 return test_authenticated_decryption_oop(&gcm_test_case_5);
10911 test_authenticated_encryption_sessionless(
10912 const struct aead_test_data *tdata)
10914 struct crypto_testsuite_params *ts_params = &testsuite_params;
10915 struct crypto_unittest_params *ut_params = &unittest_params;
10918 uint8_t *ciphertext, *auth_tag;
10919 uint16_t plaintext_pad_len;
10920 uint8_t key[tdata->key.len + 1];
10921 struct rte_cryptodev_info dev_info;
10923 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10924 uint64_t feat_flags = dev_info.feature_flags;
10926 if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
10927 printf("Device doesn't support Sessionless ops.\n");
10928 return TEST_SKIPPED;
10931 /* not supported with CPU crypto */
10932 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10933 return TEST_SKIPPED;
10935 /* Verify the capabilities */
10936 struct rte_cryptodev_sym_capability_idx cap_idx;
10937 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10938 cap_idx.algo.aead = tdata->algo;
10939 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10941 return TEST_SKIPPED;
10943 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10945 /* clear mbuf payload */
10946 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10947 rte_pktmbuf_tailroom(ut_params->ibuf));
10949 /* Create AEAD operation */
10950 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
10954 /* Create GCM xform */
10955 memcpy(key, tdata->key.data, tdata->key.len);
10956 retval = create_aead_xform(ut_params->op,
10958 RTE_CRYPTO_AEAD_OP_ENCRYPT,
10959 key, tdata->key.len,
10960 tdata->aad.len, tdata->auth_tag.len,
10965 ut_params->op->sym->m_src = ut_params->ibuf;
10967 TEST_ASSERT_EQUAL(ut_params->op->sess_type,
10968 RTE_CRYPTO_OP_SESSIONLESS,
10969 "crypto op session type not sessionless");
10971 /* Process crypto operation */
10972 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
10973 ut_params->op), "failed to process sym crypto op");
10975 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
10977 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10978 "crypto op status not success");
10980 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
10982 ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
10983 ut_params->op->sym->cipher.data.offset);
10984 auth_tag = ciphertext + plaintext_pad_len;
10986 debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
10987 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
10989 /* Validate obuf */
10990 TEST_ASSERT_BUFFERS_ARE_EQUAL(
10992 tdata->ciphertext.data,
10993 tdata->ciphertext.len,
10994 "Ciphertext data not as expected");
10996 TEST_ASSERT_BUFFERS_ARE_EQUAL(
10998 tdata->auth_tag.data,
10999 tdata->auth_tag.len,
11000 "Generated auth tag not as expected");
11007 test_AES_GCM_authenticated_encryption_sessionless_test_case_1(void)
11009 return test_authenticated_encryption_sessionless(
11014 test_authenticated_decryption_sessionless(
11015 const struct aead_test_data *tdata)
11017 struct crypto_testsuite_params *ts_params = &testsuite_params;
11018 struct crypto_unittest_params *ut_params = &unittest_params;
11021 uint8_t *plaintext;
11022 uint8_t key[tdata->key.len + 1];
11023 struct rte_cryptodev_info dev_info;
11025 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11026 uint64_t feat_flags = dev_info.feature_flags;
11028 if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
11029 printf("Device doesn't support Sessionless ops.\n");
11030 return TEST_SKIPPED;
11033 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11034 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11035 printf("Device doesn't support RAW data-path APIs.\n");
11036 return TEST_SKIPPED;
11039 /* not supported with CPU crypto */
11040 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11041 return TEST_SKIPPED;
11043 /* Verify the capabilities */
11044 struct rte_cryptodev_sym_capability_idx cap_idx;
11045 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
11046 cap_idx.algo.aead = tdata->algo;
11047 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11049 return TEST_SKIPPED;
11051 /* alloc mbuf and set payload */
11052 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11054 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11055 rte_pktmbuf_tailroom(ut_params->ibuf));
11057 /* Create AEAD operation */
11058 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
11062 /* Create AEAD xform */
11063 memcpy(key, tdata->key.data, tdata->key.len);
11064 retval = create_aead_xform(ut_params->op,
11066 RTE_CRYPTO_AEAD_OP_DECRYPT,
11067 key, tdata->key.len,
11068 tdata->aad.len, tdata->auth_tag.len,
11073 ut_params->op->sym->m_src = ut_params->ibuf;
11075 TEST_ASSERT_EQUAL(ut_params->op->sess_type,
11076 RTE_CRYPTO_OP_SESSIONLESS,
11077 "crypto op session type not sessionless");
11079 /* Process crypto operation */
11080 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11081 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11082 ut_params->op, 0, 0, 0, 0);
11084 TEST_ASSERT_NOT_NULL(process_crypto_request(
11085 ts_params->valid_devs[0], ut_params->op),
11086 "failed to process sym crypto op");
11088 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
11090 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11091 "crypto op status not success");
11093 plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
11094 ut_params->op->sym->cipher.data.offset);
11096 debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
11098 /* Validate obuf */
11099 TEST_ASSERT_BUFFERS_ARE_EQUAL(
11101 tdata->plaintext.data,
11102 tdata->plaintext.len,
11103 "Plaintext data not as expected");
11105 TEST_ASSERT_EQUAL(ut_params->op->status,
11106 RTE_CRYPTO_OP_STATUS_SUCCESS,
11107 "Authentication failed");
11112 test_AES_GCM_authenticated_decryption_sessionless_test_case_1(void)
11114 return test_authenticated_decryption_sessionless(
11119 test_AES_CCM_authenticated_encryption_test_case_128_1(void)
11121 return test_authenticated_encryption(&ccm_test_case_128_1);
11125 test_AES_CCM_authenticated_encryption_test_case_128_2(void)
11127 return test_authenticated_encryption(&ccm_test_case_128_2);
11131 test_AES_CCM_authenticated_encryption_test_case_128_3(void)
11133 return test_authenticated_encryption(&ccm_test_case_128_3);
11137 test_AES_CCM_authenticated_decryption_test_case_128_1(void)
11139 return test_authenticated_decryption(&ccm_test_case_128_1);
11143 test_AES_CCM_authenticated_decryption_test_case_128_2(void)
11145 return test_authenticated_decryption(&ccm_test_case_128_2);
11149 test_AES_CCM_authenticated_decryption_test_case_128_3(void)
11151 return test_authenticated_decryption(&ccm_test_case_128_3);
11155 test_AES_CCM_authenticated_encryption_test_case_192_1(void)
11157 return test_authenticated_encryption(&ccm_test_case_192_1);
11161 test_AES_CCM_authenticated_encryption_test_case_192_2(void)
11163 return test_authenticated_encryption(&ccm_test_case_192_2);
11167 test_AES_CCM_authenticated_encryption_test_case_192_3(void)
11169 return test_authenticated_encryption(&ccm_test_case_192_3);
11173 test_AES_CCM_authenticated_decryption_test_case_192_1(void)
11175 return test_authenticated_decryption(&ccm_test_case_192_1);
11179 test_AES_CCM_authenticated_decryption_test_case_192_2(void)
11181 return test_authenticated_decryption(&ccm_test_case_192_2);
11185 test_AES_CCM_authenticated_decryption_test_case_192_3(void)
11187 return test_authenticated_decryption(&ccm_test_case_192_3);
11191 test_AES_CCM_authenticated_encryption_test_case_256_1(void)
11193 return test_authenticated_encryption(&ccm_test_case_256_1);
11197 test_AES_CCM_authenticated_encryption_test_case_256_2(void)
11199 return test_authenticated_encryption(&ccm_test_case_256_2);
11203 test_AES_CCM_authenticated_encryption_test_case_256_3(void)
11205 return test_authenticated_encryption(&ccm_test_case_256_3);
11209 test_AES_CCM_authenticated_decryption_test_case_256_1(void)
11211 return test_authenticated_decryption(&ccm_test_case_256_1);
11215 test_AES_CCM_authenticated_decryption_test_case_256_2(void)
11217 return test_authenticated_decryption(&ccm_test_case_256_2);
11221 test_AES_CCM_authenticated_decryption_test_case_256_3(void)
11223 return test_authenticated_decryption(&ccm_test_case_256_3);
11229 struct crypto_testsuite_params *ts_params = &testsuite_params;
11230 struct rte_cryptodev_stats stats;
11232 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11233 return TEST_SKIPPED;
11235 /* Verify the capabilities */
11236 struct rte_cryptodev_sym_capability_idx cap_idx;
11237 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11238 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
11239 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11241 return TEST_SKIPPED;
11242 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11243 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
11244 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11246 return TEST_SKIPPED;
11248 if (rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
11250 return TEST_SKIPPED;
11252 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
11253 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
11254 &stats) == -ENODEV),
11255 "rte_cryptodev_stats_get invalid dev failed");
11256 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
11257 "rte_cryptodev_stats_get invalid Param failed");
11259 /* Test expected values */
11260 test_AES_CBC_HMAC_SHA1_encrypt_digest();
11261 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
11263 "rte_cryptodev_stats_get failed");
11264 TEST_ASSERT((stats.enqueued_count == 1),
11265 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11266 TEST_ASSERT((stats.dequeued_count == 1),
11267 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11268 TEST_ASSERT((stats.enqueue_err_count == 0),
11269 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11270 TEST_ASSERT((stats.dequeue_err_count == 0),
11271 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11273 /* invalid device but should ignore and not reset device stats*/
11274 rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
11275 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
11277 "rte_cryptodev_stats_get failed");
11278 TEST_ASSERT((stats.enqueued_count == 1),
11279 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11281 /* check that a valid reset clears stats */
11282 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
11283 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
11285 "rte_cryptodev_stats_get failed");
11286 TEST_ASSERT((stats.enqueued_count == 0),
11287 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11288 TEST_ASSERT((stats.dequeued_count == 0),
11289 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11291 return TEST_SUCCESS;
11294 static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
11295 struct crypto_unittest_params *ut_params,
11296 enum rte_crypto_auth_operation op,
11297 const struct HMAC_MD5_vector *test_case)
11302 memcpy(key, test_case->key.data, test_case->key.len);
11304 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11305 ut_params->auth_xform.next = NULL;
11306 ut_params->auth_xform.auth.op = op;
11308 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC;
11310 ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN;
11311 ut_params->auth_xform.auth.key.length = test_case->key.len;
11312 ut_params->auth_xform.auth.key.data = key;
11314 ut_params->sess = rte_cryptodev_sym_session_create(
11315 ts_params->session_mpool);
11316 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
11317 if (ut_params->sess == NULL)
11318 return TEST_FAILED;
11320 status = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11321 ut_params->sess, &ut_params->auth_xform,
11322 ts_params->session_priv_mpool);
11323 if (status == -ENOTSUP)
11324 return TEST_SKIPPED;
11326 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11328 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11329 rte_pktmbuf_tailroom(ut_params->ibuf));
11334 static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
11335 const struct HMAC_MD5_vector *test_case,
11336 uint8_t **plaintext)
11338 uint16_t plaintext_pad_len;
11340 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
11342 plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
11345 *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11346 plaintext_pad_len);
11347 memcpy(*plaintext, test_case->plaintext.data,
11348 test_case->plaintext.len);
11350 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
11351 ut_params->ibuf, MD5_DIGEST_LEN);
11352 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
11353 "no room to append digest");
11354 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
11355 ut_params->ibuf, plaintext_pad_len);
11357 if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
11358 rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data,
11359 test_case->auth_tag.len);
11362 sym_op->auth.data.offset = 0;
11363 sym_op->auth.data.length = test_case->plaintext.len;
11365 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11366 ut_params->op->sym->m_src = ut_params->ibuf;
11372 test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
11374 uint16_t plaintext_pad_len;
11375 uint8_t *plaintext, *auth_tag;
11377 struct crypto_testsuite_params *ts_params = &testsuite_params;
11378 struct crypto_unittest_params *ut_params = &unittest_params;
11379 struct rte_cryptodev_info dev_info;
11381 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11382 uint64_t feat_flags = dev_info.feature_flags;
11384 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11385 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11386 printf("Device doesn't support RAW data-path APIs.\n");
11387 return TEST_SKIPPED;
11390 /* Verify the capabilities */
11391 struct rte_cryptodev_sym_capability_idx cap_idx;
11392 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11393 cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
11394 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11396 return TEST_SKIPPED;
11398 if (MD5_HMAC_create_session(ts_params, ut_params,
11399 RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
11400 return TEST_FAILED;
11402 /* Generate Crypto op data structure */
11403 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11404 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11405 TEST_ASSERT_NOT_NULL(ut_params->op,
11406 "Failed to allocate symmetric crypto operation struct");
11408 plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
11411 if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
11412 return TEST_FAILED;
11414 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11415 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11417 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11418 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11419 ut_params->op, 0, 1, 0, 0);
11421 TEST_ASSERT_NOT_NULL(
11422 process_crypto_request(ts_params->valid_devs[0],
11424 "failed to process sym crypto op");
11426 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11427 "crypto op processing failed");
11429 if (ut_params->op->sym->m_dst) {
11430 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
11431 uint8_t *, plaintext_pad_len);
11433 auth_tag = plaintext + plaintext_pad_len;
11436 TEST_ASSERT_BUFFERS_ARE_EQUAL(
11438 test_case->auth_tag.data,
11439 test_case->auth_tag.len,
11440 "HMAC_MD5 generated tag not as expected");
11442 return TEST_SUCCESS;
11446 test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
11448 uint8_t *plaintext;
11450 struct crypto_testsuite_params *ts_params = &testsuite_params;
11451 struct crypto_unittest_params *ut_params = &unittest_params;
11452 struct rte_cryptodev_info dev_info;
11454 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11455 uint64_t feat_flags = dev_info.feature_flags;
11457 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11458 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11459 printf("Device doesn't support RAW data-path APIs.\n");
11460 return TEST_SKIPPED;
11463 /* Verify the capabilities */
11464 struct rte_cryptodev_sym_capability_idx cap_idx;
11465 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11466 cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
11467 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11469 return TEST_SKIPPED;
11471 if (MD5_HMAC_create_session(ts_params, ut_params,
11472 RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
11473 return TEST_FAILED;
11476 /* Generate Crypto op data structure */
11477 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11478 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11479 TEST_ASSERT_NOT_NULL(ut_params->op,
11480 "Failed to allocate symmetric crypto operation struct");
11482 if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
11483 return TEST_FAILED;
11485 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11486 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11488 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11489 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11490 ut_params->op, 0, 1, 0, 0);
11492 TEST_ASSERT_NOT_NULL(
11493 process_crypto_request(ts_params->valid_devs[0],
11495 "failed to process sym crypto op");
11497 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11498 "HMAC_MD5 crypto op processing failed");
11500 return TEST_SUCCESS;
11504 test_MD5_HMAC_generate_case_1(void)
11506 return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1);
11510 test_MD5_HMAC_verify_case_1(void)
11512 return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1);
11516 test_MD5_HMAC_generate_case_2(void)
11518 return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2);
11522 test_MD5_HMAC_verify_case_2(void)
11524 return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2);
11528 test_multi_session(void)
11530 struct crypto_testsuite_params *ts_params = &testsuite_params;
11531 struct crypto_unittest_params *ut_params = &unittest_params;
11533 struct rte_cryptodev_info dev_info;
11534 struct rte_cryptodev_sym_session **sessions;
11539 /* Verify the capabilities */
11540 struct rte_cryptodev_sym_capability_idx cap_idx;
11541 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11542 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
11543 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11545 return TEST_SKIPPED;
11546 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11547 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
11548 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11550 return TEST_SKIPPED;
11552 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
11553 aes_cbc_key, hmac_sha512_key);
11556 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11558 sessions = rte_malloc(NULL,
11559 sizeof(struct rte_cryptodev_sym_session *) *
11560 (MAX_NB_SESSIONS + 1), 0);
11562 /* Create multiple crypto sessions*/
11563 for (i = 0; i < MAX_NB_SESSIONS; i++) {
11565 sessions[i] = rte_cryptodev_sym_session_create(
11566 ts_params->session_mpool);
11567 TEST_ASSERT_NOT_NULL(sessions[i],
11568 "Session creation failed at session number %u",
11571 status = rte_cryptodev_sym_session_init(
11572 ts_params->valid_devs[0],
11573 sessions[i], &ut_params->auth_xform,
11574 ts_params->session_priv_mpool);
11575 if (status == -ENOTSUP)
11576 return TEST_SKIPPED;
11578 /* Attempt to send a request on each session */
11579 TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform(
11583 catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
11584 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
11586 "Failed to perform decrypt on request number %u.", i);
11587 /* free crypto operation structure */
11589 rte_crypto_op_free(ut_params->op);
11592 * free mbuf - both obuf and ibuf are usually the same,
11593 * so check if they point at the same address is necessary,
11594 * to avoid freeing the mbuf twice.
11596 if (ut_params->obuf) {
11597 rte_pktmbuf_free(ut_params->obuf);
11598 if (ut_params->ibuf == ut_params->obuf)
11599 ut_params->ibuf = 0;
11600 ut_params->obuf = 0;
11602 if (ut_params->ibuf) {
11603 rte_pktmbuf_free(ut_params->ibuf);
11604 ut_params->ibuf = 0;
11608 sessions[i] = NULL;
11609 /* Next session create should fail */
11610 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11611 sessions[i], &ut_params->auth_xform,
11612 ts_params->session_priv_mpool);
11613 TEST_ASSERT_NULL(sessions[i],
11614 "Session creation succeeded unexpectedly!");
11616 for (i = 0; i < MAX_NB_SESSIONS; i++) {
11617 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
11619 rte_cryptodev_sym_session_free(sessions[i]);
11622 rte_free(sessions);
11624 return TEST_SUCCESS;
11627 struct multi_session_params {
11628 struct crypto_unittest_params ut_params;
11629 uint8_t *cipher_key;
11631 const uint8_t *cipher;
11632 const uint8_t *digest;
11636 #define MB_SESSION_NUMBER 3
11639 test_multi_session_random_usage(void)
11641 struct crypto_testsuite_params *ts_params = &testsuite_params;
11642 struct rte_cryptodev_info dev_info;
11643 struct rte_cryptodev_sym_session **sessions;
11645 struct multi_session_params ut_paramz[] = {
11648 .cipher_key = ms_aes_cbc_key0,
11649 .hmac_key = ms_hmac_key0,
11650 .cipher = ms_aes_cbc_cipher0,
11651 .digest = ms_hmac_digest0,
11652 .iv = ms_aes_cbc_iv0
11655 .cipher_key = ms_aes_cbc_key1,
11656 .hmac_key = ms_hmac_key1,
11657 .cipher = ms_aes_cbc_cipher1,
11658 .digest = ms_hmac_digest1,
11659 .iv = ms_aes_cbc_iv1
11662 .cipher_key = ms_aes_cbc_key2,
11663 .hmac_key = ms_hmac_key2,
11664 .cipher = ms_aes_cbc_cipher2,
11665 .digest = ms_hmac_digest2,
11666 .iv = ms_aes_cbc_iv2
11672 /* Verify the capabilities */
11673 struct rte_cryptodev_sym_capability_idx cap_idx;
11674 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11675 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
11676 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11678 return TEST_SKIPPED;
11679 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11680 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
11681 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11683 return TEST_SKIPPED;
11685 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11687 sessions = rte_malloc(NULL,
11688 (sizeof(struct rte_cryptodev_sym_session *)
11689 * MAX_NB_SESSIONS) + 1, 0);
11691 for (i = 0; i < MB_SESSION_NUMBER; i++) {
11692 sessions[i] = rte_cryptodev_sym_session_create(
11693 ts_params->session_mpool);
11694 TEST_ASSERT_NOT_NULL(sessions[i],
11695 "Session creation failed at session number %u",
11698 rte_memcpy(&ut_paramz[i].ut_params, &unittest_params,
11699 sizeof(struct crypto_unittest_params));
11701 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
11702 &ut_paramz[i].ut_params,
11703 ut_paramz[i].cipher_key, ut_paramz[i].hmac_key);
11705 /* Create multiple crypto sessions*/
11706 status = rte_cryptodev_sym_session_init(
11707 ts_params->valid_devs[0],
11709 &ut_paramz[i].ut_params.auth_xform,
11710 ts_params->session_priv_mpool);
11712 if (status == -ENOTSUP)
11713 return TEST_SKIPPED;
11715 TEST_ASSERT_EQUAL(status, 0, "Session init failed");
11719 for (i = 0; i < 40000; i++) {
11721 j = rand() % MB_SESSION_NUMBER;
11723 TEST_ASSERT_SUCCESS(
11724 test_AES_CBC_HMAC_SHA512_decrypt_perform(
11726 &ut_paramz[j].ut_params,
11727 ts_params, ut_paramz[j].cipher,
11728 ut_paramz[j].digest,
11730 "Failed to perform decrypt on request number %u.", i);
11732 if (ut_paramz[j].ut_params.op)
11733 rte_crypto_op_free(ut_paramz[j].ut_params.op);
11736 * free mbuf - both obuf and ibuf are usually the same,
11737 * so check if they point at the same address is necessary,
11738 * to avoid freeing the mbuf twice.
11740 if (ut_paramz[j].ut_params.obuf) {
11741 rte_pktmbuf_free(ut_paramz[j].ut_params.obuf);
11742 if (ut_paramz[j].ut_params.ibuf
11743 == ut_paramz[j].ut_params.obuf)
11744 ut_paramz[j].ut_params.ibuf = 0;
11745 ut_paramz[j].ut_params.obuf = 0;
11747 if (ut_paramz[j].ut_params.ibuf) {
11748 rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf);
11749 ut_paramz[j].ut_params.ibuf = 0;
11753 for (i = 0; i < MB_SESSION_NUMBER; i++) {
11754 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
11756 rte_cryptodev_sym_session_free(sessions[i]);
11759 rte_free(sessions);
11761 return TEST_SUCCESS;
11764 uint8_t orig_data[] = {0xab, 0xab, 0xab, 0xab,
11765 0xab, 0xab, 0xab, 0xab,
11766 0xab, 0xab, 0xab, 0xab,
11767 0xab, 0xab, 0xab, 0xab};
11770 test_null_invalid_operation(void)
11772 struct crypto_testsuite_params *ts_params = &testsuite_params;
11773 struct crypto_unittest_params *ut_params = &unittest_params;
11776 /* This test is for NULL PMD only */
11777 if (gbl_driver_id != rte_cryptodev_driver_id_get(
11778 RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
11779 return TEST_SKIPPED;
11781 /* Setup Cipher Parameters */
11782 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11783 ut_params->cipher_xform.next = NULL;
11785 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
11786 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
11788 ut_params->sess = rte_cryptodev_sym_session_create(
11789 ts_params->session_mpool);
11791 /* Create Crypto session*/
11792 ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11793 ut_params->sess, &ut_params->cipher_xform,
11794 ts_params->session_priv_mpool);
11795 TEST_ASSERT(ret < 0,
11796 "Session creation succeeded unexpectedly");
11799 /* Setup HMAC Parameters */
11800 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11801 ut_params->auth_xform.next = NULL;
11803 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
11804 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
11806 ut_params->sess = rte_cryptodev_sym_session_create(
11807 ts_params->session_mpool);
11809 /* Create Crypto session*/
11810 ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11811 ut_params->sess, &ut_params->auth_xform,
11812 ts_params->session_priv_mpool);
11813 TEST_ASSERT(ret < 0,
11814 "Session creation succeeded unexpectedly");
11816 return TEST_SUCCESS;
11820 #define NULL_BURST_LENGTH (32)
11823 test_null_burst_operation(void)
11825 struct crypto_testsuite_params *ts_params = &testsuite_params;
11826 struct crypto_unittest_params *ut_params = &unittest_params;
11829 unsigned i, burst_len = NULL_BURST_LENGTH;
11831 struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
11832 struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
11834 /* This test is for NULL PMD only */
11835 if (gbl_driver_id != rte_cryptodev_driver_id_get(
11836 RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
11837 return TEST_SKIPPED;
11839 /* Setup Cipher Parameters */
11840 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11841 ut_params->cipher_xform.next = &ut_params->auth_xform;
11843 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
11844 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
11846 /* Setup HMAC Parameters */
11847 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11848 ut_params->auth_xform.next = NULL;
11850 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
11851 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
11853 ut_params->sess = rte_cryptodev_sym_session_create(
11854 ts_params->session_mpool);
11855 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
11857 /* Create Crypto session*/
11858 status = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11859 ut_params->sess, &ut_params->cipher_xform,
11860 ts_params->session_priv_mpool);
11862 if (status == -ENOTSUP)
11863 return TEST_SKIPPED;
11865 TEST_ASSERT_EQUAL(status, 0, "Session init failed");
11867 TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
11868 RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
11869 burst_len, "failed to generate burst of crypto ops");
11871 /* Generate an operation for each mbuf in burst */
11872 for (i = 0; i < burst_len; i++) {
11873 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11875 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
11877 unsigned *data = (unsigned *)rte_pktmbuf_append(m,
11881 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
11883 burst[i]->sym->m_src = m;
11886 /* Process crypto operation */
11887 TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
11888 0, burst, burst_len),
11890 "Error enqueuing burst");
11892 TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
11893 0, burst_dequeued, burst_len),
11895 "Error dequeuing burst");
11898 for (i = 0; i < burst_len; i++) {
11900 *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
11901 *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
11903 "data not as expected");
11905 rte_pktmbuf_free(burst[i]->sym->m_src);
11906 rte_crypto_op_free(burst[i]);
11909 return TEST_SUCCESS;
11913 test_enq_callback(uint16_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops,
11914 uint16_t nb_ops, void *user_param)
11916 RTE_SET_USED(dev_id);
11917 RTE_SET_USED(qp_id);
11919 RTE_SET_USED(user_param);
11921 printf("crypto enqueue callback called\n");
11926 test_deq_callback(uint16_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops,
11927 uint16_t nb_ops, void *user_param)
11929 RTE_SET_USED(dev_id);
11930 RTE_SET_USED(qp_id);
11932 RTE_SET_USED(user_param);
11934 printf("crypto dequeue callback called\n");
11939 * Thread using enqueue/dequeue callback with RCU.
11942 test_enqdeq_callback_thread(void *arg)
11945 /* DP thread calls rte_cryptodev_enqueue_burst()/
11946 * rte_cryptodev_dequeue_burst() and invokes callback.
11948 test_null_burst_operation();
11953 test_enq_callback_setup(void)
11955 struct crypto_testsuite_params *ts_params = &testsuite_params;
11956 struct rte_cryptodev_info dev_info;
11957 struct rte_cryptodev_qp_conf qp_conf = {
11958 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
11961 struct rte_cryptodev_cb *cb;
11962 uint16_t qp_id = 0;
11964 /* Stop the device in case it's started so it can be configured */
11965 rte_cryptodev_stop(ts_params->valid_devs[0]);
11967 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11969 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
11971 "Failed to configure cryptodev %u",
11972 ts_params->valid_devs[0]);
11974 qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
11975 qp_conf.mp_session = ts_params->session_mpool;
11976 qp_conf.mp_session_private = ts_params->session_priv_mpool;
11978 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
11979 ts_params->valid_devs[0], qp_id, &qp_conf,
11980 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
11982 "rte_cryptodev_queue_pair_setup: num_inflights "
11983 "%u on qp %u on cryptodev %u",
11984 qp_conf.nb_descriptors, qp_id,
11985 ts_params->valid_devs[0]);
11987 /* Test with invalid crypto device */
11988 cb = rte_cryptodev_add_enq_callback(RTE_CRYPTO_MAX_DEVS,
11989 qp_id, test_enq_callback, NULL);
11990 TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11991 "cryptodev %u did not fail",
11992 qp_id, RTE_CRYPTO_MAX_DEVS);
11994 /* Test with invalid queue pair */
11995 cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
11996 dev_info.max_nb_queue_pairs + 1,
11997 test_enq_callback, NULL);
11998 TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11999 "cryptodev %u did not fail",
12000 dev_info.max_nb_queue_pairs + 1,
12001 ts_params->valid_devs[0]);
12003 /* Test with NULL callback */
12004 cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
12005 qp_id, NULL, NULL);
12006 TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12007 "cryptodev %u did not fail",
12008 qp_id, ts_params->valid_devs[0]);
12010 /* Test with valid configuration */
12011 cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
12012 qp_id, test_enq_callback, NULL);
12013 TEST_ASSERT_NOT_NULL(cb, "Failed test to add callback on "
12014 "qp %u on cryptodev %u",
12015 qp_id, ts_params->valid_devs[0]);
12017 rte_cryptodev_start(ts_params->valid_devs[0]);
12019 /* Launch a thread */
12020 rte_eal_remote_launch(test_enqdeq_callback_thread, NULL,
12021 rte_get_next_lcore(-1, 1, 0));
12023 /* Wait until reader exited. */
12024 rte_eal_mp_wait_lcore();
12026 /* Test with invalid crypto device */
12027 TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
12028 RTE_CRYPTO_MAX_DEVS, qp_id, cb),
12029 "Expected call to fail as crypto device is invalid");
12031 /* Test with invalid queue pair */
12032 TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
12033 ts_params->valid_devs[0],
12034 dev_info.max_nb_queue_pairs + 1, cb),
12035 "Expected call to fail as queue pair is invalid");
12037 /* Test with NULL callback */
12038 TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
12039 ts_params->valid_devs[0], qp_id, NULL),
12040 "Expected call to fail as callback is NULL");
12042 /* Test with valid configuration */
12043 TEST_ASSERT_SUCCESS(rte_cryptodev_remove_enq_callback(
12044 ts_params->valid_devs[0], qp_id, cb),
12045 "Failed test to remove callback on "
12046 "qp %u on cryptodev %u",
12047 qp_id, ts_params->valid_devs[0]);
12049 return TEST_SUCCESS;
12053 test_deq_callback_setup(void)
12055 struct crypto_testsuite_params *ts_params = &testsuite_params;
12056 struct rte_cryptodev_info dev_info;
12057 struct rte_cryptodev_qp_conf qp_conf = {
12058 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
12061 struct rte_cryptodev_cb *cb;
12062 uint16_t qp_id = 0;
12064 /* Stop the device in case it's started so it can be configured */
12065 rte_cryptodev_stop(ts_params->valid_devs[0]);
12067 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12069 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
12071 "Failed to configure cryptodev %u",
12072 ts_params->valid_devs[0]);
12074 qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
12075 qp_conf.mp_session = ts_params->session_mpool;
12076 qp_conf.mp_session_private = ts_params->session_priv_mpool;
12078 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
12079 ts_params->valid_devs[0], qp_id, &qp_conf,
12080 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
12082 "rte_cryptodev_queue_pair_setup: num_inflights "
12083 "%u on qp %u on cryptodev %u",
12084 qp_conf.nb_descriptors, qp_id,
12085 ts_params->valid_devs[0]);
12087 /* Test with invalid crypto device */
12088 cb = rte_cryptodev_add_deq_callback(RTE_CRYPTO_MAX_DEVS,
12089 qp_id, test_deq_callback, NULL);
12090 TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12091 "cryptodev %u did not fail",
12092 qp_id, RTE_CRYPTO_MAX_DEVS);
12094 /* Test with invalid queue pair */
12095 cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
12096 dev_info.max_nb_queue_pairs + 1,
12097 test_deq_callback, NULL);
12098 TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12099 "cryptodev %u did not fail",
12100 dev_info.max_nb_queue_pairs + 1,
12101 ts_params->valid_devs[0]);
12103 /* Test with NULL callback */
12104 cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
12105 qp_id, NULL, NULL);
12106 TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12107 "cryptodev %u did not fail",
12108 qp_id, ts_params->valid_devs[0]);
12110 /* Test with valid configuration */
12111 cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
12112 qp_id, test_deq_callback, NULL);
12113 TEST_ASSERT_NOT_NULL(cb, "Failed test to add callback on "
12114 "qp %u on cryptodev %u",
12115 qp_id, ts_params->valid_devs[0]);
12117 rte_cryptodev_start(ts_params->valid_devs[0]);
12119 /* Launch a thread */
12120 rte_eal_remote_launch(test_enqdeq_callback_thread, NULL,
12121 rte_get_next_lcore(-1, 1, 0));
12123 /* Wait until reader exited. */
12124 rte_eal_mp_wait_lcore();
12126 /* Test with invalid crypto device */
12127 TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
12128 RTE_CRYPTO_MAX_DEVS, qp_id, cb),
12129 "Expected call to fail as crypto device is invalid");
12131 /* Test with invalid queue pair */
12132 TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
12133 ts_params->valid_devs[0],
12134 dev_info.max_nb_queue_pairs + 1, cb),
12135 "Expected call to fail as queue pair is invalid");
12137 /* Test with NULL callback */
12138 TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
12139 ts_params->valid_devs[0], qp_id, NULL),
12140 "Expected call to fail as callback is NULL");
12142 /* Test with valid configuration */
12143 TEST_ASSERT_SUCCESS(rte_cryptodev_remove_deq_callback(
12144 ts_params->valid_devs[0], qp_id, cb),
12145 "Failed test to remove callback on "
12146 "qp %u on cryptodev %u",
12147 qp_id, ts_params->valid_devs[0]);
12149 return TEST_SUCCESS;
12153 generate_gmac_large_plaintext(uint8_t *data)
12157 for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32)
12158 memcpy(&data[i], &data[0], 32);
12162 create_gmac_operation(enum rte_crypto_auth_operation op,
12163 const struct gmac_test_data *tdata)
12165 struct crypto_testsuite_params *ts_params = &testsuite_params;
12166 struct crypto_unittest_params *ut_params = &unittest_params;
12167 struct rte_crypto_sym_op *sym_op;
12169 uint32_t plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
12171 /* Generate Crypto op data structure */
12172 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12173 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12174 TEST_ASSERT_NOT_NULL(ut_params->op,
12175 "Failed to allocate symmetric crypto operation struct");
12177 sym_op = ut_params->op->sym;
12179 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
12180 ut_params->ibuf, tdata->gmac_tag.len);
12181 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
12182 "no room to append digest");
12184 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
12185 ut_params->ibuf, plaintext_pad_len);
12187 if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
12188 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
12189 tdata->gmac_tag.len);
12190 debug_hexdump(stdout, "digest:",
12191 sym_op->auth.digest.data,
12192 tdata->gmac_tag.len);
12195 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
12196 uint8_t *, IV_OFFSET);
12198 rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
12200 debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
12202 sym_op->cipher.data.length = 0;
12203 sym_op->cipher.data.offset = 0;
12205 sym_op->auth.data.offset = 0;
12206 sym_op->auth.data.length = tdata->plaintext.len;
12212 create_gmac_operation_sgl(enum rte_crypto_auth_operation op,
12213 const struct gmac_test_data *tdata,
12214 void *digest_mem, uint64_t digest_phys)
12216 struct crypto_testsuite_params *ts_params = &testsuite_params;
12217 struct crypto_unittest_params *ut_params = &unittest_params;
12218 struct rte_crypto_sym_op *sym_op;
12220 /* Generate Crypto op data structure */
12221 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12222 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12223 TEST_ASSERT_NOT_NULL(ut_params->op,
12224 "Failed to allocate symmetric crypto operation struct");
12226 sym_op = ut_params->op->sym;
12228 sym_op->auth.digest.data = digest_mem;
12229 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
12230 "no room to append digest");
12232 sym_op->auth.digest.phys_addr = digest_phys;
12234 if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
12235 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
12236 tdata->gmac_tag.len);
12237 debug_hexdump(stdout, "digest:",
12238 sym_op->auth.digest.data,
12239 tdata->gmac_tag.len);
12242 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
12243 uint8_t *, IV_OFFSET);
12245 rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
12247 debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
12249 sym_op->cipher.data.length = 0;
12250 sym_op->cipher.data.offset = 0;
12252 sym_op->auth.data.offset = 0;
12253 sym_op->auth.data.length = tdata->plaintext.len;
12258 static int create_gmac_session(uint8_t dev_id,
12259 const struct gmac_test_data *tdata,
12260 enum rte_crypto_auth_operation auth_op)
12262 uint8_t auth_key[tdata->key.len];
12265 struct crypto_testsuite_params *ts_params = &testsuite_params;
12266 struct crypto_unittest_params *ut_params = &unittest_params;
12268 memcpy(auth_key, tdata->key.data, tdata->key.len);
12270 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12271 ut_params->auth_xform.next = NULL;
12273 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
12274 ut_params->auth_xform.auth.op = auth_op;
12275 ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
12276 ut_params->auth_xform.auth.key.length = tdata->key.len;
12277 ut_params->auth_xform.auth.key.data = auth_key;
12278 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
12279 ut_params->auth_xform.auth.iv.length = tdata->iv.len;
12282 ut_params->sess = rte_cryptodev_sym_session_create(
12283 ts_params->session_mpool);
12284 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12286 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
12287 &ut_params->auth_xform,
12288 ts_params->session_priv_mpool);
12294 test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
12296 struct crypto_testsuite_params *ts_params = &testsuite_params;
12297 struct crypto_unittest_params *ut_params = &unittest_params;
12298 struct rte_cryptodev_info dev_info;
12300 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12301 uint64_t feat_flags = dev_info.feature_flags;
12303 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12304 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12305 printf("Device doesn't support RAW data-path APIs.\n");
12306 return TEST_SKIPPED;
12311 uint8_t *auth_tag, *plaintext;
12312 uint16_t plaintext_pad_len;
12314 TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
12315 "No GMAC length in the source data");
12317 /* Verify the capabilities */
12318 struct rte_cryptodev_sym_capability_idx cap_idx;
12319 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12320 cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
12321 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12323 return TEST_SKIPPED;
12325 retval = create_gmac_session(ts_params->valid_devs[0],
12326 tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
12328 if (retval == -ENOTSUP)
12329 return TEST_SKIPPED;
12333 if (tdata->plaintext.len > MBUF_SIZE)
12334 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
12336 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12337 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12338 "Failed to allocate input buffer in mempool");
12340 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12341 rte_pktmbuf_tailroom(ut_params->ibuf));
12343 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
12345 * Runtime generate the large plain text instead of use hard code
12346 * plain text vector. It is done to avoid create huge source file
12347 * with the test vector.
12349 if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
12350 generate_gmac_large_plaintext(tdata->plaintext.data);
12352 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12353 plaintext_pad_len);
12354 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12356 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
12357 debug_hexdump(stdout, "plaintext:", plaintext,
12358 tdata->plaintext.len);
12360 retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
12366 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12368 ut_params->op->sym->m_src = ut_params->ibuf;
12370 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12371 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12373 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12374 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12375 ut_params->op, 0, 1, 0, 0);
12377 TEST_ASSERT_NOT_NULL(
12378 process_crypto_request(ts_params->valid_devs[0],
12379 ut_params->op), "failed to process sym crypto op");
12381 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12382 "crypto op processing failed");
12384 if (ut_params->op->sym->m_dst) {
12385 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
12386 uint8_t *, plaintext_pad_len);
12388 auth_tag = plaintext + plaintext_pad_len;
12391 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
12393 TEST_ASSERT_BUFFERS_ARE_EQUAL(
12395 tdata->gmac_tag.data,
12396 tdata->gmac_tag.len,
12397 "GMAC Generated auth tag not as expected");
12403 test_AES_GMAC_authentication_test_case_1(void)
12405 return test_AES_GMAC_authentication(&gmac_test_case_1);
12409 test_AES_GMAC_authentication_test_case_2(void)
12411 return test_AES_GMAC_authentication(&gmac_test_case_2);
12415 test_AES_GMAC_authentication_test_case_3(void)
12417 return test_AES_GMAC_authentication(&gmac_test_case_3);
12421 test_AES_GMAC_authentication_test_case_4(void)
12423 return test_AES_GMAC_authentication(&gmac_test_case_4);
12427 test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
12429 struct crypto_testsuite_params *ts_params = &testsuite_params;
12430 struct crypto_unittest_params *ut_params = &unittest_params;
12432 uint32_t plaintext_pad_len;
12433 uint8_t *plaintext;
12434 struct rte_cryptodev_info dev_info;
12436 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12437 uint64_t feat_flags = dev_info.feature_flags;
12439 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12440 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12441 printf("Device doesn't support RAW data-path APIs.\n");
12442 return TEST_SKIPPED;
12445 TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
12446 "No GMAC length in the source data");
12448 /* Verify the capabilities */
12449 struct rte_cryptodev_sym_capability_idx cap_idx;
12450 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12451 cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
12452 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12454 return TEST_SKIPPED;
12456 retval = create_gmac_session(ts_params->valid_devs[0],
12457 tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
12459 if (retval == -ENOTSUP)
12460 return TEST_SKIPPED;
12464 if (tdata->plaintext.len > MBUF_SIZE)
12465 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
12467 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12468 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12469 "Failed to allocate input buffer in mempool");
12471 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12472 rte_pktmbuf_tailroom(ut_params->ibuf));
12474 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
12477 * Runtime generate the large plain text instead of use hard code
12478 * plain text vector. It is done to avoid create huge source file
12479 * with the test vector.
12481 if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
12482 generate_gmac_large_plaintext(tdata->plaintext.data);
12484 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12485 plaintext_pad_len);
12486 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12488 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
12489 debug_hexdump(stdout, "plaintext:", plaintext,
12490 tdata->plaintext.len);
12492 retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
12498 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12500 ut_params->op->sym->m_src = ut_params->ibuf;
12502 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12503 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12505 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12506 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12507 ut_params->op, 0, 1, 0, 0);
12509 TEST_ASSERT_NOT_NULL(
12510 process_crypto_request(ts_params->valid_devs[0],
12511 ut_params->op), "failed to process sym crypto op");
12513 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12514 "crypto op processing failed");
12521 test_AES_GMAC_authentication_verify_test_case_1(void)
12523 return test_AES_GMAC_authentication_verify(&gmac_test_case_1);
12527 test_AES_GMAC_authentication_verify_test_case_2(void)
12529 return test_AES_GMAC_authentication_verify(&gmac_test_case_2);
12533 test_AES_GMAC_authentication_verify_test_case_3(void)
12535 return test_AES_GMAC_authentication_verify(&gmac_test_case_3);
12539 test_AES_GMAC_authentication_verify_test_case_4(void)
12541 return test_AES_GMAC_authentication_verify(&gmac_test_case_4);
12545 test_AES_GMAC_authentication_SGL(const struct gmac_test_data *tdata,
12548 struct crypto_testsuite_params *ts_params = &testsuite_params;
12549 struct crypto_unittest_params *ut_params = &unittest_params;
12550 struct rte_cryptodev_info dev_info;
12551 uint64_t feature_flags;
12552 unsigned int trn_data = 0;
12553 void *digest_mem = NULL;
12555 unsigned int to_trn = 0;
12556 struct rte_mbuf *buf = NULL;
12557 uint8_t *auth_tag, *plaintext;
12560 TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
12561 "No GMAC length in the source data");
12563 /* Verify the capabilities */
12564 struct rte_cryptodev_sym_capability_idx cap_idx;
12565 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12566 cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
12567 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12569 return TEST_SKIPPED;
12571 /* Check for any input SGL support */
12572 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12573 feature_flags = dev_info.feature_flags;
12575 if ((!(feature_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) ||
12576 (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT)) ||
12577 (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)))
12578 return TEST_SKIPPED;
12580 if (fragsz > tdata->plaintext.len)
12581 fragsz = tdata->plaintext.len;
12583 uint16_t plaintext_len = fragsz;
12585 retval = create_gmac_session(ts_params->valid_devs[0],
12586 tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
12588 if (retval == -ENOTSUP)
12589 return TEST_SKIPPED;
12593 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12594 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12595 "Failed to allocate input buffer in mempool");
12597 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12598 rte_pktmbuf_tailroom(ut_params->ibuf));
12600 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12602 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12604 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
12606 trn_data += plaintext_len;
12608 buf = ut_params->ibuf;
12611 * Loop until no more fragments
12614 while (trn_data < tdata->plaintext.len) {
12616 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
12617 (tdata->plaintext.len - trn_data) : fragsz;
12619 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12622 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
12623 rte_pktmbuf_tailroom(buf));
12625 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
12628 memcpy(plaintext, tdata->plaintext.data + trn_data,
12630 trn_data += to_trn;
12631 if (trn_data == tdata->plaintext.len)
12632 digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
12633 tdata->gmac_tag.len);
12635 ut_params->ibuf->nb_segs = segs;
12638 * Place digest at the end of the last buffer
12640 uint64_t digest_phys = rte_pktmbuf_iova(buf) + to_trn;
12643 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12644 + tdata->gmac_tag.len);
12645 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
12646 tdata->plaintext.len);
12649 retval = create_gmac_operation_sgl(RTE_CRYPTO_AUTH_OP_GENERATE,
12650 tdata, digest_mem, digest_phys);
12655 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12657 ut_params->op->sym->m_src = ut_params->ibuf;
12659 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12660 return TEST_SKIPPED;
12662 TEST_ASSERT_NOT_NULL(
12663 process_crypto_request(ts_params->valid_devs[0],
12664 ut_params->op), "failed to process sym crypto op");
12666 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12667 "crypto op processing failed");
12669 auth_tag = digest_mem;
12670 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
12671 TEST_ASSERT_BUFFERS_ARE_EQUAL(
12673 tdata->gmac_tag.data,
12674 tdata->gmac_tag.len,
12675 "GMAC Generated auth tag not as expected");
12680 /* Segment size not multiple of block size (16B) */
12682 test_AES_GMAC_authentication_SGL_40B(void)
12684 return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 40);
12688 test_AES_GMAC_authentication_SGL_80B(void)
12690 return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 80);
12694 test_AES_GMAC_authentication_SGL_2048B(void)
12696 return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2048);
12699 /* Segment size not multiple of block size (16B) */
12701 test_AES_GMAC_authentication_SGL_2047B(void)
12703 return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2047);
12706 struct test_crypto_vector {
12707 enum rte_crypto_cipher_algorithm crypto_algo;
12708 unsigned int cipher_offset;
12709 unsigned int cipher_len;
12722 const uint8_t *data;
12727 const uint8_t *data;
12731 enum rte_crypto_auth_algorithm auth_algo;
12732 unsigned int auth_offset;
12740 const uint8_t *data;
12750 static const struct test_crypto_vector
12751 hmac_sha1_test_crypto_vector = {
12752 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
12754 .data = plaintext_hash,
12759 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
12760 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
12761 0xDE, 0xF4, 0xDE, 0xAD
12767 0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
12768 0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
12769 0x3F, 0x91, 0x64, 0x59
12775 static const struct test_crypto_vector
12776 aes128_gmac_test_vector = {
12777 .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
12779 .data = plaintext_hash,
12784 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
12785 0x08, 0x09, 0x0A, 0x0B
12791 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
12792 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
12798 0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56,
12799 0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A
12805 static const struct test_crypto_vector
12806 aes128cbc_hmac_sha1_test_vector = {
12807 .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
12808 .cipher_offset = 0,
12812 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
12813 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
12819 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
12820 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
12825 .data = plaintext_hash,
12829 .data = ciphertext512_aes128cbc,
12832 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
12836 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
12837 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
12838 0xDE, 0xF4, 0xDE, 0xAD
12844 0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
12845 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
12846 0x18, 0x8C, 0x1D, 0x32
12852 static const struct test_crypto_vector
12853 aes128cbc_hmac_sha1_aad_test_vector = {
12854 .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
12855 .cipher_offset = 8,
12859 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
12860 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
12866 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
12867 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
12872 .data = plaintext_hash,
12876 .data = ciphertext512_aes128cbc_aad,
12879 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
12883 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
12884 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
12885 0xDE, 0xF4, 0xDE, 0xAD
12891 0x6D, 0xF3, 0x50, 0x79, 0x7A, 0x2A, 0xAC, 0x7F,
12892 0xA6, 0xF0, 0xC6, 0x38, 0x1F, 0xA4, 0xDD, 0x9B,
12893 0x62, 0x0F, 0xFB, 0x10
12900 data_corruption(uint8_t *data)
12906 tag_corruption(uint8_t *data, unsigned int tag_offset)
12908 data[tag_offset] += 1;
12912 create_auth_session(struct crypto_unittest_params *ut_params,
12914 const struct test_crypto_vector *reference,
12915 enum rte_crypto_auth_operation auth_op)
12917 struct crypto_testsuite_params *ts_params = &testsuite_params;
12918 uint8_t auth_key[reference->auth_key.len + 1];
12921 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
12923 /* Setup Authentication Parameters */
12924 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12925 ut_params->auth_xform.auth.op = auth_op;
12926 ut_params->auth_xform.next = NULL;
12927 ut_params->auth_xform.auth.algo = reference->auth_algo;
12928 ut_params->auth_xform.auth.key.length = reference->auth_key.len;
12929 ut_params->auth_xform.auth.key.data = auth_key;
12930 ut_params->auth_xform.auth.digest_length = reference->digest.len;
12932 /* Create Crypto session*/
12933 ut_params->sess = rte_cryptodev_sym_session_create(
12934 ts_params->session_mpool);
12935 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12937 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
12938 &ut_params->auth_xform,
12939 ts_params->session_priv_mpool);
12945 create_auth_cipher_session(struct crypto_unittest_params *ut_params,
12947 const struct test_crypto_vector *reference,
12948 enum rte_crypto_auth_operation auth_op,
12949 enum rte_crypto_cipher_operation cipher_op)
12951 struct crypto_testsuite_params *ts_params = &testsuite_params;
12952 uint8_t cipher_key[reference->cipher_key.len + 1];
12953 uint8_t auth_key[reference->auth_key.len + 1];
12956 memcpy(cipher_key, reference->cipher_key.data,
12957 reference->cipher_key.len);
12958 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
12960 /* Setup Authentication Parameters */
12961 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12962 ut_params->auth_xform.auth.op = auth_op;
12963 ut_params->auth_xform.auth.algo = reference->auth_algo;
12964 ut_params->auth_xform.auth.key.length = reference->auth_key.len;
12965 ut_params->auth_xform.auth.key.data = auth_key;
12966 ut_params->auth_xform.auth.digest_length = reference->digest.len;
12968 if (reference->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) {
12969 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
12970 ut_params->auth_xform.auth.iv.length = reference->iv.len;
12972 ut_params->auth_xform.next = &ut_params->cipher_xform;
12974 /* Setup Cipher Parameters */
12975 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12976 ut_params->cipher_xform.next = NULL;
12977 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
12978 ut_params->cipher_xform.cipher.op = cipher_op;
12979 ut_params->cipher_xform.cipher.key.data = cipher_key;
12980 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
12981 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
12982 ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
12985 /* Create Crypto session*/
12986 ut_params->sess = rte_cryptodev_sym_session_create(
12987 ts_params->session_mpool);
12988 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12990 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
12991 &ut_params->auth_xform,
12992 ts_params->session_priv_mpool);
12998 create_auth_operation(struct crypto_testsuite_params *ts_params,
12999 struct crypto_unittest_params *ut_params,
13000 const struct test_crypto_vector *reference,
13001 unsigned int auth_generate)
13003 /* Generate Crypto op data structure */
13004 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
13005 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
13006 TEST_ASSERT_NOT_NULL(ut_params->op,
13007 "Failed to allocate pktmbuf offload");
13009 /* Set crypto operation data parameters */
13010 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
13012 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
13014 /* set crypto operation source mbuf */
13015 sym_op->m_src = ut_params->ibuf;
13018 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
13019 ut_params->ibuf, reference->digest.len);
13021 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
13022 "no room to append auth tag");
13024 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
13025 ut_params->ibuf, reference->plaintext.len);
13028 memset(sym_op->auth.digest.data, 0, reference->digest.len);
13030 memcpy(sym_op->auth.digest.data,
13031 reference->digest.data,
13032 reference->digest.len);
13034 debug_hexdump(stdout, "digest:",
13035 sym_op->auth.digest.data,
13036 reference->digest.len);
13038 sym_op->auth.data.length = reference->plaintext.len;
13039 sym_op->auth.data.offset = 0;
13045 create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
13046 struct crypto_unittest_params *ut_params,
13047 const struct test_crypto_vector *reference,
13048 unsigned int auth_generate)
13050 /* Generate Crypto op data structure */
13051 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
13052 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
13053 TEST_ASSERT_NOT_NULL(ut_params->op,
13054 "Failed to allocate pktmbuf offload");
13056 /* Set crypto operation data parameters */
13057 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
13059 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
13061 /* set crypto operation source mbuf */
13062 sym_op->m_src = ut_params->ibuf;
13065 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
13066 ut_params->ibuf, reference->digest.len);
13068 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
13069 "no room to append auth tag");
13071 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
13072 ut_params->ibuf, reference->ciphertext.len);
13075 memset(sym_op->auth.digest.data, 0, reference->digest.len);
13077 memcpy(sym_op->auth.digest.data,
13078 reference->digest.data,
13079 reference->digest.len);
13081 debug_hexdump(stdout, "digest:",
13082 sym_op->auth.digest.data,
13083 reference->digest.len);
13085 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
13086 reference->iv.data, reference->iv.len);
13088 sym_op->cipher.data.length = 0;
13089 sym_op->cipher.data.offset = 0;
13091 sym_op->auth.data.length = reference->plaintext.len;
13092 sym_op->auth.data.offset = 0;
13098 create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
13099 struct crypto_unittest_params *ut_params,
13100 const struct test_crypto_vector *reference,
13101 unsigned int auth_generate)
13103 /* Generate Crypto op data structure */
13104 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
13105 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
13106 TEST_ASSERT_NOT_NULL(ut_params->op,
13107 "Failed to allocate pktmbuf offload");
13109 /* Set crypto operation data parameters */
13110 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
13112 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
13114 /* set crypto operation source mbuf */
13115 sym_op->m_src = ut_params->ibuf;
13118 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
13119 ut_params->ibuf, reference->digest.len);
13121 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
13122 "no room to append auth tag");
13124 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
13125 ut_params->ibuf, reference->ciphertext.len);
13128 memset(sym_op->auth.digest.data, 0, reference->digest.len);
13130 memcpy(sym_op->auth.digest.data,
13131 reference->digest.data,
13132 reference->digest.len);
13134 debug_hexdump(stdout, "digest:",
13135 sym_op->auth.digest.data,
13136 reference->digest.len);
13138 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
13139 reference->iv.data, reference->iv.len);
13141 sym_op->cipher.data.length = reference->cipher_len;
13142 sym_op->cipher.data.offset = reference->cipher_offset;
13144 sym_op->auth.data.length = reference->plaintext.len;
13145 sym_op->auth.data.offset = reference->auth_offset;
13151 create_auth_verify_operation(struct crypto_testsuite_params *ts_params,
13152 struct crypto_unittest_params *ut_params,
13153 const struct test_crypto_vector *reference)
13155 return create_auth_operation(ts_params, ut_params, reference, 0);
13159 create_auth_verify_GMAC_operation(
13160 struct crypto_testsuite_params *ts_params,
13161 struct crypto_unittest_params *ut_params,
13162 const struct test_crypto_vector *reference)
13164 return create_auth_GMAC_operation(ts_params, ut_params, reference, 0);
13168 create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params,
13169 struct crypto_unittest_params *ut_params,
13170 const struct test_crypto_vector *reference)
13172 return create_cipher_auth_operation(ts_params, ut_params, reference, 0);
13176 test_authentication_verify_fail_when_data_corruption(
13177 struct crypto_testsuite_params *ts_params,
13178 struct crypto_unittest_params *ut_params,
13179 const struct test_crypto_vector *reference,
13180 unsigned int data_corrupted)
13184 uint8_t *plaintext;
13185 struct rte_cryptodev_info dev_info;
13187 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13188 uint64_t feat_flags = dev_info.feature_flags;
13190 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13191 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13192 printf("Device doesn't support RAW data-path APIs.\n");
13193 return TEST_SKIPPED;
13196 /* Verify the capabilities */
13197 struct rte_cryptodev_sym_capability_idx cap_idx;
13198 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13199 cap_idx.algo.auth = reference->auth_algo;
13200 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13202 return TEST_SKIPPED;
13205 /* Create session */
13206 retval = create_auth_session(ut_params,
13207 ts_params->valid_devs[0],
13209 RTE_CRYPTO_AUTH_OP_VERIFY);
13211 if (retval == -ENOTSUP)
13212 return TEST_SKIPPED;
13216 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13217 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13218 "Failed to allocate input buffer in mempool");
13220 /* clear mbuf payload */
13221 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13222 rte_pktmbuf_tailroom(ut_params->ibuf));
13224 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13225 reference->plaintext.len);
13226 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
13227 memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
13229 debug_hexdump(stdout, "plaintext:", plaintext,
13230 reference->plaintext.len);
13232 /* Create operation */
13233 retval = create_auth_verify_operation(ts_params, ut_params, reference);
13238 if (data_corrupted)
13239 data_corruption(plaintext);
13241 tag_corruption(plaintext, reference->plaintext.len);
13243 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
13244 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13246 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
13247 RTE_CRYPTO_OP_STATUS_SUCCESS,
13248 "authentication not failed");
13249 } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13250 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13251 ut_params->op, 0, 1, 0, 0);
13253 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13256 if (ut_params->op == NULL)
13258 else if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS)
13265 test_authentication_verify_GMAC_fail_when_corruption(
13266 struct crypto_testsuite_params *ts_params,
13267 struct crypto_unittest_params *ut_params,
13268 const struct test_crypto_vector *reference,
13269 unsigned int data_corrupted)
13272 uint8_t *plaintext;
13273 struct rte_cryptodev_info dev_info;
13275 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13276 uint64_t feat_flags = dev_info.feature_flags;
13278 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13279 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13280 printf("Device doesn't support RAW data-path APIs.\n");
13281 return TEST_SKIPPED;
13284 /* Verify the capabilities */
13285 struct rte_cryptodev_sym_capability_idx cap_idx;
13286 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13287 cap_idx.algo.auth = reference->auth_algo;
13288 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13290 return TEST_SKIPPED;
13292 /* Create session */
13293 retval = create_auth_cipher_session(ut_params,
13294 ts_params->valid_devs[0],
13296 RTE_CRYPTO_AUTH_OP_VERIFY,
13297 RTE_CRYPTO_CIPHER_OP_DECRYPT);
13301 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13302 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13303 "Failed to allocate input buffer in mempool");
13305 /* clear mbuf payload */
13306 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13307 rte_pktmbuf_tailroom(ut_params->ibuf));
13309 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13310 reference->plaintext.len);
13311 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
13312 memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
13314 debug_hexdump(stdout, "plaintext:", plaintext,
13315 reference->plaintext.len);
13317 /* Create operation */
13318 retval = create_auth_verify_GMAC_operation(ts_params,
13325 if (data_corrupted)
13326 data_corruption(plaintext);
13328 tag_corruption(plaintext, reference->aad.len);
13330 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
13331 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13333 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
13334 RTE_CRYPTO_OP_STATUS_SUCCESS,
13335 "authentication not failed");
13336 } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13337 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13338 ut_params->op, 0, 1, 0, 0);
13340 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13342 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
13349 test_authenticated_decryption_fail_when_corruption(
13350 struct crypto_testsuite_params *ts_params,
13351 struct crypto_unittest_params *ut_params,
13352 const struct test_crypto_vector *reference,
13353 unsigned int data_corrupted)
13357 uint8_t *ciphertext;
13358 struct rte_cryptodev_info dev_info;
13360 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13361 uint64_t feat_flags = dev_info.feature_flags;
13363 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13364 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13365 printf("Device doesn't support RAW data-path APIs.\n");
13366 return TEST_SKIPPED;
13369 /* Verify the capabilities */
13370 struct rte_cryptodev_sym_capability_idx cap_idx;
13371 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13372 cap_idx.algo.auth = reference->auth_algo;
13373 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13375 return TEST_SKIPPED;
13376 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13377 cap_idx.algo.cipher = reference->crypto_algo;
13378 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13380 return TEST_SKIPPED;
13382 /* Create session */
13383 retval = create_auth_cipher_session(ut_params,
13384 ts_params->valid_devs[0],
13386 RTE_CRYPTO_AUTH_OP_VERIFY,
13387 RTE_CRYPTO_CIPHER_OP_DECRYPT);
13389 if (retval == -ENOTSUP)
13390 return TEST_SKIPPED;
13394 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13395 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13396 "Failed to allocate input buffer in mempool");
13398 /* clear mbuf payload */
13399 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13400 rte_pktmbuf_tailroom(ut_params->ibuf));
13402 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13403 reference->ciphertext.len);
13404 TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
13405 memcpy(ciphertext, reference->ciphertext.data,
13406 reference->ciphertext.len);
13408 /* Create operation */
13409 retval = create_cipher_auth_verify_operation(ts_params,
13416 if (data_corrupted)
13417 data_corruption(ciphertext);
13419 tag_corruption(ciphertext, reference->ciphertext.len);
13421 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
13422 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13424 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
13425 RTE_CRYPTO_OP_STATUS_SUCCESS,
13426 "authentication not failed");
13427 } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13428 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13429 ut_params->op, 1, 1, 0, 0);
13431 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13433 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
13440 test_authenticated_encrypt_with_esn(
13441 struct crypto_testsuite_params *ts_params,
13442 struct crypto_unittest_params *ut_params,
13443 const struct test_crypto_vector *reference)
13447 uint8_t *authciphertext, *plaintext, *auth_tag;
13448 uint16_t plaintext_pad_len;
13449 uint8_t cipher_key[reference->cipher_key.len + 1];
13450 uint8_t auth_key[reference->auth_key.len + 1];
13451 struct rte_cryptodev_info dev_info;
13454 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13455 uint64_t feat_flags = dev_info.feature_flags;
13457 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13458 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13459 printf("Device doesn't support RAW data-path APIs.\n");
13460 return TEST_SKIPPED;
13463 /* Verify the capabilities */
13464 struct rte_cryptodev_sym_capability_idx cap_idx;
13465 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13466 cap_idx.algo.auth = reference->auth_algo;
13467 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13469 return TEST_SKIPPED;
13470 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13471 cap_idx.algo.cipher = reference->crypto_algo;
13472 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13474 return TEST_SKIPPED;
13476 /* Create session */
13477 memcpy(cipher_key, reference->cipher_key.data,
13478 reference->cipher_key.len);
13479 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
13481 /* Setup Cipher Parameters */
13482 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13483 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
13484 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
13485 ut_params->cipher_xform.cipher.key.data = cipher_key;
13486 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
13487 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
13488 ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
13490 ut_params->cipher_xform.next = &ut_params->auth_xform;
13492 /* Setup Authentication Parameters */
13493 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13494 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
13495 ut_params->auth_xform.auth.algo = reference->auth_algo;
13496 ut_params->auth_xform.auth.key.length = reference->auth_key.len;
13497 ut_params->auth_xform.auth.key.data = auth_key;
13498 ut_params->auth_xform.auth.digest_length = reference->digest.len;
13499 ut_params->auth_xform.next = NULL;
13501 /* Create Crypto session*/
13502 ut_params->sess = rte_cryptodev_sym_session_create(
13503 ts_params->session_mpool);
13504 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
13506 status = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
13508 &ut_params->cipher_xform,
13509 ts_params->session_priv_mpool);
13511 if (status == -ENOTSUP)
13512 return TEST_SKIPPED;
13514 TEST_ASSERT_EQUAL(status, 0, "Session init failed");
13516 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13517 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13518 "Failed to allocate input buffer in mempool");
13520 /* clear mbuf payload */
13521 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13522 rte_pktmbuf_tailroom(ut_params->ibuf));
13524 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13525 reference->plaintext.len);
13526 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
13527 memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
13529 /* Create operation */
13530 retval = create_cipher_auth_operation(ts_params,
13537 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13538 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13540 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13541 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13542 ut_params->op, 1, 1, 0, 0);
13544 ut_params->op = process_crypto_request(
13545 ts_params->valid_devs[0], ut_params->op);
13547 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
13549 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
13550 "crypto op processing failed");
13552 plaintext_pad_len = RTE_ALIGN_CEIL(reference->plaintext.len, 16);
13554 authciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
13555 ut_params->op->sym->auth.data.offset);
13556 auth_tag = authciphertext + plaintext_pad_len;
13557 debug_hexdump(stdout, "ciphertext:", authciphertext,
13558 reference->ciphertext.len);
13559 debug_hexdump(stdout, "auth tag:", auth_tag, reference->digest.len);
13561 /* Validate obuf */
13562 TEST_ASSERT_BUFFERS_ARE_EQUAL(
13564 reference->ciphertext.data,
13565 reference->ciphertext.len,
13566 "Ciphertext data not as expected");
13568 TEST_ASSERT_BUFFERS_ARE_EQUAL(
13570 reference->digest.data,
13571 reference->digest.len,
13572 "Generated digest not as expected");
13574 return TEST_SUCCESS;
13579 test_authenticated_decrypt_with_esn(
13580 struct crypto_testsuite_params *ts_params,
13581 struct crypto_unittest_params *ut_params,
13582 const struct test_crypto_vector *reference)
13586 uint8_t *ciphertext;
13587 uint8_t cipher_key[reference->cipher_key.len + 1];
13588 uint8_t auth_key[reference->auth_key.len + 1];
13589 struct rte_cryptodev_info dev_info;
13591 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13592 uint64_t feat_flags = dev_info.feature_flags;
13594 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13595 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13596 printf("Device doesn't support RAW data-path APIs.\n");
13597 return TEST_SKIPPED;
13600 /* Verify the capabilities */
13601 struct rte_cryptodev_sym_capability_idx cap_idx;
13602 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13603 cap_idx.algo.auth = reference->auth_algo;
13604 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13606 return TEST_SKIPPED;
13607 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13608 cap_idx.algo.cipher = reference->crypto_algo;
13609 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13611 return TEST_SKIPPED;
13613 /* Create session */
13614 memcpy(cipher_key, reference->cipher_key.data,
13615 reference->cipher_key.len);
13616 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
13618 /* Setup Authentication Parameters */
13619 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13620 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
13621 ut_params->auth_xform.auth.algo = reference->auth_algo;
13622 ut_params->auth_xform.auth.key.length = reference->auth_key.len;
13623 ut_params->auth_xform.auth.key.data = auth_key;
13624 ut_params->auth_xform.auth.digest_length = reference->digest.len;
13625 ut_params->auth_xform.next = &ut_params->cipher_xform;
13627 /* Setup Cipher Parameters */
13628 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13629 ut_params->cipher_xform.next = NULL;
13630 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
13631 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
13632 ut_params->cipher_xform.cipher.key.data = cipher_key;
13633 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
13634 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
13635 ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
13637 /* Create Crypto session*/
13638 ut_params->sess = rte_cryptodev_sym_session_create(
13639 ts_params->session_mpool);
13640 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
13642 retval = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
13644 &ut_params->auth_xform,
13645 ts_params->session_priv_mpool);
13647 if (retval == -ENOTSUP)
13648 return TEST_SKIPPED;
13650 TEST_ASSERT_EQUAL(retval, 0, "Session init failed");
13652 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13653 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13654 "Failed to allocate input buffer in mempool");
13656 /* clear mbuf payload */
13657 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13658 rte_pktmbuf_tailroom(ut_params->ibuf));
13660 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13661 reference->ciphertext.len);
13662 TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
13663 memcpy(ciphertext, reference->ciphertext.data,
13664 reference->ciphertext.len);
13666 /* Create operation */
13667 retval = create_cipher_auth_verify_operation(ts_params,
13674 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13675 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13677 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13678 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13679 ut_params->op, 1, 1, 0, 0);
13681 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13684 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
13685 TEST_ASSERT_EQUAL(ut_params->op->status,
13686 RTE_CRYPTO_OP_STATUS_SUCCESS,
13687 "crypto op processing passed");
13689 ut_params->obuf = ut_params->op->sym->m_src;
13690 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
13696 create_aead_operation_SGL(enum rte_crypto_aead_operation op,
13697 const struct aead_test_data *tdata,
13698 void *digest_mem, uint64_t digest_phys)
13700 struct crypto_testsuite_params *ts_params = &testsuite_params;
13701 struct crypto_unittest_params *ut_params = &unittest_params;
13703 const unsigned int auth_tag_len = tdata->auth_tag.len;
13704 const unsigned int iv_len = tdata->iv.len;
13705 unsigned int aad_len = tdata->aad.len;
13706 unsigned int aad_len_pad = 0;
13708 /* Generate Crypto op data structure */
13709 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
13710 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
13711 TEST_ASSERT_NOT_NULL(ut_params->op,
13712 "Failed to allocate symmetric crypto operation struct");
13714 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
13716 sym_op->aead.digest.data = digest_mem;
13718 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
13719 "no room to append digest");
13721 sym_op->aead.digest.phys_addr = digest_phys;
13723 if (op == RTE_CRYPTO_AEAD_OP_DECRYPT) {
13724 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
13726 debug_hexdump(stdout, "digest:",
13727 sym_op->aead.digest.data,
13731 /* Append aad data */
13732 if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
13733 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
13734 uint8_t *, IV_OFFSET);
13736 /* Copy IV 1 byte after the IV pointer, according to the API */
13737 rte_memcpy(iv_ptr + 1, tdata->iv.data, iv_len);
13739 aad_len = RTE_ALIGN_CEIL(aad_len + 18, 16);
13741 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
13742 ut_params->ibuf, aad_len);
13743 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
13744 "no room to prepend aad");
13745 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
13748 memset(sym_op->aead.aad.data, 0, aad_len);
13749 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
13750 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
13752 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
13753 debug_hexdump(stdout, "aad:",
13754 sym_op->aead.aad.data, aad_len);
13756 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
13757 uint8_t *, IV_OFFSET);
13759 rte_memcpy(iv_ptr, tdata->iv.data, iv_len);
13761 aad_len_pad = RTE_ALIGN_CEIL(aad_len, 16);
13763 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
13764 ut_params->ibuf, aad_len_pad);
13765 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
13766 "no room to prepend aad");
13767 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
13770 memset(sym_op->aead.aad.data, 0, aad_len);
13771 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
13773 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
13774 debug_hexdump(stdout, "aad:",
13775 sym_op->aead.aad.data, aad_len);
13778 sym_op->aead.data.length = tdata->plaintext.len;
13779 sym_op->aead.data.offset = aad_len_pad;
13784 #define SGL_MAX_NO 16
13787 test_authenticated_encryption_SGL(const struct aead_test_data *tdata,
13788 const int oop, uint32_t fragsz, uint32_t fragsz_oop)
13790 struct crypto_testsuite_params *ts_params = &testsuite_params;
13791 struct crypto_unittest_params *ut_params = &unittest_params;
13792 struct rte_mbuf *buf, *buf_oop = NULL, *buf_last_oop = NULL;
13795 int to_trn_tbl[SGL_MAX_NO];
13797 unsigned int trn_data = 0;
13798 uint8_t *plaintext, *ciphertext, *auth_tag;
13799 struct rte_cryptodev_info dev_info;
13801 /* Verify the capabilities */
13802 struct rte_cryptodev_sym_capability_idx cap_idx;
13803 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
13804 cap_idx.algo.aead = tdata->algo;
13805 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13807 return TEST_SKIPPED;
13809 /* OOP not supported with CPU crypto */
13810 if (oop && gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13811 return TEST_SKIPPED;
13813 /* Detailed check for the particular SGL support flag */
13814 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13816 unsigned int sgl_in = fragsz < tdata->plaintext.len;
13817 if (sgl_in && (!(dev_info.feature_flags &
13818 RTE_CRYPTODEV_FF_IN_PLACE_SGL)))
13819 return TEST_SKIPPED;
13821 uint64_t feat_flags = dev_info.feature_flags;
13823 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13824 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13825 printf("Device doesn't support RAW data-path APIs.\n");
13826 return TEST_SKIPPED;
13829 unsigned int sgl_in = fragsz < tdata->plaintext.len;
13830 unsigned int sgl_out = (fragsz_oop ? fragsz_oop : fragsz) <
13831 tdata->plaintext.len;
13832 /* Raw data path API does not support OOP */
13833 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13834 return TEST_SKIPPED;
13835 if (sgl_in && !sgl_out) {
13836 if (!(dev_info.feature_flags &
13837 RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT))
13838 return TEST_SKIPPED;
13839 } else if (!sgl_in && sgl_out) {
13840 if (!(dev_info.feature_flags &
13841 RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT))
13842 return TEST_SKIPPED;
13843 } else if (sgl_in && sgl_out) {
13844 if (!(dev_info.feature_flags &
13845 RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT))
13846 return TEST_SKIPPED;
13850 if (fragsz > tdata->plaintext.len)
13851 fragsz = tdata->plaintext.len;
13853 uint16_t plaintext_len = fragsz;
13854 uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
13856 if (fragsz_oop > tdata->plaintext.len)
13857 frag_size_oop = tdata->plaintext.len;
13860 void *digest_mem = NULL;
13862 uint32_t prepend_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
13864 if (tdata->plaintext.len % fragsz != 0) {
13865 if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO)
13868 if (tdata->plaintext.len / fragsz > SGL_MAX_NO)
13873 * For out-op-place we need to alloc another mbuf
13876 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13877 rte_pktmbuf_append(ut_params->obuf,
13878 frag_size_oop + prepend_len);
13879 buf_oop = ut_params->obuf;
13882 /* Create AEAD session */
13883 retval = create_aead_session(ts_params->valid_devs[0],
13885 RTE_CRYPTO_AEAD_OP_ENCRYPT,
13886 tdata->key.data, tdata->key.len,
13887 tdata->aad.len, tdata->auth_tag.len,
13892 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13894 /* clear mbuf payload */
13895 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13896 rte_pktmbuf_tailroom(ut_params->ibuf));
13898 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13901 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
13903 trn_data += plaintext_len;
13905 buf = ut_params->ibuf;
13908 * Loop until no more fragments
13911 while (trn_data < tdata->plaintext.len) {
13913 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
13914 (tdata->plaintext.len - trn_data) : fragsz;
13916 to_trn_tbl[ecx++] = to_trn;
13918 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13921 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
13922 rte_pktmbuf_tailroom(buf));
13925 if (oop && !fragsz_oop) {
13926 buf_last_oop = buf_oop->next =
13927 rte_pktmbuf_alloc(ts_params->mbuf_pool);
13928 buf_oop = buf_oop->next;
13929 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
13930 0, rte_pktmbuf_tailroom(buf_oop));
13931 rte_pktmbuf_append(buf_oop, to_trn);
13934 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
13937 memcpy(plaintext, tdata->plaintext.data + trn_data,
13939 trn_data += to_trn;
13940 if (trn_data == tdata->plaintext.len) {
13943 digest_mem = rte_pktmbuf_append(buf_oop,
13944 tdata->auth_tag.len);
13946 digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
13947 tdata->auth_tag.len);
13951 uint64_t digest_phys = 0;
13953 ut_params->ibuf->nb_segs = segs;
13956 if (fragsz_oop && oop) {
13960 if (frag_size_oop == tdata->plaintext.len) {
13961 digest_mem = rte_pktmbuf_append(ut_params->obuf,
13962 tdata->auth_tag.len);
13964 digest_phys = rte_pktmbuf_iova_offset(
13966 tdata->plaintext.len + prepend_len);
13969 trn_data = frag_size_oop;
13970 while (trn_data < tdata->plaintext.len) {
13973 (tdata->plaintext.len - trn_data <
13975 (tdata->plaintext.len - trn_data) :
13978 to_trn_tbl[ecx++] = to_trn;
13980 buf_last_oop = buf_oop->next =
13981 rte_pktmbuf_alloc(ts_params->mbuf_pool);
13982 buf_oop = buf_oop->next;
13983 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
13984 0, rte_pktmbuf_tailroom(buf_oop));
13985 rte_pktmbuf_append(buf_oop, to_trn);
13987 trn_data += to_trn;
13989 if (trn_data == tdata->plaintext.len) {
13990 digest_mem = rte_pktmbuf_append(buf_oop,
13991 tdata->auth_tag.len);
13995 ut_params->obuf->nb_segs = segs;
13999 * Place digest at the end of the last buffer
14002 digest_phys = rte_pktmbuf_iova(buf) + to_trn;
14003 if (oop && buf_last_oop)
14004 digest_phys = rte_pktmbuf_iova(buf_last_oop) + to_trn;
14006 if (!digest_mem && !oop) {
14007 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
14008 + tdata->auth_tag.len);
14009 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
14010 tdata->plaintext.len);
14013 /* Create AEAD operation */
14014 retval = create_aead_operation_SGL(RTE_CRYPTO_AEAD_OP_ENCRYPT,
14015 tdata, digest_mem, digest_phys);
14020 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
14022 ut_params->op->sym->m_src = ut_params->ibuf;
14024 ut_params->op->sym->m_dst = ut_params->obuf;
14026 /* Process crypto operation */
14027 if (oop == IN_PLACE &&
14028 gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
14029 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
14030 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
14031 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
14032 ut_params->op, 0, 0, 0, 0);
14034 TEST_ASSERT_NOT_NULL(
14035 process_crypto_request(ts_params->valid_devs[0],
14036 ut_params->op), "failed to process sym crypto op");
14038 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
14039 "crypto op processing failed");
14042 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
14043 uint8_t *, prepend_len);
14045 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
14046 uint8_t *, prepend_len);
14050 fragsz = fragsz_oop;
14052 TEST_ASSERT_BUFFERS_ARE_EQUAL(
14054 tdata->ciphertext.data,
14056 "Ciphertext data not as expected");
14058 buf = ut_params->op->sym->m_src->next;
14060 buf = ut_params->op->sym->m_dst->next;
14062 unsigned int off = fragsz;
14066 ciphertext = rte_pktmbuf_mtod(buf,
14069 TEST_ASSERT_BUFFERS_ARE_EQUAL(
14071 tdata->ciphertext.data + off,
14073 "Ciphertext data not as expected");
14075 off += to_trn_tbl[ecx++];
14079 auth_tag = digest_mem;
14080 TEST_ASSERT_BUFFERS_ARE_EQUAL(
14082 tdata->auth_tag.data,
14083 tdata->auth_tag.len,
14084 "Generated auth tag not as expected");
14090 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void)
14092 return test_authenticated_encryption_SGL(
14093 &gcm_test_case_SGL_1, OUT_OF_PLACE, 400, 400);
14097 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B(void)
14099 return test_authenticated_encryption_SGL(
14100 &gcm_test_case_SGL_1, OUT_OF_PLACE, 1500, 2000);
14104 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void)
14106 return test_authenticated_encryption_SGL(
14107 &gcm_test_case_8, OUT_OF_PLACE, 400,
14108 gcm_test_case_8.plaintext.len);
14112 test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void)
14114 /* This test is not for OPENSSL PMD */
14115 if (gbl_driver_id == rte_cryptodev_driver_id_get(
14116 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)))
14117 return TEST_SKIPPED;
14119 return test_authenticated_encryption_SGL(
14120 &gcm_test_case_SGL_1, IN_PLACE, 1500, 0);
14124 test_authentication_verify_fail_when_data_corrupted(
14125 struct crypto_testsuite_params *ts_params,
14126 struct crypto_unittest_params *ut_params,
14127 const struct test_crypto_vector *reference)
14129 return test_authentication_verify_fail_when_data_corruption(
14130 ts_params, ut_params, reference, 1);
14134 test_authentication_verify_fail_when_tag_corrupted(
14135 struct crypto_testsuite_params *ts_params,
14136 struct crypto_unittest_params *ut_params,
14137 const struct test_crypto_vector *reference)
14139 return test_authentication_verify_fail_when_data_corruption(
14140 ts_params, ut_params, reference, 0);
14144 test_authentication_verify_GMAC_fail_when_data_corrupted(
14145 struct crypto_testsuite_params *ts_params,
14146 struct crypto_unittest_params *ut_params,
14147 const struct test_crypto_vector *reference)
14149 return test_authentication_verify_GMAC_fail_when_corruption(
14150 ts_params, ut_params, reference, 1);
14154 test_authentication_verify_GMAC_fail_when_tag_corrupted(
14155 struct crypto_testsuite_params *ts_params,
14156 struct crypto_unittest_params *ut_params,
14157 const struct test_crypto_vector *reference)
14159 return test_authentication_verify_GMAC_fail_when_corruption(
14160 ts_params, ut_params, reference, 0);
14164 test_authenticated_decryption_fail_when_data_corrupted(
14165 struct crypto_testsuite_params *ts_params,
14166 struct crypto_unittest_params *ut_params,
14167 const struct test_crypto_vector *reference)
14169 return test_authenticated_decryption_fail_when_corruption(
14170 ts_params, ut_params, reference, 1);
14174 test_authenticated_decryption_fail_when_tag_corrupted(
14175 struct crypto_testsuite_params *ts_params,
14176 struct crypto_unittest_params *ut_params,
14177 const struct test_crypto_vector *reference)
14179 return test_authenticated_decryption_fail_when_corruption(
14180 ts_params, ut_params, reference, 0);
14184 authentication_verify_HMAC_SHA1_fail_data_corrupt(void)
14186 return test_authentication_verify_fail_when_data_corrupted(
14187 &testsuite_params, &unittest_params,
14188 &hmac_sha1_test_crypto_vector);
14192 authentication_verify_HMAC_SHA1_fail_tag_corrupt(void)
14194 return test_authentication_verify_fail_when_tag_corrupted(
14195 &testsuite_params, &unittest_params,
14196 &hmac_sha1_test_crypto_vector);
14200 authentication_verify_AES128_GMAC_fail_data_corrupt(void)
14202 return test_authentication_verify_GMAC_fail_when_data_corrupted(
14203 &testsuite_params, &unittest_params,
14204 &aes128_gmac_test_vector);
14208 authentication_verify_AES128_GMAC_fail_tag_corrupt(void)
14210 return test_authentication_verify_GMAC_fail_when_tag_corrupted(
14211 &testsuite_params, &unittest_params,
14212 &aes128_gmac_test_vector);
14216 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void)
14218 return test_authenticated_decryption_fail_when_data_corrupted(
14221 &aes128cbc_hmac_sha1_test_vector);
14225 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void)
14227 return test_authenticated_decryption_fail_when_tag_corrupted(
14230 &aes128cbc_hmac_sha1_test_vector);
14234 auth_encrypt_AES128CBC_HMAC_SHA1_esn_check(void)
14236 return test_authenticated_encrypt_with_esn(
14239 &aes128cbc_hmac_sha1_aad_test_vector);
14243 auth_decrypt_AES128CBC_HMAC_SHA1_esn_check(void)
14245 return test_authenticated_decrypt_with_esn(
14248 &aes128cbc_hmac_sha1_aad_test_vector);
14252 test_chacha20_poly1305_encrypt_test_case_rfc8439(void)
14254 return test_authenticated_encryption(&chacha20_poly1305_case_rfc8439);
14258 test_chacha20_poly1305_decrypt_test_case_rfc8439(void)
14260 return test_authenticated_decryption(&chacha20_poly1305_case_rfc8439);
14264 test_chacha20_poly1305_encrypt_SGL_out_of_place(void)
14266 return test_authenticated_encryption_SGL(
14267 &chacha20_poly1305_case_2, OUT_OF_PLACE, 32,
14268 chacha20_poly1305_case_2.plaintext.len);
14271 #ifdef RTE_CRYPTO_SCHEDULER
14273 /* global AESNI worker IDs for the scheduler test */
14274 uint8_t aesni_ids[2];
14277 scheduler_testsuite_setup(void)
14280 int32_t nb_devs, ret;
14281 char vdev_args[VDEV_ARGS_SIZE] = {""};
14282 char temp_str[VDEV_ARGS_SIZE] = {"mode=multi-core,"
14283 "ordering=enable,name=cryptodev_test_scheduler,corelist="};
14284 uint16_t worker_core_count = 0;
14285 uint16_t socket_id = 0;
14287 if (gbl_driver_id == rte_cryptodev_driver_id_get(
14288 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD))) {
14290 /* Identify the Worker Cores
14291 * Use 2 worker cores for the device args
14293 RTE_LCORE_FOREACH_WORKER(i) {
14294 if (worker_core_count > 1)
14296 snprintf(vdev_args, sizeof(vdev_args),
14297 "%s%d", temp_str, i);
14298 strcpy(temp_str, vdev_args);
14299 strlcat(temp_str, ";", sizeof(temp_str));
14300 worker_core_count++;
14301 socket_id = rte_lcore_to_socket_id(i);
14303 if (worker_core_count != 2) {
14304 RTE_LOG(ERR, USER1,
14305 "Cryptodev scheduler test require at least "
14306 "two worker cores to run. "
14307 "Please use the correct coremask.\n");
14308 return TEST_FAILED;
14310 strcpy(temp_str, vdev_args);
14311 snprintf(vdev_args, sizeof(vdev_args), "%s,socket_id=%d",
14312 temp_str, socket_id);
14313 RTE_LOG(DEBUG, USER1, "vdev_args: %s\n", vdev_args);
14314 nb_devs = rte_cryptodev_device_count_by_driver(
14315 rte_cryptodev_driver_id_get(
14316 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)));
14318 ret = rte_vdev_init(
14319 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),
14321 TEST_ASSERT(ret == 0,
14322 "Failed to create instance %u of pmd : %s",
14323 i, RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
14326 return testsuite_setup();
14330 test_scheduler_attach_worker_op(void)
14332 struct crypto_testsuite_params *ts_params = &testsuite_params;
14333 uint8_t sched_id = ts_params->valid_devs[0];
14334 uint32_t i, nb_devs_attached = 0;
14336 char vdev_name[32];
14337 unsigned int count = rte_cryptodev_count();
14339 /* create 2 AESNI_MB vdevs on top of existing devices */
14340 for (i = count; i < count + 2; i++) {
14341 snprintf(vdev_name, sizeof(vdev_name), "%s_%u",
14342 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD),
14344 ret = rte_vdev_init(vdev_name, NULL);
14346 TEST_ASSERT(ret == 0,
14347 "Failed to create instance %u of"
14349 i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
14352 RTE_LOG(ERR, USER1,
14353 "Failed to create 2 AESNI MB PMDs.\n");
14354 return TEST_SKIPPED;
14358 /* attach 2 AESNI_MB cdevs */
14359 for (i = count; i < count + 2; i++) {
14360 struct rte_cryptodev_info info;
14361 unsigned int session_size;
14363 rte_cryptodev_info_get(i, &info);
14364 if (info.driver_id != rte_cryptodev_driver_id_get(
14365 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)))
14368 session_size = rte_cryptodev_sym_get_private_session_size(i);
14370 * Create the session mempool again, since now there are new devices
14371 * to use the mempool.
14373 if (ts_params->session_mpool) {
14374 rte_mempool_free(ts_params->session_mpool);
14375 ts_params->session_mpool = NULL;
14377 if (ts_params->session_priv_mpool) {
14378 rte_mempool_free(ts_params->session_priv_mpool);
14379 ts_params->session_priv_mpool = NULL;
14382 if (info.sym.max_nb_sessions != 0 &&
14383 info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
14384 RTE_LOG(ERR, USER1,
14385 "Device does not support "
14386 "at least %u sessions\n",
14388 return TEST_FAILED;
14391 * Create mempool with maximum number of sessions,
14392 * to include the session headers
14394 if (ts_params->session_mpool == NULL) {
14395 ts_params->session_mpool =
14396 rte_cryptodev_sym_session_pool_create(
14398 MAX_NB_SESSIONS, 0, 0, 0,
14400 TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
14401 "session mempool allocation failed");
14405 * Create mempool with maximum number of sessions,
14406 * to include device specific session private data
14408 if (ts_params->session_priv_mpool == NULL) {
14409 ts_params->session_priv_mpool = rte_mempool_create(
14410 "test_sess_mp_priv",
14413 0, 0, NULL, NULL, NULL,
14414 NULL, SOCKET_ID_ANY,
14417 TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
14418 "session mempool allocation failed");
14421 ts_params->qp_conf.mp_session = ts_params->session_mpool;
14422 ts_params->qp_conf.mp_session_private =
14423 ts_params->session_priv_mpool;
14425 ret = rte_cryptodev_scheduler_worker_attach(sched_id,
14428 TEST_ASSERT(ret == 0,
14429 "Failed to attach device %u of pmd : %s", i,
14430 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
14432 aesni_ids[nb_devs_attached] = (uint8_t)i;
14434 nb_devs_attached++;
14441 test_scheduler_detach_worker_op(void)
14443 struct crypto_testsuite_params *ts_params = &testsuite_params;
14444 uint8_t sched_id = ts_params->valid_devs[0];
14448 for (i = 0; i < 2; i++) {
14449 ret = rte_cryptodev_scheduler_worker_detach(sched_id,
14451 TEST_ASSERT(ret == 0,
14452 "Failed to detach device %u", aesni_ids[i]);
14459 test_scheduler_mode_op(enum rte_cryptodev_scheduler_mode scheduler_mode)
14461 struct crypto_testsuite_params *ts_params = &testsuite_params;
14462 uint8_t sched_id = ts_params->valid_devs[0];
14464 return rte_cryptodev_scheduler_mode_set(sched_id,
14469 test_scheduler_mode_roundrobin_op(void)
14471 TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) ==
14472 0, "Failed to set roundrobin mode");
14478 test_scheduler_mode_multicore_op(void)
14480 TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) ==
14481 0, "Failed to set multicore mode");
14487 test_scheduler_mode_failover_op(void)
14489 TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) ==
14490 0, "Failed to set failover mode");
14496 test_scheduler_mode_pkt_size_distr_op(void)
14498 TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) ==
14499 0, "Failed to set pktsize mode");
14505 scheduler_multicore_testsuite_setup(void)
14507 if (test_scheduler_attach_worker_op() < 0)
14508 return TEST_SKIPPED;
14509 if (test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) < 0)
14510 return TEST_SKIPPED;
14515 scheduler_roundrobin_testsuite_setup(void)
14517 if (test_scheduler_attach_worker_op() < 0)
14518 return TEST_SKIPPED;
14519 if (test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) < 0)
14520 return TEST_SKIPPED;
14525 scheduler_failover_testsuite_setup(void)
14527 if (test_scheduler_attach_worker_op() < 0)
14528 return TEST_SKIPPED;
14529 if (test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) < 0)
14530 return TEST_SKIPPED;
14535 scheduler_pkt_size_distr_testsuite_setup(void)
14537 if (test_scheduler_attach_worker_op() < 0)
14538 return TEST_SKIPPED;
14539 if (test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) < 0)
14540 return TEST_SKIPPED;
14545 scheduler_mode_testsuite_teardown(void)
14547 test_scheduler_detach_worker_op();
14550 #endif /* RTE_CRYPTO_SCHEDULER */
14552 static struct unit_test_suite end_testsuite = {
14553 .suite_name = NULL,
14556 .unit_test_suites = NULL
14559 #ifdef RTE_LIB_SECURITY
14560 static struct unit_test_suite ipsec_proto_testsuite = {
14561 .suite_name = "IPsec Proto Unit Test Suite",
14562 .setup = ipsec_proto_testsuite_setup,
14563 .unit_test_cases = {
14564 TEST_CASE_NAMED_WITH_DATA(
14565 "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 128)",
14566 ut_setup_security, ut_teardown,
14567 test_ipsec_proto_known_vec, &pkt_aes_128_gcm),
14568 TEST_CASE_NAMED_WITH_DATA(
14569 "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 192)",
14570 ut_setup_security, ut_teardown,
14571 test_ipsec_proto_known_vec, &pkt_aes_192_gcm),
14572 TEST_CASE_NAMED_WITH_DATA(
14573 "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 256)",
14574 ut_setup_security, ut_teardown,
14575 test_ipsec_proto_known_vec, &pkt_aes_256_gcm),
14576 TEST_CASE_NAMED_WITH_DATA(
14577 "Outbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA256 [16B ICV])",
14578 ut_setup_security, ut_teardown,
14579 test_ipsec_proto_known_vec,
14580 &pkt_aes_128_cbc_hmac_sha256),
14581 TEST_CASE_NAMED_WITH_DATA(
14582 "Outbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA384 [24B ICV])",
14583 ut_setup_security, ut_teardown,
14584 test_ipsec_proto_known_vec,
14585 &pkt_aes_128_cbc_hmac_sha384),
14586 TEST_CASE_NAMED_WITH_DATA(
14587 "Outbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA512 [32B ICV])",
14588 ut_setup_security, ut_teardown,
14589 test_ipsec_proto_known_vec,
14590 &pkt_aes_128_cbc_hmac_sha512),
14591 TEST_CASE_NAMED_WITH_DATA(
14592 "Outbound known vector (ESP tunnel mode IPv6 AES-GCM 128)",
14593 ut_setup_security, ut_teardown,
14594 test_ipsec_proto_known_vec, &pkt_aes_256_gcm_v6),
14595 TEST_CASE_NAMED_WITH_DATA(
14596 "Outbound known vector (ESP tunnel mode IPv6 AES-CBC 128 HMAC-SHA256 [16B ICV])",
14597 ut_setup_security, ut_teardown,
14598 test_ipsec_proto_known_vec,
14599 &pkt_aes_128_cbc_hmac_sha256_v6),
14600 TEST_CASE_NAMED_WITH_DATA(
14601 "Outbound known vector (ESP tunnel mode IPv4 NULL AES-XCBC-MAC [12B ICV])",
14602 ut_setup_security, ut_teardown,
14603 test_ipsec_proto_known_vec,
14604 &pkt_null_aes_xcbc),
14605 TEST_CASE_NAMED_WITH_DATA(
14606 "Outbound fragmented packet",
14607 ut_setup_security, ut_teardown,
14608 test_ipsec_proto_known_vec_fragmented,
14609 &pkt_aes_128_gcm_frag),
14610 TEST_CASE_NAMED_WITH_DATA(
14611 "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 128)",
14612 ut_setup_security, ut_teardown,
14613 test_ipsec_proto_known_vec_inb, &pkt_aes_128_gcm),
14614 TEST_CASE_NAMED_WITH_DATA(
14615 "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 192)",
14616 ut_setup_security, ut_teardown,
14617 test_ipsec_proto_known_vec_inb, &pkt_aes_192_gcm),
14618 TEST_CASE_NAMED_WITH_DATA(
14619 "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 256)",
14620 ut_setup_security, ut_teardown,
14621 test_ipsec_proto_known_vec_inb, &pkt_aes_256_gcm),
14622 TEST_CASE_NAMED_WITH_DATA(
14623 "Inbound known vector (ESP tunnel mode IPv4 AES-CBC 128)",
14624 ut_setup_security, ut_teardown,
14625 test_ipsec_proto_known_vec_inb, &pkt_aes_128_cbc_null),
14626 TEST_CASE_NAMED_WITH_DATA(
14627 "Inbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA256 [16B ICV])",
14628 ut_setup_security, ut_teardown,
14629 test_ipsec_proto_known_vec_inb,
14630 &pkt_aes_128_cbc_hmac_sha256),
14631 TEST_CASE_NAMED_WITH_DATA(
14632 "Inbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA384 [24B ICV])",
14633 ut_setup_security, ut_teardown,
14634 test_ipsec_proto_known_vec_inb,
14635 &pkt_aes_128_cbc_hmac_sha384),
14636 TEST_CASE_NAMED_WITH_DATA(
14637 "Inbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA512 [32B ICV])",
14638 ut_setup_security, ut_teardown,
14639 test_ipsec_proto_known_vec_inb,
14640 &pkt_aes_128_cbc_hmac_sha512),
14641 TEST_CASE_NAMED_WITH_DATA(
14642 "Inbound known vector (ESP tunnel mode IPv6 AES-GCM 128)",
14643 ut_setup_security, ut_teardown,
14644 test_ipsec_proto_known_vec_inb, &pkt_aes_256_gcm_v6),
14645 TEST_CASE_NAMED_WITH_DATA(
14646 "Inbound known vector (ESP tunnel mode IPv6 AES-CBC 128 HMAC-SHA256 [16B ICV])",
14647 ut_setup_security, ut_teardown,
14648 test_ipsec_proto_known_vec_inb,
14649 &pkt_aes_128_cbc_hmac_sha256_v6),
14650 TEST_CASE_NAMED_WITH_DATA(
14651 "Inbound known vector (ESP tunnel mode IPv4 NULL AES-XCBC-MAC [12B ICV])",
14652 ut_setup_security, ut_teardown,
14653 test_ipsec_proto_known_vec_inb,
14654 &pkt_null_aes_xcbc),
14655 TEST_CASE_NAMED_ST(
14656 "Combined test alg list",
14657 ut_setup_security, ut_teardown,
14658 test_ipsec_proto_display_list),
14659 TEST_CASE_NAMED_ST(
14661 ut_setup_security, ut_teardown,
14662 test_ipsec_proto_iv_gen),
14663 TEST_CASE_NAMED_ST(
14664 "UDP encapsulation",
14665 ut_setup_security, ut_teardown,
14666 test_ipsec_proto_udp_encap),
14667 TEST_CASE_NAMED_ST(
14668 "UDP encapsulation ports verification test",
14669 ut_setup_security, ut_teardown,
14670 test_ipsec_proto_udp_ports_verify),
14671 TEST_CASE_NAMED_ST(
14672 "SA expiry packets soft",
14673 ut_setup_security, ut_teardown,
14674 test_ipsec_proto_sa_exp_pkts_soft),
14675 TEST_CASE_NAMED_ST(
14676 "SA expiry packets hard",
14677 ut_setup_security, ut_teardown,
14678 test_ipsec_proto_sa_exp_pkts_hard),
14679 TEST_CASE_NAMED_ST(
14680 "Negative test: ICV corruption",
14681 ut_setup_security, ut_teardown,
14682 test_ipsec_proto_err_icv_corrupt),
14683 TEST_CASE_NAMED_ST(
14684 "Tunnel dst addr verification",
14685 ut_setup_security, ut_teardown,
14686 test_ipsec_proto_tunnel_dst_addr_verify),
14687 TEST_CASE_NAMED_ST(
14688 "Tunnel src and dst addr verification",
14689 ut_setup_security, ut_teardown,
14690 test_ipsec_proto_tunnel_src_dst_addr_verify),
14691 TEST_CASE_NAMED_ST(
14692 "Inner IP checksum",
14693 ut_setup_security, ut_teardown,
14694 test_ipsec_proto_inner_ip_csum),
14695 TEST_CASE_NAMED_ST(
14696 "Inner L4 checksum",
14697 ut_setup_security, ut_teardown,
14698 test_ipsec_proto_inner_l4_csum),
14699 TEST_CASE_NAMED_ST(
14700 "Tunnel IPv4 in IPv4",
14701 ut_setup_security, ut_teardown,
14702 test_ipsec_proto_tunnel_v4_in_v4),
14703 TEST_CASE_NAMED_ST(
14704 "Tunnel IPv6 in IPv6",
14705 ut_setup_security, ut_teardown,
14706 test_ipsec_proto_tunnel_v6_in_v6),
14707 TEST_CASE_NAMED_ST(
14708 "Tunnel IPv4 in IPv6",
14709 ut_setup_security, ut_teardown,
14710 test_ipsec_proto_tunnel_v4_in_v6),
14711 TEST_CASE_NAMED_ST(
14712 "Tunnel IPv6 in IPv4",
14713 ut_setup_security, ut_teardown,
14714 test_ipsec_proto_tunnel_v6_in_v4),
14715 TEST_CASE_NAMED_ST(
14717 ut_setup_security, ut_teardown,
14718 test_ipsec_proto_transport_v4),
14719 TEST_CASE_NAMED_ST(
14720 "Statistics: success",
14721 ut_setup_security, ut_teardown,
14722 test_ipsec_proto_stats),
14723 TEST_CASE_NAMED_ST(
14724 "Fragmented packet",
14725 ut_setup_security, ut_teardown,
14726 test_ipsec_proto_pkt_fragment),
14727 TEST_CASES_END() /**< NULL terminate unit test array */
14731 static struct unit_test_suite pdcp_proto_testsuite = {
14732 .suite_name = "PDCP Proto Unit Test Suite",
14733 .setup = pdcp_proto_testsuite_setup,
14734 .unit_test_cases = {
14735 TEST_CASE_ST(ut_setup_security, ut_teardown,
14736 test_PDCP_PROTO_all),
14737 TEST_CASES_END() /**< NULL terminate unit test array */
14741 #define ADD_UPLINK_TESTCASE(data) \
14742 TEST_CASE_NAMED_WITH_DATA(data.test_descr_uplink, ut_setup_security, \
14743 ut_teardown, test_docsis_proto_uplink, (const void *) &data), \
14745 #define ADD_DOWNLINK_TESTCASE(data) \
14746 TEST_CASE_NAMED_WITH_DATA(data.test_descr_downlink, ut_setup_security, \
14747 ut_teardown, test_docsis_proto_downlink, (const void *) &data), \
14749 static struct unit_test_suite docsis_proto_testsuite = {
14750 .suite_name = "DOCSIS Proto Unit Test Suite",
14751 .setup = docsis_proto_testsuite_setup,
14752 .unit_test_cases = {
14754 ADD_UPLINK_TESTCASE(docsis_test_case_1)
14755 ADD_UPLINK_TESTCASE(docsis_test_case_2)
14756 ADD_UPLINK_TESTCASE(docsis_test_case_3)
14757 ADD_UPLINK_TESTCASE(docsis_test_case_4)
14758 ADD_UPLINK_TESTCASE(docsis_test_case_5)
14759 ADD_UPLINK_TESTCASE(docsis_test_case_6)
14760 ADD_UPLINK_TESTCASE(docsis_test_case_7)
14761 ADD_UPLINK_TESTCASE(docsis_test_case_8)
14762 ADD_UPLINK_TESTCASE(docsis_test_case_9)
14763 ADD_UPLINK_TESTCASE(docsis_test_case_10)
14764 ADD_UPLINK_TESTCASE(docsis_test_case_11)
14765 ADD_UPLINK_TESTCASE(docsis_test_case_12)
14766 ADD_UPLINK_TESTCASE(docsis_test_case_13)
14767 ADD_UPLINK_TESTCASE(docsis_test_case_14)
14768 ADD_UPLINK_TESTCASE(docsis_test_case_15)
14769 ADD_UPLINK_TESTCASE(docsis_test_case_16)
14770 ADD_UPLINK_TESTCASE(docsis_test_case_17)
14771 ADD_UPLINK_TESTCASE(docsis_test_case_18)
14772 ADD_UPLINK_TESTCASE(docsis_test_case_19)
14773 ADD_UPLINK_TESTCASE(docsis_test_case_20)
14774 ADD_UPLINK_TESTCASE(docsis_test_case_21)
14775 ADD_UPLINK_TESTCASE(docsis_test_case_22)
14776 ADD_UPLINK_TESTCASE(docsis_test_case_23)
14777 ADD_UPLINK_TESTCASE(docsis_test_case_24)
14778 ADD_UPLINK_TESTCASE(docsis_test_case_25)
14779 ADD_UPLINK_TESTCASE(docsis_test_case_26)
14781 ADD_DOWNLINK_TESTCASE(docsis_test_case_1)
14782 ADD_DOWNLINK_TESTCASE(docsis_test_case_2)
14783 ADD_DOWNLINK_TESTCASE(docsis_test_case_3)
14784 ADD_DOWNLINK_TESTCASE(docsis_test_case_4)
14785 ADD_DOWNLINK_TESTCASE(docsis_test_case_5)
14786 ADD_DOWNLINK_TESTCASE(docsis_test_case_6)
14787 ADD_DOWNLINK_TESTCASE(docsis_test_case_7)
14788 ADD_DOWNLINK_TESTCASE(docsis_test_case_8)
14789 ADD_DOWNLINK_TESTCASE(docsis_test_case_9)
14790 ADD_DOWNLINK_TESTCASE(docsis_test_case_10)
14791 ADD_DOWNLINK_TESTCASE(docsis_test_case_11)
14792 ADD_DOWNLINK_TESTCASE(docsis_test_case_12)
14793 ADD_DOWNLINK_TESTCASE(docsis_test_case_13)
14794 ADD_DOWNLINK_TESTCASE(docsis_test_case_14)
14795 ADD_DOWNLINK_TESTCASE(docsis_test_case_15)
14796 ADD_DOWNLINK_TESTCASE(docsis_test_case_16)
14797 ADD_DOWNLINK_TESTCASE(docsis_test_case_17)
14798 ADD_DOWNLINK_TESTCASE(docsis_test_case_18)
14799 ADD_DOWNLINK_TESTCASE(docsis_test_case_19)
14800 ADD_DOWNLINK_TESTCASE(docsis_test_case_20)
14801 ADD_DOWNLINK_TESTCASE(docsis_test_case_21)
14802 ADD_DOWNLINK_TESTCASE(docsis_test_case_22)
14803 ADD_DOWNLINK_TESTCASE(docsis_test_case_23)
14804 ADD_DOWNLINK_TESTCASE(docsis_test_case_24)
14805 ADD_DOWNLINK_TESTCASE(docsis_test_case_25)
14806 ADD_DOWNLINK_TESTCASE(docsis_test_case_26)
14807 TEST_CASES_END() /**< NULL terminate unit test array */
14812 static struct unit_test_suite cryptodev_gen_testsuite = {
14813 .suite_name = "Crypto General Unit Test Suite",
14814 .setup = crypto_gen_testsuite_setup,
14815 .unit_test_cases = {
14816 TEST_CASE_ST(ut_setup, ut_teardown,
14817 test_device_configure_invalid_dev_id),
14818 TEST_CASE_ST(ut_setup, ut_teardown,
14819 test_queue_pair_descriptor_setup),
14820 TEST_CASE_ST(ut_setup, ut_teardown,
14821 test_device_configure_invalid_queue_pair_ids),
14822 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
14823 TEST_CASE_ST(ut_setup, ut_teardown, test_enq_callback_setup),
14824 TEST_CASE_ST(ut_setup, ut_teardown, test_deq_callback_setup),
14825 TEST_CASES_END() /**< NULL terminate unit test array */
14829 static struct unit_test_suite cryptodev_negative_hmac_sha1_testsuite = {
14830 .suite_name = "Negative HMAC SHA1 Unit Test Suite",
14831 .setup = negative_hmac_sha1_testsuite_setup,
14832 .unit_test_cases = {
14833 /** Negative tests */
14834 TEST_CASE_ST(ut_setup, ut_teardown,
14835 authentication_verify_HMAC_SHA1_fail_data_corrupt),
14836 TEST_CASE_ST(ut_setup, ut_teardown,
14837 authentication_verify_HMAC_SHA1_fail_tag_corrupt),
14838 TEST_CASE_ST(ut_setup, ut_teardown,
14839 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
14840 TEST_CASE_ST(ut_setup, ut_teardown,
14841 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
14843 TEST_CASES_END() /**< NULL terminate unit test array */
14847 static struct unit_test_suite cryptodev_multi_session_testsuite = {
14848 .suite_name = "Multi Session Unit Test Suite",
14849 .setup = multi_session_testsuite_setup,
14850 .unit_test_cases = {
14851 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
14852 TEST_CASE_ST(ut_setup, ut_teardown,
14853 test_multi_session_random_usage),
14855 TEST_CASES_END() /**< NULL terminate unit test array */
14859 static struct unit_test_suite cryptodev_null_testsuite = {
14860 .suite_name = "NULL Test Suite",
14861 .setup = null_testsuite_setup,
14862 .unit_test_cases = {
14863 TEST_CASE_ST(ut_setup, ut_teardown,
14864 test_null_invalid_operation),
14865 TEST_CASE_ST(ut_setup, ut_teardown, test_null_burst_operation),
14870 static struct unit_test_suite cryptodev_aes_ccm_auth_testsuite = {
14871 .suite_name = "AES CCM Authenticated Test Suite",
14872 .setup = aes_ccm_auth_testsuite_setup,
14873 .unit_test_cases = {
14874 /** AES CCM Authenticated Encryption 128 bits key*/
14875 TEST_CASE_ST(ut_setup, ut_teardown,
14876 test_AES_CCM_authenticated_encryption_test_case_128_1),
14877 TEST_CASE_ST(ut_setup, ut_teardown,
14878 test_AES_CCM_authenticated_encryption_test_case_128_2),
14879 TEST_CASE_ST(ut_setup, ut_teardown,
14880 test_AES_CCM_authenticated_encryption_test_case_128_3),
14882 /** AES CCM Authenticated Decryption 128 bits key*/
14883 TEST_CASE_ST(ut_setup, ut_teardown,
14884 test_AES_CCM_authenticated_decryption_test_case_128_1),
14885 TEST_CASE_ST(ut_setup, ut_teardown,
14886 test_AES_CCM_authenticated_decryption_test_case_128_2),
14887 TEST_CASE_ST(ut_setup, ut_teardown,
14888 test_AES_CCM_authenticated_decryption_test_case_128_3),
14890 /** AES CCM Authenticated Encryption 192 bits key */
14891 TEST_CASE_ST(ut_setup, ut_teardown,
14892 test_AES_CCM_authenticated_encryption_test_case_192_1),
14893 TEST_CASE_ST(ut_setup, ut_teardown,
14894 test_AES_CCM_authenticated_encryption_test_case_192_2),
14895 TEST_CASE_ST(ut_setup, ut_teardown,
14896 test_AES_CCM_authenticated_encryption_test_case_192_3),
14898 /** AES CCM Authenticated Decryption 192 bits key*/
14899 TEST_CASE_ST(ut_setup, ut_teardown,
14900 test_AES_CCM_authenticated_decryption_test_case_192_1),
14901 TEST_CASE_ST(ut_setup, ut_teardown,
14902 test_AES_CCM_authenticated_decryption_test_case_192_2),
14903 TEST_CASE_ST(ut_setup, ut_teardown,
14904 test_AES_CCM_authenticated_decryption_test_case_192_3),
14906 /** AES CCM Authenticated Encryption 256 bits key */
14907 TEST_CASE_ST(ut_setup, ut_teardown,
14908 test_AES_CCM_authenticated_encryption_test_case_256_1),
14909 TEST_CASE_ST(ut_setup, ut_teardown,
14910 test_AES_CCM_authenticated_encryption_test_case_256_2),
14911 TEST_CASE_ST(ut_setup, ut_teardown,
14912 test_AES_CCM_authenticated_encryption_test_case_256_3),
14914 /** AES CCM Authenticated Decryption 256 bits key*/
14915 TEST_CASE_ST(ut_setup, ut_teardown,
14916 test_AES_CCM_authenticated_decryption_test_case_256_1),
14917 TEST_CASE_ST(ut_setup, ut_teardown,
14918 test_AES_CCM_authenticated_decryption_test_case_256_2),
14919 TEST_CASE_ST(ut_setup, ut_teardown,
14920 test_AES_CCM_authenticated_decryption_test_case_256_3),
14925 static struct unit_test_suite cryptodev_aes_gcm_auth_testsuite = {
14926 .suite_name = "AES GCM Authenticated Test Suite",
14927 .setup = aes_gcm_auth_testsuite_setup,
14928 .unit_test_cases = {
14929 /** AES GCM Authenticated Encryption */
14930 TEST_CASE_ST(ut_setup, ut_teardown,
14931 test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
14932 TEST_CASE_ST(ut_setup, ut_teardown,
14933 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
14934 TEST_CASE_ST(ut_setup, ut_teardown,
14935 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
14936 TEST_CASE_ST(ut_setup, ut_teardown,
14937 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
14938 TEST_CASE_ST(ut_setup, ut_teardown,
14939 test_AES_GCM_authenticated_encryption_test_case_1),
14940 TEST_CASE_ST(ut_setup, ut_teardown,
14941 test_AES_GCM_authenticated_encryption_test_case_2),
14942 TEST_CASE_ST(ut_setup, ut_teardown,
14943 test_AES_GCM_authenticated_encryption_test_case_3),
14944 TEST_CASE_ST(ut_setup, ut_teardown,
14945 test_AES_GCM_authenticated_encryption_test_case_4),
14946 TEST_CASE_ST(ut_setup, ut_teardown,
14947 test_AES_GCM_authenticated_encryption_test_case_5),
14948 TEST_CASE_ST(ut_setup, ut_teardown,
14949 test_AES_GCM_authenticated_encryption_test_case_6),
14950 TEST_CASE_ST(ut_setup, ut_teardown,
14951 test_AES_GCM_authenticated_encryption_test_case_7),
14952 TEST_CASE_ST(ut_setup, ut_teardown,
14953 test_AES_GCM_authenticated_encryption_test_case_8),
14954 TEST_CASE_ST(ut_setup, ut_teardown,
14955 test_AES_GCM_J0_authenticated_encryption_test_case_1),
14957 /** AES GCM Authenticated Decryption */
14958 TEST_CASE_ST(ut_setup, ut_teardown,
14959 test_AES_GCM_authenticated_decryption_test_case_1),
14960 TEST_CASE_ST(ut_setup, ut_teardown,
14961 test_AES_GCM_authenticated_decryption_test_case_2),
14962 TEST_CASE_ST(ut_setup, ut_teardown,
14963 test_AES_GCM_authenticated_decryption_test_case_3),
14964 TEST_CASE_ST(ut_setup, ut_teardown,
14965 test_AES_GCM_authenticated_decryption_test_case_4),
14966 TEST_CASE_ST(ut_setup, ut_teardown,
14967 test_AES_GCM_authenticated_decryption_test_case_5),
14968 TEST_CASE_ST(ut_setup, ut_teardown,
14969 test_AES_GCM_authenticated_decryption_test_case_6),
14970 TEST_CASE_ST(ut_setup, ut_teardown,
14971 test_AES_GCM_authenticated_decryption_test_case_7),
14972 TEST_CASE_ST(ut_setup, ut_teardown,
14973 test_AES_GCM_authenticated_decryption_test_case_8),
14974 TEST_CASE_ST(ut_setup, ut_teardown,
14975 test_AES_GCM_J0_authenticated_decryption_test_case_1),
14977 /** AES GCM Authenticated Encryption 192 bits key */
14978 TEST_CASE_ST(ut_setup, ut_teardown,
14979 test_AES_GCM_auth_encryption_test_case_192_1),
14980 TEST_CASE_ST(ut_setup, ut_teardown,
14981 test_AES_GCM_auth_encryption_test_case_192_2),
14982 TEST_CASE_ST(ut_setup, ut_teardown,
14983 test_AES_GCM_auth_encryption_test_case_192_3),
14984 TEST_CASE_ST(ut_setup, ut_teardown,
14985 test_AES_GCM_auth_encryption_test_case_192_4),
14986 TEST_CASE_ST(ut_setup, ut_teardown,
14987 test_AES_GCM_auth_encryption_test_case_192_5),
14988 TEST_CASE_ST(ut_setup, ut_teardown,
14989 test_AES_GCM_auth_encryption_test_case_192_6),
14990 TEST_CASE_ST(ut_setup, ut_teardown,
14991 test_AES_GCM_auth_encryption_test_case_192_7),
14993 /** AES GCM Authenticated Decryption 192 bits key */
14994 TEST_CASE_ST(ut_setup, ut_teardown,
14995 test_AES_GCM_auth_decryption_test_case_192_1),
14996 TEST_CASE_ST(ut_setup, ut_teardown,
14997 test_AES_GCM_auth_decryption_test_case_192_2),
14998 TEST_CASE_ST(ut_setup, ut_teardown,
14999 test_AES_GCM_auth_decryption_test_case_192_3),
15000 TEST_CASE_ST(ut_setup, ut_teardown,
15001 test_AES_GCM_auth_decryption_test_case_192_4),
15002 TEST_CASE_ST(ut_setup, ut_teardown,
15003 test_AES_GCM_auth_decryption_test_case_192_5),
15004 TEST_CASE_ST(ut_setup, ut_teardown,
15005 test_AES_GCM_auth_decryption_test_case_192_6),
15006 TEST_CASE_ST(ut_setup, ut_teardown,
15007 test_AES_GCM_auth_decryption_test_case_192_7),
15009 /** AES GCM Authenticated Encryption 256 bits key */
15010 TEST_CASE_ST(ut_setup, ut_teardown,
15011 test_AES_GCM_auth_encryption_test_case_256_1),
15012 TEST_CASE_ST(ut_setup, ut_teardown,
15013 test_AES_GCM_auth_encryption_test_case_256_2),
15014 TEST_CASE_ST(ut_setup, ut_teardown,
15015 test_AES_GCM_auth_encryption_test_case_256_3),
15016 TEST_CASE_ST(ut_setup, ut_teardown,
15017 test_AES_GCM_auth_encryption_test_case_256_4),
15018 TEST_CASE_ST(ut_setup, ut_teardown,
15019 test_AES_GCM_auth_encryption_test_case_256_5),
15020 TEST_CASE_ST(ut_setup, ut_teardown,
15021 test_AES_GCM_auth_encryption_test_case_256_6),
15022 TEST_CASE_ST(ut_setup, ut_teardown,
15023 test_AES_GCM_auth_encryption_test_case_256_7),
15025 /** AES GCM Authenticated Decryption 256 bits key */
15026 TEST_CASE_ST(ut_setup, ut_teardown,
15027 test_AES_GCM_auth_decryption_test_case_256_1),
15028 TEST_CASE_ST(ut_setup, ut_teardown,
15029 test_AES_GCM_auth_decryption_test_case_256_2),
15030 TEST_CASE_ST(ut_setup, ut_teardown,
15031 test_AES_GCM_auth_decryption_test_case_256_3),
15032 TEST_CASE_ST(ut_setup, ut_teardown,
15033 test_AES_GCM_auth_decryption_test_case_256_4),
15034 TEST_CASE_ST(ut_setup, ut_teardown,
15035 test_AES_GCM_auth_decryption_test_case_256_5),
15036 TEST_CASE_ST(ut_setup, ut_teardown,
15037 test_AES_GCM_auth_decryption_test_case_256_6),
15038 TEST_CASE_ST(ut_setup, ut_teardown,
15039 test_AES_GCM_auth_decryption_test_case_256_7),
15041 /** AES GCM Authenticated Encryption big aad size */
15042 TEST_CASE_ST(ut_setup, ut_teardown,
15043 test_AES_GCM_auth_encryption_test_case_aad_1),
15044 TEST_CASE_ST(ut_setup, ut_teardown,
15045 test_AES_GCM_auth_encryption_test_case_aad_2),
15047 /** AES GCM Authenticated Decryption big aad size */
15048 TEST_CASE_ST(ut_setup, ut_teardown,
15049 test_AES_GCM_auth_decryption_test_case_aad_1),
15050 TEST_CASE_ST(ut_setup, ut_teardown,
15051 test_AES_GCM_auth_decryption_test_case_aad_2),
15053 /** Out of place tests */
15054 TEST_CASE_ST(ut_setup, ut_teardown,
15055 test_AES_GCM_authenticated_encryption_oop_test_case_1),
15056 TEST_CASE_ST(ut_setup, ut_teardown,
15057 test_AES_GCM_authenticated_decryption_oop_test_case_1),
15059 /** Session-less tests */
15060 TEST_CASE_ST(ut_setup, ut_teardown,
15061 test_AES_GCM_authenticated_encryption_sessionless_test_case_1),
15062 TEST_CASE_ST(ut_setup, ut_teardown,
15063 test_AES_GCM_authenticated_decryption_sessionless_test_case_1),
15069 static struct unit_test_suite cryptodev_aes_gmac_auth_testsuite = {
15070 .suite_name = "AES GMAC Authentication Test Suite",
15071 .setup = aes_gmac_auth_testsuite_setup,
15072 .unit_test_cases = {
15073 TEST_CASE_ST(ut_setup, ut_teardown,
15074 test_AES_GMAC_authentication_test_case_1),
15075 TEST_CASE_ST(ut_setup, ut_teardown,
15076 test_AES_GMAC_authentication_verify_test_case_1),
15077 TEST_CASE_ST(ut_setup, ut_teardown,
15078 test_AES_GMAC_authentication_test_case_2),
15079 TEST_CASE_ST(ut_setup, ut_teardown,
15080 test_AES_GMAC_authentication_verify_test_case_2),
15081 TEST_CASE_ST(ut_setup, ut_teardown,
15082 test_AES_GMAC_authentication_test_case_3),
15083 TEST_CASE_ST(ut_setup, ut_teardown,
15084 test_AES_GMAC_authentication_verify_test_case_3),
15085 TEST_CASE_ST(ut_setup, ut_teardown,
15086 test_AES_GMAC_authentication_test_case_4),
15087 TEST_CASE_ST(ut_setup, ut_teardown,
15088 test_AES_GMAC_authentication_verify_test_case_4),
15089 TEST_CASE_ST(ut_setup, ut_teardown,
15090 test_AES_GMAC_authentication_SGL_40B),
15091 TEST_CASE_ST(ut_setup, ut_teardown,
15092 test_AES_GMAC_authentication_SGL_80B),
15093 TEST_CASE_ST(ut_setup, ut_teardown,
15094 test_AES_GMAC_authentication_SGL_2048B),
15095 TEST_CASE_ST(ut_setup, ut_teardown,
15096 test_AES_GMAC_authentication_SGL_2047B),
15102 static struct unit_test_suite cryptodev_chacha20_poly1305_testsuite = {
15103 .suite_name = "Chacha20-Poly1305 Test Suite",
15104 .setup = chacha20_poly1305_testsuite_setup,
15105 .unit_test_cases = {
15106 TEST_CASE_ST(ut_setup, ut_teardown,
15107 test_chacha20_poly1305_encrypt_test_case_rfc8439),
15108 TEST_CASE_ST(ut_setup, ut_teardown,
15109 test_chacha20_poly1305_decrypt_test_case_rfc8439),
15110 TEST_CASE_ST(ut_setup, ut_teardown,
15111 test_chacha20_poly1305_encrypt_SGL_out_of_place),
15116 static struct unit_test_suite cryptodev_snow3g_testsuite = {
15117 .suite_name = "SNOW 3G Test Suite",
15118 .setup = snow3g_testsuite_setup,
15119 .unit_test_cases = {
15120 /** SNOW 3G encrypt only (UEA2) */
15121 TEST_CASE_ST(ut_setup, ut_teardown,
15122 test_snow3g_encryption_test_case_1),
15123 TEST_CASE_ST(ut_setup, ut_teardown,
15124 test_snow3g_encryption_test_case_2),
15125 TEST_CASE_ST(ut_setup, ut_teardown,
15126 test_snow3g_encryption_test_case_3),
15127 TEST_CASE_ST(ut_setup, ut_teardown,
15128 test_snow3g_encryption_test_case_4),
15129 TEST_CASE_ST(ut_setup, ut_teardown,
15130 test_snow3g_encryption_test_case_5),
15132 TEST_CASE_ST(ut_setup, ut_teardown,
15133 test_snow3g_encryption_test_case_1_oop),
15134 TEST_CASE_ST(ut_setup, ut_teardown,
15135 test_snow3g_encryption_test_case_1_oop_sgl),
15136 TEST_CASE_ST(ut_setup, ut_teardown,
15137 test_snow3g_encryption_test_case_1_offset_oop),
15138 TEST_CASE_ST(ut_setup, ut_teardown,
15139 test_snow3g_decryption_test_case_1_oop),
15141 /** SNOW 3G generate auth, then encrypt (UEA2) */
15142 TEST_CASE_ST(ut_setup, ut_teardown,
15143 test_snow3g_auth_cipher_test_case_1),
15144 TEST_CASE_ST(ut_setup, ut_teardown,
15145 test_snow3g_auth_cipher_test_case_2),
15146 TEST_CASE_ST(ut_setup, ut_teardown,
15147 test_snow3g_auth_cipher_test_case_2_oop),
15148 TEST_CASE_ST(ut_setup, ut_teardown,
15149 test_snow3g_auth_cipher_part_digest_enc),
15150 TEST_CASE_ST(ut_setup, ut_teardown,
15151 test_snow3g_auth_cipher_part_digest_enc_oop),
15152 TEST_CASE_ST(ut_setup, ut_teardown,
15153 test_snow3g_auth_cipher_test_case_3_sgl),
15154 TEST_CASE_ST(ut_setup, ut_teardown,
15155 test_snow3g_auth_cipher_test_case_3_oop_sgl),
15156 TEST_CASE_ST(ut_setup, ut_teardown,
15157 test_snow3g_auth_cipher_part_digest_enc_sgl),
15158 TEST_CASE_ST(ut_setup, ut_teardown,
15159 test_snow3g_auth_cipher_part_digest_enc_oop_sgl),
15161 /** SNOW 3G decrypt (UEA2), then verify auth */
15162 TEST_CASE_ST(ut_setup, ut_teardown,
15163 test_snow3g_auth_cipher_verify_test_case_1),
15164 TEST_CASE_ST(ut_setup, ut_teardown,
15165 test_snow3g_auth_cipher_verify_test_case_2),
15166 TEST_CASE_ST(ut_setup, ut_teardown,
15167 test_snow3g_auth_cipher_verify_test_case_2_oop),
15168 TEST_CASE_ST(ut_setup, ut_teardown,
15169 test_snow3g_auth_cipher_verify_part_digest_enc),
15170 TEST_CASE_ST(ut_setup, ut_teardown,
15171 test_snow3g_auth_cipher_verify_part_digest_enc_oop),
15172 TEST_CASE_ST(ut_setup, ut_teardown,
15173 test_snow3g_auth_cipher_verify_test_case_3_sgl),
15174 TEST_CASE_ST(ut_setup, ut_teardown,
15175 test_snow3g_auth_cipher_verify_test_case_3_oop_sgl),
15176 TEST_CASE_ST(ut_setup, ut_teardown,
15177 test_snow3g_auth_cipher_verify_part_digest_enc_sgl),
15178 TEST_CASE_ST(ut_setup, ut_teardown,
15179 test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl),
15181 /** SNOW 3G decrypt only (UEA2) */
15182 TEST_CASE_ST(ut_setup, ut_teardown,
15183 test_snow3g_decryption_test_case_1),
15184 TEST_CASE_ST(ut_setup, ut_teardown,
15185 test_snow3g_decryption_test_case_2),
15186 TEST_CASE_ST(ut_setup, ut_teardown,
15187 test_snow3g_decryption_test_case_3),
15188 TEST_CASE_ST(ut_setup, ut_teardown,
15189 test_snow3g_decryption_test_case_4),
15190 TEST_CASE_ST(ut_setup, ut_teardown,
15191 test_snow3g_decryption_test_case_5),
15192 TEST_CASE_ST(ut_setup, ut_teardown,
15193 test_snow3g_decryption_with_digest_test_case_1),
15194 TEST_CASE_ST(ut_setup, ut_teardown,
15195 test_snow3g_hash_generate_test_case_1),
15196 TEST_CASE_ST(ut_setup, ut_teardown,
15197 test_snow3g_hash_generate_test_case_2),
15198 TEST_CASE_ST(ut_setup, ut_teardown,
15199 test_snow3g_hash_generate_test_case_3),
15201 /* Tests with buffers which length is not byte-aligned */
15202 TEST_CASE_ST(ut_setup, ut_teardown,
15203 test_snow3g_hash_generate_test_case_4),
15204 TEST_CASE_ST(ut_setup, ut_teardown,
15205 test_snow3g_hash_generate_test_case_5),
15206 TEST_CASE_ST(ut_setup, ut_teardown,
15207 test_snow3g_hash_generate_test_case_6),
15208 TEST_CASE_ST(ut_setup, ut_teardown,
15209 test_snow3g_hash_verify_test_case_1),
15210 TEST_CASE_ST(ut_setup, ut_teardown,
15211 test_snow3g_hash_verify_test_case_2),
15212 TEST_CASE_ST(ut_setup, ut_teardown,
15213 test_snow3g_hash_verify_test_case_3),
15215 /* Tests with buffers which length is not byte-aligned */
15216 TEST_CASE_ST(ut_setup, ut_teardown,
15217 test_snow3g_hash_verify_test_case_4),
15218 TEST_CASE_ST(ut_setup, ut_teardown,
15219 test_snow3g_hash_verify_test_case_5),
15220 TEST_CASE_ST(ut_setup, ut_teardown,
15221 test_snow3g_hash_verify_test_case_6),
15222 TEST_CASE_ST(ut_setup, ut_teardown,
15223 test_snow3g_cipher_auth_test_case_1),
15224 TEST_CASE_ST(ut_setup, ut_teardown,
15225 test_snow3g_auth_cipher_with_digest_test_case_1),
15230 static struct unit_test_suite cryptodev_zuc_testsuite = {
15231 .suite_name = "ZUC Test Suite",
15232 .setup = zuc_testsuite_setup,
15233 .unit_test_cases = {
15234 /** ZUC encrypt only (EEA3) */
15235 TEST_CASE_ST(ut_setup, ut_teardown,
15236 test_zuc_encryption_test_case_1),
15237 TEST_CASE_ST(ut_setup, ut_teardown,
15238 test_zuc_encryption_test_case_2),
15239 TEST_CASE_ST(ut_setup, ut_teardown,
15240 test_zuc_encryption_test_case_3),
15241 TEST_CASE_ST(ut_setup, ut_teardown,
15242 test_zuc_encryption_test_case_4),
15243 TEST_CASE_ST(ut_setup, ut_teardown,
15244 test_zuc_encryption_test_case_5),
15245 TEST_CASE_ST(ut_setup, ut_teardown,
15246 test_zuc_encryption_test_case_6_sgl),
15248 /** ZUC authenticate (EIA3) */
15249 TEST_CASE_ST(ut_setup, ut_teardown,
15250 test_zuc_hash_generate_test_case_1),
15251 TEST_CASE_ST(ut_setup, ut_teardown,
15252 test_zuc_hash_generate_test_case_2),
15253 TEST_CASE_ST(ut_setup, ut_teardown,
15254 test_zuc_hash_generate_test_case_3),
15255 TEST_CASE_ST(ut_setup, ut_teardown,
15256 test_zuc_hash_generate_test_case_4),
15257 TEST_CASE_ST(ut_setup, ut_teardown,
15258 test_zuc_hash_generate_test_case_5),
15259 TEST_CASE_ST(ut_setup, ut_teardown,
15260 test_zuc_hash_generate_test_case_6),
15261 TEST_CASE_ST(ut_setup, ut_teardown,
15262 test_zuc_hash_generate_test_case_7),
15263 TEST_CASE_ST(ut_setup, ut_teardown,
15264 test_zuc_hash_generate_test_case_8),
15265 TEST_CASE_ST(ut_setup, ut_teardown,
15266 test_zuc_hash_generate_test_case_9),
15267 TEST_CASE_ST(ut_setup, ut_teardown,
15268 test_zuc_hash_generate_test_case_10),
15269 TEST_CASE_ST(ut_setup, ut_teardown,
15270 test_zuc_hash_generate_test_case_11),
15273 /** ZUC alg-chain (EEA3/EIA3) */
15274 TEST_CASE_ST(ut_setup, ut_teardown,
15275 test_zuc_cipher_auth_test_case_1),
15276 TEST_CASE_ST(ut_setup, ut_teardown,
15277 test_zuc_cipher_auth_test_case_2),
15279 /** ZUC generate auth, then encrypt (EEA3) */
15280 TEST_CASE_ST(ut_setup, ut_teardown,
15281 test_zuc_auth_cipher_test_case_1),
15282 TEST_CASE_ST(ut_setup, ut_teardown,
15283 test_zuc_auth_cipher_test_case_1_oop),
15284 TEST_CASE_ST(ut_setup, ut_teardown,
15285 test_zuc_auth_cipher_test_case_1_sgl),
15286 TEST_CASE_ST(ut_setup, ut_teardown,
15287 test_zuc_auth_cipher_test_case_1_oop_sgl),
15289 /** ZUC decrypt (EEA3), then verify auth */
15290 TEST_CASE_ST(ut_setup, ut_teardown,
15291 test_zuc_auth_cipher_verify_test_case_1),
15292 TEST_CASE_ST(ut_setup, ut_teardown,
15293 test_zuc_auth_cipher_verify_test_case_1_oop),
15294 TEST_CASE_ST(ut_setup, ut_teardown,
15295 test_zuc_auth_cipher_verify_test_case_1_sgl),
15296 TEST_CASE_ST(ut_setup, ut_teardown,
15297 test_zuc_auth_cipher_verify_test_case_1_oop_sgl),
15299 /** ZUC-256 encrypt only **/
15300 TEST_CASE_ST(ut_setup, ut_teardown,
15301 test_zuc256_encryption_test_case_1),
15302 TEST_CASE_ST(ut_setup, ut_teardown,
15303 test_zuc256_encryption_test_case_2),
15305 /** ZUC-256 authentication only **/
15306 TEST_CASE_ST(ut_setup, ut_teardown,
15307 test_zuc256_authentication_test_case_1),
15308 TEST_CASE_ST(ut_setup, ut_teardown,
15309 test_zuc256_authentication_test_case_2),
15315 static struct unit_test_suite cryptodev_hmac_md5_auth_testsuite = {
15316 .suite_name = "HMAC_MD5 Authentication Test Suite",
15317 .setup = hmac_md5_auth_testsuite_setup,
15318 .unit_test_cases = {
15319 TEST_CASE_ST(ut_setup, ut_teardown,
15320 test_MD5_HMAC_generate_case_1),
15321 TEST_CASE_ST(ut_setup, ut_teardown,
15322 test_MD5_HMAC_verify_case_1),
15323 TEST_CASE_ST(ut_setup, ut_teardown,
15324 test_MD5_HMAC_generate_case_2),
15325 TEST_CASE_ST(ut_setup, ut_teardown,
15326 test_MD5_HMAC_verify_case_2),
15331 static struct unit_test_suite cryptodev_kasumi_testsuite = {
15332 .suite_name = "Kasumi Test Suite",
15333 .setup = kasumi_testsuite_setup,
15334 .unit_test_cases = {
15335 /** KASUMI hash only (UIA1) */
15336 TEST_CASE_ST(ut_setup, ut_teardown,
15337 test_kasumi_hash_generate_test_case_1),
15338 TEST_CASE_ST(ut_setup, ut_teardown,
15339 test_kasumi_hash_generate_test_case_2),
15340 TEST_CASE_ST(ut_setup, ut_teardown,
15341 test_kasumi_hash_generate_test_case_3),
15342 TEST_CASE_ST(ut_setup, ut_teardown,
15343 test_kasumi_hash_generate_test_case_4),
15344 TEST_CASE_ST(ut_setup, ut_teardown,
15345 test_kasumi_hash_generate_test_case_5),
15346 TEST_CASE_ST(ut_setup, ut_teardown,
15347 test_kasumi_hash_generate_test_case_6),
15349 TEST_CASE_ST(ut_setup, ut_teardown,
15350 test_kasumi_hash_verify_test_case_1),
15351 TEST_CASE_ST(ut_setup, ut_teardown,
15352 test_kasumi_hash_verify_test_case_2),
15353 TEST_CASE_ST(ut_setup, ut_teardown,
15354 test_kasumi_hash_verify_test_case_3),
15355 TEST_CASE_ST(ut_setup, ut_teardown,
15356 test_kasumi_hash_verify_test_case_4),
15357 TEST_CASE_ST(ut_setup, ut_teardown,
15358 test_kasumi_hash_verify_test_case_5),
15360 /** KASUMI encrypt only (UEA1) */
15361 TEST_CASE_ST(ut_setup, ut_teardown,
15362 test_kasumi_encryption_test_case_1),
15363 TEST_CASE_ST(ut_setup, ut_teardown,
15364 test_kasumi_encryption_test_case_1_sgl),
15365 TEST_CASE_ST(ut_setup, ut_teardown,
15366 test_kasumi_encryption_test_case_1_oop),
15367 TEST_CASE_ST(ut_setup, ut_teardown,
15368 test_kasumi_encryption_test_case_1_oop_sgl),
15369 TEST_CASE_ST(ut_setup, ut_teardown,
15370 test_kasumi_encryption_test_case_2),
15371 TEST_CASE_ST(ut_setup, ut_teardown,
15372 test_kasumi_encryption_test_case_3),
15373 TEST_CASE_ST(ut_setup, ut_teardown,
15374 test_kasumi_encryption_test_case_4),
15375 TEST_CASE_ST(ut_setup, ut_teardown,
15376 test_kasumi_encryption_test_case_5),
15378 /** KASUMI decrypt only (UEA1) */
15379 TEST_CASE_ST(ut_setup, ut_teardown,
15380 test_kasumi_decryption_test_case_1),
15381 TEST_CASE_ST(ut_setup, ut_teardown,
15382 test_kasumi_decryption_test_case_2),
15383 TEST_CASE_ST(ut_setup, ut_teardown,
15384 test_kasumi_decryption_test_case_3),
15385 TEST_CASE_ST(ut_setup, ut_teardown,
15386 test_kasumi_decryption_test_case_4),
15387 TEST_CASE_ST(ut_setup, ut_teardown,
15388 test_kasumi_decryption_test_case_5),
15389 TEST_CASE_ST(ut_setup, ut_teardown,
15390 test_kasumi_decryption_test_case_1_oop),
15391 TEST_CASE_ST(ut_setup, ut_teardown,
15392 test_kasumi_cipher_auth_test_case_1),
15394 /** KASUMI generate auth, then encrypt (F8) */
15395 TEST_CASE_ST(ut_setup, ut_teardown,
15396 test_kasumi_auth_cipher_test_case_1),
15397 TEST_CASE_ST(ut_setup, ut_teardown,
15398 test_kasumi_auth_cipher_test_case_2),
15399 TEST_CASE_ST(ut_setup, ut_teardown,
15400 test_kasumi_auth_cipher_test_case_2_oop),
15401 TEST_CASE_ST(ut_setup, ut_teardown,
15402 test_kasumi_auth_cipher_test_case_2_sgl),
15403 TEST_CASE_ST(ut_setup, ut_teardown,
15404 test_kasumi_auth_cipher_test_case_2_oop_sgl),
15406 /** KASUMI decrypt (F8), then verify auth */
15407 TEST_CASE_ST(ut_setup, ut_teardown,
15408 test_kasumi_auth_cipher_verify_test_case_1),
15409 TEST_CASE_ST(ut_setup, ut_teardown,
15410 test_kasumi_auth_cipher_verify_test_case_2),
15411 TEST_CASE_ST(ut_setup, ut_teardown,
15412 test_kasumi_auth_cipher_verify_test_case_2_oop),
15413 TEST_CASE_ST(ut_setup, ut_teardown,
15414 test_kasumi_auth_cipher_verify_test_case_2_sgl),
15415 TEST_CASE_ST(ut_setup, ut_teardown,
15416 test_kasumi_auth_cipher_verify_test_case_2_oop_sgl),
15422 static struct unit_test_suite cryptodev_esn_testsuite = {
15423 .suite_name = "ESN Test Suite",
15424 .setup = esn_testsuite_setup,
15425 .unit_test_cases = {
15426 TEST_CASE_ST(ut_setup, ut_teardown,
15427 auth_encrypt_AES128CBC_HMAC_SHA1_esn_check),
15428 TEST_CASE_ST(ut_setup, ut_teardown,
15429 auth_decrypt_AES128CBC_HMAC_SHA1_esn_check),
15434 static struct unit_test_suite cryptodev_negative_aes_gcm_testsuite = {
15435 .suite_name = "Negative AES GCM Test Suite",
15436 .setup = negative_aes_gcm_testsuite_setup,
15437 .unit_test_cases = {
15438 TEST_CASE_ST(ut_setup, ut_teardown,
15439 test_AES_GCM_auth_encryption_fail_iv_corrupt),
15440 TEST_CASE_ST(ut_setup, ut_teardown,
15441 test_AES_GCM_auth_encryption_fail_in_data_corrupt),
15442 TEST_CASE_ST(ut_setup, ut_teardown,
15443 test_AES_GCM_auth_encryption_fail_out_data_corrupt),
15444 TEST_CASE_ST(ut_setup, ut_teardown,
15445 test_AES_GCM_auth_encryption_fail_aad_len_corrupt),
15446 TEST_CASE_ST(ut_setup, ut_teardown,
15447 test_AES_GCM_auth_encryption_fail_aad_corrupt),
15448 TEST_CASE_ST(ut_setup, ut_teardown,
15449 test_AES_GCM_auth_encryption_fail_tag_corrupt),
15450 TEST_CASE_ST(ut_setup, ut_teardown,
15451 test_AES_GCM_auth_decryption_fail_iv_corrupt),
15452 TEST_CASE_ST(ut_setup, ut_teardown,
15453 test_AES_GCM_auth_decryption_fail_in_data_corrupt),
15454 TEST_CASE_ST(ut_setup, ut_teardown,
15455 test_AES_GCM_auth_decryption_fail_out_data_corrupt),
15456 TEST_CASE_ST(ut_setup, ut_teardown,
15457 test_AES_GCM_auth_decryption_fail_aad_len_corrupt),
15458 TEST_CASE_ST(ut_setup, ut_teardown,
15459 test_AES_GCM_auth_decryption_fail_aad_corrupt),
15460 TEST_CASE_ST(ut_setup, ut_teardown,
15461 test_AES_GCM_auth_decryption_fail_tag_corrupt),
15467 static struct unit_test_suite cryptodev_negative_aes_gmac_testsuite = {
15468 .suite_name = "Negative AES GMAC Test Suite",
15469 .setup = negative_aes_gmac_testsuite_setup,
15470 .unit_test_cases = {
15471 TEST_CASE_ST(ut_setup, ut_teardown,
15472 authentication_verify_AES128_GMAC_fail_data_corrupt),
15473 TEST_CASE_ST(ut_setup, ut_teardown,
15474 authentication_verify_AES128_GMAC_fail_tag_corrupt),
15480 static struct unit_test_suite cryptodev_mixed_cipher_hash_testsuite = {
15481 .suite_name = "Mixed CIPHER + HASH algorithms Test Suite",
15482 .setup = mixed_cipher_hash_testsuite_setup,
15483 .unit_test_cases = {
15484 /** AUTH AES CMAC + CIPHER AES CTR */
15485 TEST_CASE_ST(ut_setup, ut_teardown,
15486 test_aes_cmac_aes_ctr_digest_enc_test_case_1),
15487 TEST_CASE_ST(ut_setup, ut_teardown,
15488 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
15489 TEST_CASE_ST(ut_setup, ut_teardown,
15490 test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
15491 TEST_CASE_ST(ut_setup, ut_teardown,
15492 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
15493 TEST_CASE_ST(ut_setup, ut_teardown,
15494 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1),
15495 TEST_CASE_ST(ut_setup, ut_teardown,
15496 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
15497 TEST_CASE_ST(ut_setup, ut_teardown,
15498 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
15499 TEST_CASE_ST(ut_setup, ut_teardown,
15500 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
15502 /** AUTH ZUC + CIPHER SNOW3G */
15503 TEST_CASE_ST(ut_setup, ut_teardown,
15504 test_auth_zuc_cipher_snow_test_case_1),
15505 TEST_CASE_ST(ut_setup, ut_teardown,
15506 test_verify_auth_zuc_cipher_snow_test_case_1),
15507 /** AUTH AES CMAC + CIPHER SNOW3G */
15508 TEST_CASE_ST(ut_setup, ut_teardown,
15509 test_auth_aes_cmac_cipher_snow_test_case_1),
15510 TEST_CASE_ST(ut_setup, ut_teardown,
15511 test_verify_auth_aes_cmac_cipher_snow_test_case_1),
15512 /** AUTH ZUC + CIPHER AES CTR */
15513 TEST_CASE_ST(ut_setup, ut_teardown,
15514 test_auth_zuc_cipher_aes_ctr_test_case_1),
15515 TEST_CASE_ST(ut_setup, ut_teardown,
15516 test_verify_auth_zuc_cipher_aes_ctr_test_case_1),
15517 /** AUTH SNOW3G + CIPHER AES CTR */
15518 TEST_CASE_ST(ut_setup, ut_teardown,
15519 test_auth_snow_cipher_aes_ctr_test_case_1),
15520 TEST_CASE_ST(ut_setup, ut_teardown,
15521 test_verify_auth_snow_cipher_aes_ctr_test_case_1),
15522 /** AUTH SNOW3G + CIPHER ZUC */
15523 TEST_CASE_ST(ut_setup, ut_teardown,
15524 test_auth_snow_cipher_zuc_test_case_1),
15525 TEST_CASE_ST(ut_setup, ut_teardown,
15526 test_verify_auth_snow_cipher_zuc_test_case_1),
15527 /** AUTH AES CMAC + CIPHER ZUC */
15528 TEST_CASE_ST(ut_setup, ut_teardown,
15529 test_auth_aes_cmac_cipher_zuc_test_case_1),
15530 TEST_CASE_ST(ut_setup, ut_teardown,
15531 test_verify_auth_aes_cmac_cipher_zuc_test_case_1),
15533 /** AUTH NULL + CIPHER SNOW3G */
15534 TEST_CASE_ST(ut_setup, ut_teardown,
15535 test_auth_null_cipher_snow_test_case_1),
15536 TEST_CASE_ST(ut_setup, ut_teardown,
15537 test_verify_auth_null_cipher_snow_test_case_1),
15538 /** AUTH NULL + CIPHER ZUC */
15539 TEST_CASE_ST(ut_setup, ut_teardown,
15540 test_auth_null_cipher_zuc_test_case_1),
15541 TEST_CASE_ST(ut_setup, ut_teardown,
15542 test_verify_auth_null_cipher_zuc_test_case_1),
15543 /** AUTH SNOW3G + CIPHER NULL */
15544 TEST_CASE_ST(ut_setup, ut_teardown,
15545 test_auth_snow_cipher_null_test_case_1),
15546 TEST_CASE_ST(ut_setup, ut_teardown,
15547 test_verify_auth_snow_cipher_null_test_case_1),
15548 /** AUTH ZUC + CIPHER NULL */
15549 TEST_CASE_ST(ut_setup, ut_teardown,
15550 test_auth_zuc_cipher_null_test_case_1),
15551 TEST_CASE_ST(ut_setup, ut_teardown,
15552 test_verify_auth_zuc_cipher_null_test_case_1),
15553 /** AUTH NULL + CIPHER AES CTR */
15554 TEST_CASE_ST(ut_setup, ut_teardown,
15555 test_auth_null_cipher_aes_ctr_test_case_1),
15556 TEST_CASE_ST(ut_setup, ut_teardown,
15557 test_verify_auth_null_cipher_aes_ctr_test_case_1),
15558 /** AUTH AES CMAC + CIPHER NULL */
15559 TEST_CASE_ST(ut_setup, ut_teardown,
15560 test_auth_aes_cmac_cipher_null_test_case_1),
15561 TEST_CASE_ST(ut_setup, ut_teardown,
15562 test_verify_auth_aes_cmac_cipher_null_test_case_1),
15568 run_cryptodev_testsuite(const char *pmd_name)
15570 uint8_t ret, j, i = 0, blk_start_idx = 0;
15571 const enum blockcipher_test_type blk_suites[] = {
15572 BLKCIPHER_AES_CHAIN_TYPE,
15573 BLKCIPHER_AES_CIPHERONLY_TYPE,
15574 BLKCIPHER_AES_DOCSIS_TYPE,
15575 BLKCIPHER_3DES_CHAIN_TYPE,
15576 BLKCIPHER_3DES_CIPHERONLY_TYPE,
15577 BLKCIPHER_DES_CIPHERONLY_TYPE,
15578 BLKCIPHER_DES_DOCSIS_TYPE,
15579 BLKCIPHER_AUTHONLY_TYPE};
15580 struct unit_test_suite *static_suites[] = {
15581 &cryptodev_multi_session_testsuite,
15582 &cryptodev_null_testsuite,
15583 &cryptodev_aes_ccm_auth_testsuite,
15584 &cryptodev_aes_gcm_auth_testsuite,
15585 &cryptodev_aes_gmac_auth_testsuite,
15586 &cryptodev_snow3g_testsuite,
15587 &cryptodev_chacha20_poly1305_testsuite,
15588 &cryptodev_zuc_testsuite,
15589 &cryptodev_hmac_md5_auth_testsuite,
15590 &cryptodev_kasumi_testsuite,
15591 &cryptodev_esn_testsuite,
15592 &cryptodev_negative_aes_gcm_testsuite,
15593 &cryptodev_negative_aes_gmac_testsuite,
15594 &cryptodev_mixed_cipher_hash_testsuite,
15595 &cryptodev_negative_hmac_sha1_testsuite,
15596 &cryptodev_gen_testsuite,
15597 #ifdef RTE_LIB_SECURITY
15598 &ipsec_proto_testsuite,
15599 &pdcp_proto_testsuite,
15600 &docsis_proto_testsuite,
15604 static struct unit_test_suite ts = {
15605 .suite_name = "Cryptodev Unit Test Suite",
15606 .setup = testsuite_setup,
15607 .teardown = testsuite_teardown,
15608 .unit_test_cases = {TEST_CASES_END()}
15611 gbl_driver_id = rte_cryptodev_driver_id_get(pmd_name);
15613 if (gbl_driver_id == -1) {
15614 RTE_LOG(ERR, USER1, "%s PMD must be loaded.\n", pmd_name);
15615 return TEST_SKIPPED;
15618 ts.unit_test_suites = malloc(sizeof(struct unit_test_suite *) *
15619 (RTE_DIM(blk_suites) + RTE_DIM(static_suites)));
15621 ADD_BLOCKCIPHER_TESTSUITE(i, ts, blk_suites, RTE_DIM(blk_suites));
15622 ADD_STATIC_TESTSUITE(i, ts, static_suites, RTE_DIM(static_suites));
15623 ret = unit_test_suite_runner(&ts);
15625 FREE_BLOCKCIPHER_TESTSUITE(blk_start_idx, ts, RTE_DIM(blk_suites));
15626 free(ts.unit_test_suites);
15631 require_feature_flag(const char *pmd_name, uint64_t flag, const char *flag_name)
15633 struct rte_cryptodev_info dev_info;
15634 uint8_t i, nb_devs;
15637 driver_id = rte_cryptodev_driver_id_get(pmd_name);
15638 if (driver_id == -1) {
15639 RTE_LOG(WARNING, USER1, "%s PMD must be loaded.\n", pmd_name);
15640 return TEST_SKIPPED;
15643 nb_devs = rte_cryptodev_count();
15645 RTE_LOG(WARNING, USER1, "No crypto devices found?\n");
15646 return TEST_SKIPPED;
15649 for (i = 0; i < nb_devs; i++) {
15650 rte_cryptodev_info_get(i, &dev_info);
15651 if (dev_info.driver_id == driver_id) {
15652 if (!(dev_info.feature_flags & flag)) {
15653 RTE_LOG(INFO, USER1, "%s not supported\n",
15655 return TEST_SKIPPED;
15657 return 0; /* found */
15661 RTE_LOG(INFO, USER1, "%s not supported\n", flag_name);
15662 return TEST_SKIPPED;
15666 test_cryptodev_qat(void)
15668 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
15672 test_cryptodev_virtio(void)
15674 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD));
15678 test_cryptodev_aesni_mb(void)
15680 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
15684 test_cryptodev_cpu_aesni_mb(void)
15687 enum rte_security_session_action_type at = gbl_action_type;
15688 gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
15689 rc = run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
15690 gbl_action_type = at;
15695 test_cryptodev_chacha_poly_mb(void)
15698 enum rte_security_session_action_type at = gbl_action_type;
15699 rc = run_cryptodev_testsuite(
15700 RTE_STR(CRYPTODEV_NAME_CHACHA20_POLY1305_PMD));
15701 gbl_action_type = at;
15706 test_cryptodev_openssl(void)
15708 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
15712 test_cryptodev_aesni_gcm(void)
15714 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
15718 test_cryptodev_cpu_aesni_gcm(void)
15721 enum rte_security_session_action_type at = gbl_action_type;
15722 gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
15723 rc = run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
15724 gbl_action_type = at;
15729 test_cryptodev_mlx5(void)
15731 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_MLX5_PMD));
15735 test_cryptodev_null(void)
15737 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_NULL_PMD));
15741 test_cryptodev_sw_snow3g(void)
15743 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
15747 test_cryptodev_sw_kasumi(void)
15749 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
15753 test_cryptodev_sw_zuc(void)
15755 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
15759 test_cryptodev_armv8(void)
15761 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
15765 test_cryptodev_mrvl(void)
15767 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
15770 #ifdef RTE_CRYPTO_SCHEDULER
15773 test_cryptodev_scheduler(void)
15775 uint8_t ret, sched_i, j, i = 0, blk_start_idx = 0;
15776 const enum blockcipher_test_type blk_suites[] = {
15777 BLKCIPHER_AES_CHAIN_TYPE,
15778 BLKCIPHER_AES_CIPHERONLY_TYPE,
15779 BLKCIPHER_AUTHONLY_TYPE
15781 static struct unit_test_suite scheduler_multicore = {
15782 .suite_name = "Scheduler Multicore Unit Test Suite",
15783 .setup = scheduler_multicore_testsuite_setup,
15784 .teardown = scheduler_mode_testsuite_teardown,
15785 .unit_test_cases = {TEST_CASES_END()}
15787 static struct unit_test_suite scheduler_round_robin = {
15788 .suite_name = "Scheduler Round Robin Unit Test Suite",
15789 .setup = scheduler_roundrobin_testsuite_setup,
15790 .teardown = scheduler_mode_testsuite_teardown,
15791 .unit_test_cases = {TEST_CASES_END()}
15793 static struct unit_test_suite scheduler_failover = {
15794 .suite_name = "Scheduler Failover Unit Test Suite",
15795 .setup = scheduler_failover_testsuite_setup,
15796 .teardown = scheduler_mode_testsuite_teardown,
15797 .unit_test_cases = {TEST_CASES_END()}
15799 static struct unit_test_suite scheduler_pkt_size_distr = {
15800 .suite_name = "Scheduler Pkt Size Distr Unit Test Suite",
15801 .setup = scheduler_pkt_size_distr_testsuite_setup,
15802 .teardown = scheduler_mode_testsuite_teardown,
15803 .unit_test_cases = {TEST_CASES_END()}
15805 struct unit_test_suite *sched_mode_suites[] = {
15806 &scheduler_multicore,
15807 &scheduler_round_robin,
15808 &scheduler_failover,
15809 &scheduler_pkt_size_distr
15811 static struct unit_test_suite scheduler_config = {
15812 .suite_name = "Crypto Device Scheduler Config Unit Test Suite",
15813 .unit_test_cases = {
15814 TEST_CASE(test_scheduler_attach_worker_op),
15815 TEST_CASE(test_scheduler_mode_multicore_op),
15816 TEST_CASE(test_scheduler_mode_roundrobin_op),
15817 TEST_CASE(test_scheduler_mode_failover_op),
15818 TEST_CASE(test_scheduler_mode_pkt_size_distr_op),
15819 TEST_CASE(test_scheduler_detach_worker_op),
15821 TEST_CASES_END() /**< NULL terminate array */
15824 struct unit_test_suite *static_suites[] = {
15828 static struct unit_test_suite ts = {
15829 .suite_name = "Scheduler Unit Test Suite",
15830 .setup = scheduler_testsuite_setup,
15831 .teardown = testsuite_teardown,
15832 .unit_test_cases = {TEST_CASES_END()}
15835 gbl_driver_id = rte_cryptodev_driver_id_get(
15836 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
15838 if (gbl_driver_id == -1) {
15839 RTE_LOG(ERR, USER1, "SCHEDULER PMD must be loaded.\n");
15840 return TEST_SKIPPED;
15843 if (rte_cryptodev_driver_id_get(
15844 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) == -1) {
15845 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded.\n");
15846 return TEST_SKIPPED;
15849 for (sched_i = 0; sched_i < RTE_DIM(sched_mode_suites); sched_i++) {
15851 sched_mode_suites[sched_i]->unit_test_suites = malloc(sizeof
15852 (struct unit_test_suite *) *
15853 (RTE_DIM(blk_suites) + 1));
15854 ADD_BLOCKCIPHER_TESTSUITE(blk_i, (*sched_mode_suites[sched_i]),
15855 blk_suites, RTE_DIM(blk_suites));
15856 sched_mode_suites[sched_i]->unit_test_suites[blk_i] = &end_testsuite;
15859 ts.unit_test_suites = malloc(sizeof(struct unit_test_suite *) *
15860 (RTE_DIM(static_suites) + RTE_DIM(sched_mode_suites)));
15861 ADD_STATIC_TESTSUITE(i, ts, sched_mode_suites,
15862 RTE_DIM(sched_mode_suites));
15863 ADD_STATIC_TESTSUITE(i, ts, static_suites, RTE_DIM(static_suites));
15864 ret = unit_test_suite_runner(&ts);
15866 for (sched_i = 0; sched_i < RTE_DIM(sched_mode_suites); sched_i++) {
15867 FREE_BLOCKCIPHER_TESTSUITE(blk_start_idx,
15868 (*sched_mode_suites[sched_i]),
15869 RTE_DIM(blk_suites));
15870 free(sched_mode_suites[sched_i]->unit_test_suites);
15872 free(ts.unit_test_suites);
15876 REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler);
15881 test_cryptodev_dpaa2_sec(void)
15883 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
15887 test_cryptodev_dpaa_sec(void)
15889 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD));
15893 test_cryptodev_ccp(void)
15895 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CCP_PMD));
15899 test_cryptodev_octeontx(void)
15901 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD));
15905 test_cryptodev_caam_jr(void)
15907 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD));
15911 test_cryptodev_nitrox(void)
15913 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_NITROX_PMD));
15917 test_cryptodev_bcmfs(void)
15919 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_BCMFS_PMD));
15923 test_cryptodev_qat_raw_api(void)
15925 static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD);
15928 ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
15933 global_api_test_type = CRYPTODEV_RAW_API_TEST;
15934 ret = run_cryptodev_testsuite(pmd_name);
15935 global_api_test_type = CRYPTODEV_API_TEST;
15941 test_cryptodev_cn9k(void)
15943 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CN9K_PMD));
15947 test_cryptodev_cn10k(void)
15949 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CN10K_PMD));
15953 test_cryptodev_dpaa2_sec_raw_api(void)
15955 static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD);
15958 ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
15963 global_api_test_type = CRYPTODEV_RAW_API_TEST;
15964 ret = run_cryptodev_testsuite(pmd_name);
15965 global_api_test_type = CRYPTODEV_API_TEST;
15971 test_cryptodev_dpaa_sec_raw_api(void)
15973 static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD);
15976 ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
15981 global_api_test_type = CRYPTODEV_RAW_API_TEST;
15982 ret = run_cryptodev_testsuite(pmd_name);
15983 global_api_test_type = CRYPTODEV_API_TEST;
15988 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_raw_api_autotest,
15989 test_cryptodev_dpaa2_sec_raw_api);
15990 REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_raw_api_autotest,
15991 test_cryptodev_dpaa_sec_raw_api);
15992 REGISTER_TEST_COMMAND(cryptodev_qat_raw_api_autotest,
15993 test_cryptodev_qat_raw_api);
15994 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
15995 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
15996 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_mb_autotest,
15997 test_cryptodev_cpu_aesni_mb);
15998 REGISTER_TEST_COMMAND(cryptodev_chacha_poly_mb_autotest,
15999 test_cryptodev_chacha_poly_mb);
16000 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl);
16001 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm);
16002 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_gcm_autotest,
16003 test_cryptodev_cpu_aesni_gcm);
16004 REGISTER_TEST_COMMAND(cryptodev_mlx5_autotest, test_cryptodev_mlx5);
16005 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null);
16006 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
16007 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);
16008 REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc);
16009 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_autotest, test_cryptodev_armv8);
16010 REGISTER_TEST_COMMAND(cryptodev_sw_mvsam_autotest, test_cryptodev_mrvl);
16011 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_autotest, test_cryptodev_dpaa2_sec);
16012 REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_autotest, test_cryptodev_dpaa_sec);
16013 REGISTER_TEST_COMMAND(cryptodev_ccp_autotest, test_cryptodev_ccp);
16014 REGISTER_TEST_COMMAND(cryptodev_virtio_autotest, test_cryptodev_virtio);
16015 REGISTER_TEST_COMMAND(cryptodev_octeontx_autotest, test_cryptodev_octeontx);
16016 REGISTER_TEST_COMMAND(cryptodev_caam_jr_autotest, test_cryptodev_caam_jr);
16017 REGISTER_TEST_COMMAND(cryptodev_nitrox_autotest, test_cryptodev_nitrox);
16018 REGISTER_TEST_COMMAND(cryptodev_bcmfs_autotest, test_cryptodev_bcmfs);
16019 REGISTER_TEST_COMMAND(cryptodev_cn9k_autotest, test_cryptodev_cn9k);
16020 REGISTER_TEST_COMMAND(cryptodev_cn10k_autotest, test_cryptodev_cn10k);