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 "
839 * Stop the device. Device would be started again by individual test
840 * case setup routine.
842 rte_cryptodev_stop(ts_params->valid_devs[0]);
848 pdcp_proto_testsuite_setup(void)
850 struct crypto_testsuite_params *ts_params = &testsuite_params;
851 uint8_t dev_id = ts_params->valid_devs[0];
852 struct rte_cryptodev_info dev_info;
853 const enum rte_crypto_cipher_algorithm ciphers[] = {
854 RTE_CRYPTO_CIPHER_NULL,
855 RTE_CRYPTO_CIPHER_AES_CTR,
856 RTE_CRYPTO_CIPHER_ZUC_EEA3,
857 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
859 const enum rte_crypto_auth_algorithm auths[] = {
860 RTE_CRYPTO_AUTH_NULL,
861 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
862 RTE_CRYPTO_AUTH_AES_CMAC,
863 RTE_CRYPTO_AUTH_ZUC_EIA3
866 rte_cryptodev_info_get(dev_id, &dev_info);
868 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
869 !(dev_info.feature_flags &
870 RTE_CRYPTODEV_FF_SECURITY)) {
871 RTE_LOG(INFO, USER1, "Feature flag requirements for PDCP Proto "
872 "testsuite not met\n");
876 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
877 && check_auth_capabilities_supported(auths,
878 RTE_DIM(auths)) != 0) {
879 RTE_LOG(INFO, USER1, "Capability requirements for PDCP Proto "
880 "testsuite not met\n");
888 docsis_proto_testsuite_setup(void)
890 struct crypto_testsuite_params *ts_params = &testsuite_params;
891 uint8_t dev_id = ts_params->valid_devs[0];
892 struct rte_cryptodev_info dev_info;
893 const enum rte_crypto_cipher_algorithm ciphers[] = {
894 RTE_CRYPTO_CIPHER_AES_DOCSISBPI
897 rte_cryptodev_info_get(dev_id, &dev_info);
899 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
900 !(dev_info.feature_flags &
901 RTE_CRYPTODEV_FF_SECURITY)) {
902 RTE_LOG(INFO, USER1, "Feature flag requirements for DOCSIS "
903 "Proto testsuite not met\n");
907 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0) {
908 RTE_LOG(INFO, USER1, "Capability requirements for DOCSIS Proto "
909 "testsuite not met\n");
918 aes_ccm_auth_testsuite_setup(void)
920 struct crypto_testsuite_params *ts_params = &testsuite_params;
921 uint8_t dev_id = ts_params->valid_devs[0];
922 struct rte_cryptodev_info dev_info;
923 const enum rte_crypto_aead_algorithm aeads[] = {
924 RTE_CRYPTO_AEAD_AES_CCM
927 rte_cryptodev_info_get(dev_id, &dev_info);
929 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
930 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
931 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
932 RTE_LOG(INFO, USER1, "Feature flag requirements for AES CCM "
933 "testsuite not met\n");
937 if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
938 RTE_LOG(INFO, USER1, "Capability requirements for AES CCM "
939 "testsuite not met\n");
947 aes_gcm_auth_testsuite_setup(void)
949 struct crypto_testsuite_params *ts_params = &testsuite_params;
950 uint8_t dev_id = ts_params->valid_devs[0];
951 struct rte_cryptodev_info dev_info;
952 const enum rte_crypto_aead_algorithm aeads[] = {
953 RTE_CRYPTO_AEAD_AES_GCM
956 rte_cryptodev_info_get(dev_id, &dev_info);
958 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
959 RTE_LOG(INFO, USER1, "Feature flag requirements for AES GCM "
960 "testsuite not met\n");
964 if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
965 RTE_LOG(INFO, USER1, "Capability requirements for AES GCM "
966 "testsuite not met\n");
974 aes_gmac_auth_testsuite_setup(void)
976 struct crypto_testsuite_params *ts_params = &testsuite_params;
977 uint8_t dev_id = ts_params->valid_devs[0];
978 struct rte_cryptodev_info dev_info;
979 const enum rte_crypto_auth_algorithm auths[] = {
980 RTE_CRYPTO_AUTH_AES_GMAC
983 rte_cryptodev_info_get(dev_id, &dev_info);
985 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
986 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
987 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
988 RTE_LOG(INFO, USER1, "Feature flag requirements for AES GMAC "
989 "testsuite not met\n");
993 if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
994 RTE_LOG(INFO, USER1, "Capability requirements for AES GMAC "
995 "testsuite not met\n");
1003 chacha20_poly1305_testsuite_setup(void)
1005 struct crypto_testsuite_params *ts_params = &testsuite_params;
1006 uint8_t dev_id = ts_params->valid_devs[0];
1007 struct rte_cryptodev_info dev_info;
1008 const enum rte_crypto_aead_algorithm aeads[] = {
1009 RTE_CRYPTO_AEAD_CHACHA20_POLY1305
1012 rte_cryptodev_info_get(dev_id, &dev_info);
1014 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1015 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1016 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1017 RTE_LOG(INFO, USER1, "Feature flag requirements for "
1018 "Chacha20-Poly1305 testsuite not met\n");
1019 return TEST_SKIPPED;
1022 if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
1023 RTE_LOG(INFO, USER1, "Capability requirements for "
1024 "Chacha20-Poly1305 testsuite not met\n");
1025 return TEST_SKIPPED;
1032 snow3g_testsuite_setup(void)
1034 struct crypto_testsuite_params *ts_params = &testsuite_params;
1035 uint8_t dev_id = ts_params->valid_devs[0];
1036 struct rte_cryptodev_info dev_info;
1037 const enum rte_crypto_cipher_algorithm ciphers[] = {
1038 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
1041 const enum rte_crypto_auth_algorithm auths[] = {
1042 RTE_CRYPTO_AUTH_SNOW3G_UIA2
1045 rte_cryptodev_info_get(dev_id, &dev_info);
1047 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1048 RTE_LOG(INFO, USER1, "Feature flag requirements for Snow3G "
1049 "testsuite not met\n");
1050 return TEST_SKIPPED;
1053 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1054 && check_auth_capabilities_supported(auths,
1055 RTE_DIM(auths)) != 0) {
1056 RTE_LOG(INFO, USER1, "Capability requirements for Snow3G "
1057 "testsuite not met\n");
1058 return TEST_SKIPPED;
1065 zuc_testsuite_setup(void)
1067 struct crypto_testsuite_params *ts_params = &testsuite_params;
1068 uint8_t dev_id = ts_params->valid_devs[0];
1069 struct rte_cryptodev_info dev_info;
1070 const enum rte_crypto_cipher_algorithm ciphers[] = {
1071 RTE_CRYPTO_CIPHER_ZUC_EEA3
1073 const enum rte_crypto_auth_algorithm auths[] = {
1074 RTE_CRYPTO_AUTH_ZUC_EIA3
1077 rte_cryptodev_info_get(dev_id, &dev_info);
1079 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1080 RTE_LOG(INFO, USER1, "Feature flag requirements for ZUC "
1081 "testsuite not met\n");
1082 return TEST_SKIPPED;
1085 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1086 && check_auth_capabilities_supported(auths,
1087 RTE_DIM(auths)) != 0) {
1088 RTE_LOG(INFO, USER1, "Capability requirements for ZUC "
1089 "testsuite not met\n");
1090 return TEST_SKIPPED;
1097 hmac_md5_auth_testsuite_setup(void)
1099 struct crypto_testsuite_params *ts_params = &testsuite_params;
1100 uint8_t dev_id = ts_params->valid_devs[0];
1101 struct rte_cryptodev_info dev_info;
1102 const enum rte_crypto_auth_algorithm auths[] = {
1103 RTE_CRYPTO_AUTH_MD5_HMAC
1106 rte_cryptodev_info_get(dev_id, &dev_info);
1108 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1109 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1110 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1111 RTE_LOG(INFO, USER1, "Feature flag requirements for HMAC MD5 "
1112 "Auth testsuite not met\n");
1113 return TEST_SKIPPED;
1116 if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
1117 RTE_LOG(INFO, USER1, "Capability requirements for HMAC MD5 "
1118 "testsuite not met\n");
1119 return TEST_SKIPPED;
1126 kasumi_testsuite_setup(void)
1128 struct crypto_testsuite_params *ts_params = &testsuite_params;
1129 uint8_t dev_id = ts_params->valid_devs[0];
1130 struct rte_cryptodev_info dev_info;
1131 const enum rte_crypto_cipher_algorithm ciphers[] = {
1132 RTE_CRYPTO_CIPHER_KASUMI_F8
1134 const enum rte_crypto_auth_algorithm auths[] = {
1135 RTE_CRYPTO_AUTH_KASUMI_F9
1138 rte_cryptodev_info_get(dev_id, &dev_info);
1140 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1141 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1142 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1143 RTE_LOG(INFO, USER1, "Feature flag requirements for Kasumi "
1144 "testsuite not met\n");
1145 return TEST_SKIPPED;
1148 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1149 && check_auth_capabilities_supported(auths,
1150 RTE_DIM(auths)) != 0) {
1151 RTE_LOG(INFO, USER1, "Capability requirements for Kasumi "
1152 "testsuite not met\n");
1153 return TEST_SKIPPED;
1160 negative_aes_gcm_testsuite_setup(void)
1162 struct crypto_testsuite_params *ts_params = &testsuite_params;
1163 uint8_t dev_id = ts_params->valid_devs[0];
1164 struct rte_cryptodev_info dev_info;
1165 const enum rte_crypto_aead_algorithm aeads[] = {
1166 RTE_CRYPTO_AEAD_AES_GCM
1169 rte_cryptodev_info_get(dev_id, &dev_info);
1171 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1172 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1173 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1174 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1175 "AES GCM testsuite not met\n");
1176 return TEST_SKIPPED;
1179 if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
1180 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1181 "AES GCM testsuite not met\n");
1182 return TEST_SKIPPED;
1189 negative_aes_gmac_testsuite_setup(void)
1191 struct crypto_testsuite_params *ts_params = &testsuite_params;
1192 uint8_t dev_id = ts_params->valid_devs[0];
1193 struct rte_cryptodev_info dev_info;
1194 const enum rte_crypto_auth_algorithm auths[] = {
1195 RTE_CRYPTO_AUTH_AES_GMAC
1198 rte_cryptodev_info_get(dev_id, &dev_info);
1200 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1201 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1202 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1203 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1204 "AES GMAC testsuite not met\n");
1205 return TEST_SKIPPED;
1208 if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
1209 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1210 "AES GMAC testsuite not met\n");
1211 return TEST_SKIPPED;
1218 mixed_cipher_hash_testsuite_setup(void)
1220 struct crypto_testsuite_params *ts_params = &testsuite_params;
1221 uint8_t dev_id = ts_params->valid_devs[0];
1222 struct rte_cryptodev_info dev_info;
1223 uint64_t feat_flags;
1224 const enum rte_crypto_cipher_algorithm ciphers[] = {
1225 RTE_CRYPTO_CIPHER_NULL,
1226 RTE_CRYPTO_CIPHER_AES_CTR,
1227 RTE_CRYPTO_CIPHER_ZUC_EEA3,
1228 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
1230 const enum rte_crypto_auth_algorithm auths[] = {
1231 RTE_CRYPTO_AUTH_NULL,
1232 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
1233 RTE_CRYPTO_AUTH_AES_CMAC,
1234 RTE_CRYPTO_AUTH_ZUC_EIA3
1237 rte_cryptodev_info_get(dev_id, &dev_info);
1238 feat_flags = dev_info.feature_flags;
1240 if (!(feat_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1241 (global_api_test_type == CRYPTODEV_RAW_API_TEST)) {
1242 RTE_LOG(INFO, USER1, "Feature flag requirements for Mixed "
1243 "Cipher Hash testsuite not met\n");
1244 return TEST_SKIPPED;
1247 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1248 && check_auth_capabilities_supported(auths,
1249 RTE_DIM(auths)) != 0) {
1250 RTE_LOG(INFO, USER1, "Capability requirements for Mixed "
1251 "Cipher Hash testsuite not met\n");
1252 return TEST_SKIPPED;
1259 esn_testsuite_setup(void)
1261 struct crypto_testsuite_params *ts_params = &testsuite_params;
1262 uint8_t dev_id = ts_params->valid_devs[0];
1263 struct rte_cryptodev_info dev_info;
1264 const enum rte_crypto_cipher_algorithm ciphers[] = {
1265 RTE_CRYPTO_CIPHER_AES_CBC
1267 const enum rte_crypto_auth_algorithm auths[] = {
1268 RTE_CRYPTO_AUTH_SHA1_HMAC
1271 rte_cryptodev_info_get(dev_id, &dev_info);
1273 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1274 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1275 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1276 RTE_LOG(INFO, USER1, "Feature flag requirements for ESN "
1277 "testsuite not met\n");
1278 return TEST_SKIPPED;
1281 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1282 && check_auth_capabilities_supported(auths,
1283 RTE_DIM(auths)) != 0) {
1284 RTE_LOG(INFO, USER1, "Capability requirements for ESN "
1285 "testsuite not met\n");
1286 return TEST_SKIPPED;
1293 multi_session_testsuite_setup(void)
1295 struct crypto_testsuite_params *ts_params = &testsuite_params;
1296 uint8_t dev_id = ts_params->valid_devs[0];
1297 struct rte_cryptodev_info dev_info;
1298 const enum rte_crypto_cipher_algorithm ciphers[] = {
1299 RTE_CRYPTO_CIPHER_AES_CBC
1301 const enum rte_crypto_auth_algorithm auths[] = {
1302 RTE_CRYPTO_AUTH_SHA512_HMAC
1305 rte_cryptodev_info_get(dev_id, &dev_info);
1307 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1308 RTE_LOG(INFO, USER1, "Feature flag requirements for Multi "
1309 "Session testsuite not met\n");
1310 return TEST_SKIPPED;
1313 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1314 && check_auth_capabilities_supported(auths,
1315 RTE_DIM(auths)) != 0) {
1316 RTE_LOG(INFO, USER1, "Capability requirements for Multi "
1317 "Session testsuite not met\n");
1318 return TEST_SKIPPED;
1325 negative_hmac_sha1_testsuite_setup(void)
1327 struct crypto_testsuite_params *ts_params = &testsuite_params;
1328 uint8_t dev_id = ts_params->valid_devs[0];
1329 struct rte_cryptodev_info dev_info;
1330 const enum rte_crypto_cipher_algorithm ciphers[] = {
1331 RTE_CRYPTO_CIPHER_AES_CBC
1333 const enum rte_crypto_auth_algorithm auths[] = {
1334 RTE_CRYPTO_AUTH_SHA1_HMAC
1337 rte_cryptodev_info_get(dev_id, &dev_info);
1339 if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1340 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1341 !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1342 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1343 "HMAC SHA1 testsuite not met\n");
1344 return TEST_SKIPPED;
1347 if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1348 && check_auth_capabilities_supported(auths,
1349 RTE_DIM(auths)) != 0) {
1350 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1351 "HMAC SHA1 testsuite not met\n");
1352 return TEST_SKIPPED;
1359 dev_configure_and_start(uint64_t ff_disable)
1361 struct crypto_testsuite_params *ts_params = &testsuite_params;
1362 struct crypto_unittest_params *ut_params = &unittest_params;
1366 /* Clear unit test parameters before running test */
1367 memset(ut_params, 0, sizeof(*ut_params));
1369 /* Reconfigure device to default parameters */
1370 ts_params->conf.socket_id = SOCKET_ID_ANY;
1371 ts_params->conf.ff_disable = ff_disable;
1372 ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
1373 ts_params->qp_conf.mp_session = ts_params->session_mpool;
1374 ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
1376 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1378 "Failed to configure cryptodev %u",
1379 ts_params->valid_devs[0]);
1381 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
1382 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1383 ts_params->valid_devs[0], qp_id,
1384 &ts_params->qp_conf,
1385 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1386 "Failed to setup queue pair %u on cryptodev %u",
1387 qp_id, ts_params->valid_devs[0]);
1391 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
1393 /* Start the device */
1394 TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
1395 "Failed to start cryptodev %u",
1396 ts_params->valid_devs[0]);
1398 return TEST_SUCCESS;
1404 /* Configure and start the device with security feature disabled */
1405 return dev_configure_and_start(RTE_CRYPTODEV_FF_SECURITY);
1409 ut_setup_security(void)
1411 /* Configure and start the device with no features disabled */
1412 return dev_configure_and_start(0);
1418 struct crypto_testsuite_params *ts_params = &testsuite_params;
1419 struct crypto_unittest_params *ut_params = &unittest_params;
1420 struct rte_cryptodev_stats stats;
1422 /* free crypto session structure */
1423 #ifdef RTE_LIB_SECURITY
1424 if (ut_params->type == RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL) {
1425 if (ut_params->sec_session) {
1426 rte_security_session_destroy(rte_cryptodev_get_sec_ctx
1427 (ts_params->valid_devs[0]),
1428 ut_params->sec_session);
1429 ut_params->sec_session = NULL;
1434 if (ut_params->sess) {
1435 rte_cryptodev_sym_session_clear(
1436 ts_params->valid_devs[0],
1438 rte_cryptodev_sym_session_free(ut_params->sess);
1439 ut_params->sess = NULL;
1443 /* free crypto operation structure */
1445 rte_crypto_op_free(ut_params->op);
1448 * free mbuf - both obuf and ibuf are usually the same,
1449 * so check if they point at the same address is necessary,
1450 * to avoid freeing the mbuf twice.
1452 if (ut_params->obuf) {
1453 rte_pktmbuf_free(ut_params->obuf);
1454 if (ut_params->ibuf == ut_params->obuf)
1455 ut_params->ibuf = 0;
1456 ut_params->obuf = 0;
1458 if (ut_params->ibuf) {
1459 rte_pktmbuf_free(ut_params->ibuf);
1460 ut_params->ibuf = 0;
1463 if (ts_params->mbuf_pool != NULL)
1464 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
1465 rte_mempool_avail_count(ts_params->mbuf_pool));
1467 rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats);
1469 /* Stop the device */
1470 rte_cryptodev_stop(ts_params->valid_devs[0]);
1474 test_device_configure_invalid_dev_id(void)
1476 struct crypto_testsuite_params *ts_params = &testsuite_params;
1477 uint16_t dev_id, num_devs = 0;
1479 TEST_ASSERT((num_devs = rte_cryptodev_count()) >= 1,
1480 "Need at least %d devices for test", 1);
1482 /* valid dev_id values */
1483 dev_id = ts_params->valid_devs[0];
1485 /* Stop the device in case it's started so it can be configured */
1486 rte_cryptodev_stop(dev_id);
1488 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf),
1489 "Failed test for rte_cryptodev_configure: "
1490 "invalid dev_num %u", dev_id);
1492 /* invalid dev_id values */
1495 TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
1496 "Failed test for rte_cryptodev_configure: "
1497 "invalid dev_num %u", dev_id);
1501 TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
1502 "Failed test for rte_cryptodev_configure:"
1503 "invalid dev_num %u", dev_id);
1505 return TEST_SUCCESS;
1509 test_device_configure_invalid_queue_pair_ids(void)
1511 struct crypto_testsuite_params *ts_params = &testsuite_params;
1512 uint16_t orig_nb_qps = ts_params->conf.nb_queue_pairs;
1514 /* Stop the device in case it's started so it can be configured */
1515 rte_cryptodev_stop(ts_params->valid_devs[0]);
1517 /* valid - max value queue pairs */
1518 ts_params->conf.nb_queue_pairs = orig_nb_qps;
1520 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1522 "Failed to configure cryptodev: dev_id %u, qp_id %u",
1523 ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
1525 /* valid - one queue pairs */
1526 ts_params->conf.nb_queue_pairs = 1;
1528 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1530 "Failed to configure cryptodev: dev_id %u, qp_id %u",
1531 ts_params->valid_devs[0],
1532 ts_params->conf.nb_queue_pairs);
1535 /* invalid - zero queue pairs */
1536 ts_params->conf.nb_queue_pairs = 0;
1538 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1540 "Failed test for rte_cryptodev_configure, dev_id %u,"
1542 ts_params->valid_devs[0],
1543 ts_params->conf.nb_queue_pairs);
1546 /* invalid - max value supported by field queue pairs */
1547 ts_params->conf.nb_queue_pairs = UINT16_MAX;
1549 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1551 "Failed test for rte_cryptodev_configure, dev_id %u,"
1553 ts_params->valid_devs[0],
1554 ts_params->conf.nb_queue_pairs);
1557 /* invalid - max value + 1 queue pairs */
1558 ts_params->conf.nb_queue_pairs = orig_nb_qps + 1;
1560 TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1562 "Failed test for rte_cryptodev_configure, dev_id %u,"
1564 ts_params->valid_devs[0],
1565 ts_params->conf.nb_queue_pairs);
1567 /* revert to original testsuite value */
1568 ts_params->conf.nb_queue_pairs = orig_nb_qps;
1570 return TEST_SUCCESS;
1574 test_queue_pair_descriptor_setup(void)
1576 struct crypto_testsuite_params *ts_params = &testsuite_params;
1577 struct rte_cryptodev_qp_conf qp_conf = {
1578 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
1582 /* Stop the device in case it's started so it can be configured */
1583 rte_cryptodev_stop(ts_params->valid_devs[0]);
1585 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1587 "Failed to configure cryptodev %u",
1588 ts_params->valid_devs[0]);
1591 * Test various ring sizes on this device. memzones can't be
1592 * freed so are re-used if ring is released and re-created.
1594 qp_conf.nb_descriptors = MIN_NUM_OPS_INFLIGHT; /* min size*/
1595 qp_conf.mp_session = ts_params->session_mpool;
1596 qp_conf.mp_session_private = ts_params->session_priv_mpool;
1598 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1599 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1600 ts_params->valid_devs[0], qp_id, &qp_conf,
1601 rte_cryptodev_socket_id(
1602 ts_params->valid_devs[0])),
1604 "rte_cryptodev_queue_pair_setup: num_inflights "
1605 "%u on qp %u on cryptodev %u",
1606 qp_conf.nb_descriptors, qp_id,
1607 ts_params->valid_devs[0]);
1610 qp_conf.nb_descriptors = (uint32_t)(MAX_NUM_OPS_INFLIGHT / 2);
1612 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1613 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1614 ts_params->valid_devs[0], qp_id, &qp_conf,
1615 rte_cryptodev_socket_id(
1616 ts_params->valid_devs[0])),
1618 " rte_cryptodev_queue_pair_setup: num_inflights"
1619 " %u on qp %u on cryptodev %u",
1620 qp_conf.nb_descriptors, qp_id,
1621 ts_params->valid_devs[0]);
1624 qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; /* valid */
1626 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1627 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1628 ts_params->valid_devs[0], qp_id, &qp_conf,
1629 rte_cryptodev_socket_id(
1630 ts_params->valid_devs[0])),
1632 "rte_cryptodev_queue_pair_setup: num_inflights"
1633 " %u on qp %u on cryptodev %u",
1634 qp_conf.nb_descriptors, qp_id,
1635 ts_params->valid_devs[0]);
1638 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
1640 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1641 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1642 ts_params->valid_devs[0], qp_id, &qp_conf,
1643 rte_cryptodev_socket_id(
1644 ts_params->valid_devs[0])),
1646 " rte_cryptodev_queue_pair_setup:"
1647 "num_inflights %u on qp %u on cryptodev %u",
1648 qp_conf.nb_descriptors, qp_id,
1649 ts_params->valid_devs[0]);
1652 /* test invalid queue pair id */
1653 qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT; /*valid */
1655 qp_id = ts_params->conf.nb_queue_pairs; /*invalid */
1657 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
1658 ts_params->valid_devs[0],
1660 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1661 "Failed test for rte_cryptodev_queue_pair_setup:"
1662 "invalid qp %u on cryptodev %u",
1663 qp_id, ts_params->valid_devs[0]);
1665 qp_id = 0xffff; /*invalid*/
1667 TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
1668 ts_params->valid_devs[0],
1670 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1671 "Failed test for rte_cryptodev_queue_pair_setup:"
1672 "invalid qp %u on cryptodev %u",
1673 qp_id, ts_params->valid_devs[0]);
1675 return TEST_SUCCESS;
1678 /* ***** Plaintext data for tests ***** */
1680 const char catch_22_quote_1[] =
1681 "There was only one catch and that was Catch-22, which "
1682 "specified that a concern for one's safety in the face of "
1683 "dangers that were real and immediate was the process of a "
1684 "rational mind. Orr was crazy and could be grounded. All he "
1685 "had to do was ask; and as soon as he did, he would no longer "
1686 "be crazy and would have to fly more missions. Orr would be "
1687 "crazy to fly more missions and sane if he didn't, but if he "
1688 "was sane he had to fly them. If he flew them he was crazy "
1689 "and didn't have to; but if he didn't want to he was sane and "
1690 "had to. Yossarian was moved very deeply by the absolute "
1691 "simplicity of this clause of Catch-22 and let out a "
1692 "respectful whistle. \"That's some catch, that Catch-22\", he "
1693 "observed. \"It's the best there is,\" Doc Daneeka agreed.";
1695 const char catch_22_quote[] =
1696 "What a lousy earth! He wondered how many people were "
1697 "destitute that same night even in his own prosperous country, "
1698 "how many homes were shanties, how many husbands were drunk "
1699 "and wives socked, and how many children were bullied, abused, "
1700 "or abandoned. How many families hungered for food they could "
1701 "not afford to buy? How many hearts were broken? How many "
1702 "suicides would take place that same night, how many people "
1703 "would go insane? How many cockroaches and landlords would "
1704 "triumph? How many winners were losers, successes failures, "
1705 "and rich men poor men? How many wise guys were stupid? How "
1706 "many happy endings were unhappy endings? How many honest men "
1707 "were liars, brave men cowards, loyal men traitors, how many "
1708 "sainted men were corrupt, how many people in positions of "
1709 "trust had sold their souls to bodyguards, how many had never "
1710 "had souls? How many straight-and-narrow paths were crooked "
1711 "paths? How many best families were worst families and how "
1712 "many good people were bad people? When you added them all up "
1713 "and then subtracted, you might be left with only the children, "
1714 "and perhaps with Albert Einstein and an old violinist or "
1715 "sculptor somewhere.";
1717 #define QUOTE_480_BYTES (480)
1718 #define QUOTE_512_BYTES (512)
1719 #define QUOTE_768_BYTES (768)
1720 #define QUOTE_1024_BYTES (1024)
1724 /* ***** SHA1 Hash Tests ***** */
1726 #define HMAC_KEY_LENGTH_SHA1 (DIGEST_BYTE_LENGTH_SHA1)
1728 static uint8_t hmac_sha1_key[] = {
1729 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
1730 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
1731 0xDE, 0xF4, 0xDE, 0xAD };
1733 /* ***** SHA224 Hash Tests ***** */
1735 #define HMAC_KEY_LENGTH_SHA224 (DIGEST_BYTE_LENGTH_SHA224)
1738 /* ***** AES-CBC Cipher Tests ***** */
1740 #define CIPHER_KEY_LENGTH_AES_CBC (16)
1741 #define CIPHER_IV_LENGTH_AES_CBC (CIPHER_KEY_LENGTH_AES_CBC)
1743 static uint8_t aes_cbc_key[] = {
1744 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
1745 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A };
1747 static uint8_t aes_cbc_iv[] = {
1748 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1749 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
1752 /* ***** AES-CBC / HMAC-SHA1 Hash Tests ***** */
1754 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_ciphertext[] = {
1755 0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31,
1756 0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76,
1757 0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E,
1758 0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A,
1759 0x3F, 0x6B, 0x5D, 0xDF, 0x52, 0x85, 0x5F, 0x8E,
1760 0x42, 0x3C, 0xFB, 0xE9, 0x1A, 0x24, 0xD6, 0x08,
1761 0xDD, 0xFD, 0x16, 0xFB, 0xE9, 0x55, 0xEF, 0xF0,
1762 0xA0, 0x8D, 0x13, 0xAB, 0x81, 0xC6, 0x90, 0x01,
1763 0xB5, 0x18, 0x84, 0xB3, 0xF6, 0xE6, 0x11, 0x57,
1764 0xD6, 0x71, 0xC6, 0x3C, 0x3F, 0x2F, 0x33, 0xEE,
1765 0x24, 0x42, 0x6E, 0xAC, 0x0B, 0xCA, 0xEC, 0xF9,
1766 0x84, 0xF8, 0x22, 0xAA, 0x60, 0xF0, 0x32, 0xA9,
1767 0x75, 0x75, 0x3B, 0xCB, 0x70, 0x21, 0x0A, 0x8D,
1768 0x0F, 0xE0, 0xC4, 0x78, 0x2B, 0xF8, 0x97, 0xE3,
1769 0xE4, 0x26, 0x4B, 0x29, 0xDA, 0x88, 0xCD, 0x46,
1770 0xEC, 0xAA, 0xF9, 0x7F, 0xF1, 0x15, 0xEA, 0xC3,
1771 0x87, 0xE6, 0x31, 0xF2, 0xCF, 0xDE, 0x4D, 0x80,
1772 0x70, 0x91, 0x7E, 0x0C, 0xF7, 0x26, 0x3A, 0x92,
1773 0x4F, 0x18, 0x83, 0xC0, 0x8F, 0x59, 0x01, 0xA5,
1774 0x88, 0xD1, 0xDB, 0x26, 0x71, 0x27, 0x16, 0xF5,
1775 0xEE, 0x10, 0x82, 0xAC, 0x68, 0x26, 0x9B, 0xE2,
1776 0x6D, 0xD8, 0x9A, 0x80, 0xDF, 0x04, 0x31, 0xD5,
1777 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1778 0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
1779 0x73, 0x02, 0x42, 0xC9, 0x23, 0x18, 0x8E, 0xB4,
1780 0x6F, 0xB4, 0xA3, 0x54, 0x6E, 0x88, 0x3B, 0x62,
1781 0x7C, 0x02, 0x8D, 0x4C, 0x9F, 0xC8, 0x45, 0xF4,
1782 0xC9, 0xDE, 0x4F, 0xEB, 0x22, 0x83, 0x1B, 0xE4,
1783 0x49, 0x37, 0xE4, 0xAD, 0xE7, 0xCD, 0x21, 0x54,
1784 0xBC, 0x1C, 0xC2, 0x04, 0x97, 0xB4, 0x10, 0x61,
1785 0xF0, 0xE4, 0xEF, 0x27, 0x63, 0x3A, 0xDA, 0x91,
1786 0x41, 0x25, 0x62, 0x1C, 0x5C, 0xB6, 0x38, 0x4A,
1787 0x88, 0x71, 0x59, 0x5A, 0x8D, 0xA0, 0x09, 0xAF,
1788 0x72, 0x94, 0xD7, 0x79, 0x5C, 0x60, 0x7C, 0x8F,
1789 0x4C, 0xF5, 0xD9, 0xA1, 0x39, 0x6D, 0x81, 0x28,
1790 0xEF, 0x13, 0x28, 0xDF, 0xF5, 0x3E, 0xF7, 0x8E,
1791 0x09, 0x9C, 0x78, 0x18, 0x79, 0xB8, 0x68, 0xD7,
1792 0xA8, 0x29, 0x62, 0xAD, 0xDE, 0xE1, 0x61, 0x76,
1793 0x1B, 0x05, 0x16, 0xCD, 0xBF, 0x02, 0x8E, 0xA6,
1794 0x43, 0x6E, 0x92, 0x55, 0x4F, 0x60, 0x9C, 0x03,
1795 0xB8, 0x4F, 0xA3, 0x02, 0xAC, 0xA8, 0xA7, 0x0C,
1796 0x1E, 0xB5, 0x6B, 0xF8, 0xC8, 0x4D, 0xDE, 0xD2,
1797 0xB0, 0x29, 0x6E, 0x40, 0xE6, 0xD6, 0xC9, 0xE6,
1798 0xB9, 0x0F, 0xB6, 0x63, 0xF5, 0xAA, 0x2B, 0x96,
1799 0xA7, 0x16, 0xAC, 0x4E, 0x0A, 0x33, 0x1C, 0xA6,
1800 0xE6, 0xBD, 0x8A, 0xCF, 0x40, 0xA9, 0xB2, 0xFA,
1801 0x63, 0x27, 0xFD, 0x9B, 0xD9, 0xFC, 0xD5, 0x87,
1802 0x8D, 0x4C, 0xB6, 0xA4, 0xCB, 0xE7, 0x74, 0x55,
1803 0xF4, 0xFB, 0x41, 0x25, 0xB5, 0x4B, 0x0A, 0x1B,
1804 0xB1, 0xD6, 0xB7, 0xD9, 0x47, 0x2A, 0xC3, 0x98,
1805 0x6A, 0xC4, 0x03, 0x73, 0x1F, 0x93, 0x6E, 0x53,
1806 0x19, 0x25, 0x64, 0x15, 0x83, 0xF9, 0x73, 0x2A,
1807 0x74, 0xB4, 0x93, 0x69, 0xC4, 0x72, 0xFC, 0x26,
1808 0xA2, 0x9F, 0x43, 0x45, 0xDD, 0xB9, 0xEF, 0x36,
1809 0xC8, 0x3A, 0xCD, 0x99, 0x9B, 0x54, 0x1A, 0x36,
1810 0xC1, 0x59, 0xF8, 0x98, 0xA8, 0xCC, 0x28, 0x0D,
1811 0x73, 0x4C, 0xEE, 0x98, 0xCB, 0x7C, 0x58, 0x7E,
1812 0x20, 0x75, 0x1E, 0xB7, 0xC9, 0xF8, 0xF2, 0x0E,
1813 0x63, 0x9E, 0x05, 0x78, 0x1A, 0xB6, 0xA8, 0x7A,
1814 0xF9, 0x98, 0x6A, 0xA6, 0x46, 0x84, 0x2E, 0xF6,
1815 0x4B, 0xDC, 0x9B, 0x8F, 0x9B, 0x8F, 0xEE, 0xB4,
1816 0xAA, 0x3F, 0xEE, 0xC0, 0x37, 0x27, 0x76, 0xC7,
1817 0x95, 0xBB, 0x26, 0x74, 0x69, 0x12, 0x7F, 0xF1,
1818 0xBB, 0xFF, 0xAE, 0xB5, 0x99, 0x6E, 0xCB, 0x0C
1821 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest[] = {
1822 0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60,
1823 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1824 0x18, 0x8c, 0x1d, 0x32
1828 /* Multisession Vector context Test */
1829 /*Begin Session 0 */
1830 static uint8_t ms_aes_cbc_key0[] = {
1831 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1832 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1835 static uint8_t ms_aes_cbc_iv0[] = {
1836 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1837 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1840 static const uint8_t ms_aes_cbc_cipher0[] = {
1841 0x3C, 0xE4, 0xEE, 0x42, 0xB6, 0x9B, 0xC3, 0x38,
1842 0x5F, 0xAD, 0x54, 0xDC, 0xA8, 0x32, 0x81, 0xDC,
1843 0x7A, 0x6F, 0x85, 0x58, 0x07, 0x35, 0xED, 0xEB,
1844 0xAD, 0x79, 0x79, 0x96, 0xD3, 0x0E, 0xA6, 0xD9,
1845 0xAA, 0x86, 0xA4, 0x8F, 0xB5, 0xD6, 0x6E, 0x6D,
1846 0x0C, 0x91, 0x2F, 0xC4, 0x67, 0x98, 0x0E, 0xC4,
1847 0x8D, 0x83, 0x68, 0x69, 0xC4, 0xD3, 0x94, 0x34,
1848 0xC4, 0x5D, 0x60, 0x55, 0x22, 0x87, 0x8F, 0x6F,
1849 0x17, 0x8E, 0x75, 0xE4, 0x02, 0xF5, 0x1B, 0x99,
1850 0xC8, 0x39, 0xA9, 0xAB, 0x23, 0x91, 0x12, 0xED,
1851 0x08, 0xE7, 0xD9, 0x25, 0x89, 0x24, 0x4F, 0x8D,
1852 0x68, 0xF3, 0x10, 0x39, 0x0A, 0xEE, 0x45, 0x24,
1853 0xDF, 0x7A, 0x9D, 0x00, 0x25, 0xE5, 0x35, 0x71,
1854 0x4E, 0x40, 0x59, 0x6F, 0x0A, 0x13, 0xB3, 0x72,
1855 0x1D, 0x98, 0x63, 0x94, 0x89, 0xA5, 0x39, 0x8E,
1856 0xD3, 0x9C, 0x8A, 0x7F, 0x71, 0x2F, 0xC7, 0xCD,
1857 0x81, 0x05, 0xDC, 0xC0, 0x8D, 0xCE, 0x6D, 0x18,
1858 0x30, 0xC4, 0x72, 0x51, 0xF0, 0x27, 0xC8, 0xF6,
1859 0x60, 0x5B, 0x7C, 0xB2, 0xE3, 0x49, 0x0C, 0x29,
1860 0xC6, 0x9F, 0x39, 0x57, 0x80, 0x55, 0x24, 0x2C,
1861 0x9B, 0x0F, 0x5A, 0xB3, 0x89, 0x55, 0x31, 0x96,
1862 0x0D, 0xCD, 0xF6, 0x51, 0x03, 0x2D, 0x89, 0x26,
1863 0x74, 0x44, 0xD6, 0xE8, 0xDC, 0xEA, 0x44, 0x55,
1864 0x64, 0x71, 0x9C, 0x9F, 0x5D, 0xBA, 0x39, 0x46,
1865 0xA8, 0x17, 0xA1, 0x9C, 0x52, 0x9D, 0xBC, 0x6B,
1866 0x4A, 0x98, 0xE6, 0xEA, 0x33, 0xEC, 0x58, 0xB4,
1867 0x43, 0xF0, 0x32, 0x45, 0xA4, 0xC1, 0x55, 0xB7,
1868 0x5D, 0xB5, 0x59, 0xB2, 0xE3, 0x96, 0xFF, 0xA5,
1869 0xAF, 0xE1, 0x86, 0x1B, 0x42, 0xE6, 0x3B, 0xA0,
1870 0x90, 0x4A, 0xE8, 0x8C, 0x21, 0x7F, 0x36, 0x1E,
1871 0x5B, 0x65, 0x25, 0xD1, 0xC1, 0x5A, 0xCA, 0x3D,
1872 0x10, 0xED, 0x2D, 0x79, 0xD0, 0x0F, 0x58, 0x44,
1873 0x69, 0x81, 0xF5, 0xD4, 0xC9, 0x0F, 0x90, 0x76,
1874 0x1F, 0x54, 0xD2, 0xD5, 0x97, 0xCE, 0x2C, 0xE3,
1875 0xEF, 0xF4, 0xB7, 0xC6, 0x3A, 0x87, 0x7F, 0x83,
1876 0x2A, 0xAF, 0xCD, 0x90, 0x12, 0xA7, 0x7D, 0x85,
1877 0x1D, 0x62, 0xD3, 0x85, 0x25, 0x05, 0xDB, 0x45,
1878 0x92, 0xA3, 0xF6, 0xA2, 0xA8, 0x41, 0xE4, 0x25,
1879 0x86, 0x87, 0x67, 0x24, 0xEC, 0x89, 0x23, 0x2A,
1880 0x9B, 0x20, 0x4D, 0x93, 0xEE, 0xE2, 0x2E, 0xC1,
1881 0x0B, 0x15, 0x33, 0xCF, 0x00, 0xD1, 0x1A, 0xDA,
1882 0x93, 0xFD, 0x28, 0x21, 0x5B, 0xCF, 0xD1, 0xF3,
1883 0x5A, 0x81, 0xBA, 0x82, 0x5E, 0x2F, 0x61, 0xB4,
1884 0x05, 0x71, 0xB5, 0xF4, 0x39, 0x3C, 0x1F, 0x60,
1885 0x00, 0x7A, 0xC4, 0xF8, 0x35, 0x20, 0x6C, 0x3A,
1886 0xCC, 0x03, 0x8F, 0x7B, 0xA2, 0xB6, 0x65, 0x8A,
1887 0xB6, 0x5F, 0xFD, 0x25, 0xD3, 0x5F, 0x92, 0xF9,
1888 0xAE, 0x17, 0x9B, 0x5E, 0x6E, 0x9A, 0xE4, 0x55,
1889 0x10, 0x25, 0x07, 0xA4, 0xAF, 0x21, 0x69, 0x13,
1890 0xD8, 0xFA, 0x31, 0xED, 0xF7, 0xA7, 0xA7, 0x3B,
1891 0xB8, 0x96, 0x8E, 0x10, 0x86, 0x74, 0xD8, 0xB1,
1892 0x34, 0x9E, 0x9B, 0x6A, 0x26, 0xA8, 0xD4, 0xD0,
1893 0xB5, 0xF6, 0xDE, 0xE7, 0xCA, 0x06, 0xDC, 0xA3,
1894 0x6F, 0xEE, 0x6B, 0x1E, 0xB5, 0x30, 0x99, 0x23,
1895 0xF9, 0x76, 0xF0, 0xA0, 0xCF, 0x3B, 0x94, 0x7B,
1896 0x19, 0x8D, 0xA5, 0x0C, 0x18, 0xA6, 0x1D, 0x07,
1897 0x89, 0xBE, 0x5B, 0x61, 0xE5, 0xF1, 0x42, 0xDB,
1898 0xD4, 0x2E, 0x02, 0x1F, 0xCE, 0xEF, 0x92, 0xB1,
1899 0x1B, 0x56, 0x50, 0xF2, 0x16, 0xE5, 0xE7, 0x4F,
1900 0xFD, 0xBB, 0x3E, 0xD2, 0xFC, 0x3C, 0xC6, 0x0F,
1901 0xF9, 0x12, 0x4E, 0xCB, 0x1E, 0x0C, 0x15, 0x84,
1902 0x2A, 0x14, 0x8A, 0x02, 0xE4, 0x7E, 0x95, 0x5B,
1903 0x86, 0xDB, 0x9B, 0x62, 0x5B, 0x19, 0xD2, 0x17,
1904 0xFA, 0x13, 0xBB, 0x6B, 0x3F, 0x45, 0x9F, 0xBF
1908 static uint8_t ms_hmac_key0[] = {
1909 0xFF, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1910 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1911 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1912 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1913 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1914 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1915 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1916 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1919 static const uint8_t ms_hmac_digest0[] = {
1920 0x43, 0x52, 0xED, 0x34, 0xAB, 0x36, 0xB2, 0x51,
1921 0xFB, 0xA3, 0xA6, 0x7C, 0x38, 0xFC, 0x42, 0x8F,
1922 0x57, 0x64, 0xAB, 0x81, 0xA7, 0x89, 0xB7, 0x6C,
1923 0xA0, 0xDC, 0xB9, 0x4D, 0xC4, 0x30, 0xF9, 0xD4,
1924 0x10, 0x82, 0x55, 0xD0, 0xAB, 0x32, 0xFB, 0x56,
1925 0x0D, 0xE4, 0x68, 0x3D, 0x76, 0xD0, 0x7B, 0xE4,
1926 0xA6, 0x2C, 0x34, 0x9E, 0x8C, 0x41, 0xF8, 0x23,
1927 0x28, 0x1B, 0x3A, 0x90, 0x26, 0x34, 0x47, 0x90
1931 /* Begin session 1 */
1933 static uint8_t ms_aes_cbc_key1[] = {
1934 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1935 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1938 static uint8_t ms_aes_cbc_iv1[] = {
1939 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1940 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1943 static const uint8_t ms_aes_cbc_cipher1[] = {
1944 0x5A, 0x7A, 0x67, 0x5D, 0xB8, 0xE1, 0xDC, 0x71,
1945 0x39, 0xA8, 0x74, 0x93, 0x9C, 0x4C, 0xFE, 0x23,
1946 0x61, 0xCD, 0xA4, 0xB3, 0xD9, 0xCE, 0x99, 0x09,
1947 0x2A, 0x23, 0xF3, 0x29, 0xBF, 0x4C, 0xB4, 0x6A,
1948 0x1B, 0x6B, 0x73, 0x4D, 0x48, 0x0C, 0xCF, 0x6C,
1949 0x5E, 0x34, 0x9E, 0x7F, 0xBC, 0x8F, 0xCC, 0x8F,
1950 0x75, 0x1D, 0x3D, 0x77, 0x10, 0x76, 0xC8, 0xB9,
1951 0x99, 0x6F, 0xD6, 0x56, 0x75, 0xA9, 0xB2, 0x66,
1952 0xC2, 0x24, 0x2B, 0x9C, 0xFE, 0x40, 0x8E, 0x43,
1953 0x20, 0x97, 0x1B, 0xFA, 0xD0, 0xCF, 0x04, 0xAB,
1954 0xBB, 0xF6, 0x5D, 0xF5, 0xA0, 0x19, 0x7C, 0x23,
1955 0x5D, 0x80, 0x8C, 0x49, 0xF6, 0x76, 0x88, 0x29,
1956 0x27, 0x4C, 0x59, 0x2B, 0x43, 0xA6, 0xB2, 0x26,
1957 0x27, 0x78, 0xBE, 0x1B, 0xE1, 0x4F, 0x5A, 0x1F,
1958 0xFC, 0x68, 0x08, 0xE7, 0xC4, 0xD1, 0x34, 0x68,
1959 0xB7, 0x13, 0x14, 0x41, 0x62, 0x6B, 0x1F, 0x77,
1960 0x0C, 0x68, 0x1D, 0x0D, 0xED, 0x89, 0xAA, 0xD8,
1961 0x97, 0x02, 0xBA, 0x5E, 0xD4, 0x84, 0x25, 0x97,
1962 0x03, 0xA5, 0xA6, 0x13, 0x66, 0x02, 0xF4, 0xC3,
1963 0xF3, 0xD3, 0xCC, 0x95, 0xC3, 0x87, 0x46, 0x90,
1964 0x1F, 0x6E, 0x14, 0xA8, 0x00, 0xF2, 0x6F, 0xD5,
1965 0xA1, 0xAD, 0xD5, 0x40, 0xA2, 0x0F, 0x32, 0x7E,
1966 0x99, 0xA3, 0xF5, 0x53, 0xC3, 0x26, 0xA1, 0x45,
1967 0x01, 0x88, 0x57, 0x84, 0x3E, 0x7B, 0x4E, 0x0B,
1968 0x3C, 0xB5, 0x3E, 0x9E, 0xE9, 0x78, 0x77, 0xC5,
1969 0xC0, 0x89, 0xA8, 0xF8, 0xF1, 0xA5, 0x2D, 0x5D,
1970 0xF9, 0xC6, 0xFB, 0xCB, 0x05, 0x23, 0xBD, 0x6E,
1971 0x5E, 0x14, 0xC6, 0x57, 0x73, 0xCF, 0x98, 0xBD,
1972 0x10, 0x8B, 0x18, 0xA6, 0x01, 0x5B, 0x13, 0xAE,
1973 0x8E, 0xDE, 0x1F, 0xB5, 0xB7, 0x40, 0x6C, 0xC1,
1974 0x1E, 0xA1, 0x19, 0x20, 0x9E, 0x95, 0xE0, 0x2F,
1975 0x1C, 0xF5, 0xD9, 0xD0, 0x2B, 0x1E, 0x82, 0x25,
1976 0x62, 0xB4, 0xEB, 0xA1, 0x1F, 0xCE, 0x44, 0xA1,
1977 0xCB, 0x92, 0x01, 0x6B, 0xE4, 0x26, 0x23, 0xE3,
1978 0xC5, 0x67, 0x35, 0x55, 0xDA, 0xE5, 0x27, 0xEE,
1979 0x8D, 0x12, 0x84, 0xB7, 0xBA, 0xA7, 0x1C, 0xD6,
1980 0x32, 0x3F, 0x67, 0xED, 0xFB, 0x5B, 0x8B, 0x52,
1981 0x46, 0x8C, 0xF9, 0x69, 0xCD, 0xAE, 0x79, 0xAA,
1982 0x37, 0x78, 0x49, 0xEB, 0xC6, 0x8E, 0x76, 0x63,
1983 0x84, 0xFF, 0x9D, 0x22, 0x99, 0x51, 0xB7, 0x5E,
1984 0x83, 0x4C, 0x8B, 0xDF, 0x5A, 0x07, 0xCC, 0xBA,
1985 0x42, 0xA5, 0x98, 0xB6, 0x47, 0x0E, 0x66, 0xEB,
1986 0x23, 0x0E, 0xBA, 0x44, 0xA8, 0xAA, 0x20, 0x71,
1987 0x79, 0x9C, 0x77, 0x5F, 0xF5, 0xFE, 0xEC, 0xEF,
1988 0xC6, 0x64, 0x3D, 0x84, 0xD0, 0x2B, 0xA7, 0x0A,
1989 0xC3, 0x72, 0x5B, 0x9C, 0xFA, 0xA8, 0x87, 0x95,
1990 0x94, 0x11, 0x38, 0xA7, 0x1E, 0x58, 0xE3, 0x73,
1991 0xC6, 0xC9, 0xD1, 0x7B, 0x92, 0xDB, 0x0F, 0x49,
1992 0x74, 0xC2, 0xA2, 0x0E, 0x35, 0x57, 0xAC, 0xDB,
1993 0x9A, 0x1C, 0xCF, 0x5A, 0x32, 0x3E, 0x26, 0x9B,
1994 0xEC, 0xB3, 0xEF, 0x9C, 0xFE, 0xBE, 0x52, 0xAC,
1995 0xB1, 0x29, 0xDD, 0xFD, 0x07, 0xE2, 0xEE, 0xED,
1996 0xE4, 0x46, 0x37, 0xFE, 0xD1, 0xDC, 0xCD, 0x02,
1997 0xF9, 0x31, 0xB0, 0xFB, 0x36, 0xB7, 0x34, 0xA4,
1998 0x76, 0xE8, 0x57, 0xBF, 0x99, 0x92, 0xC7, 0xAF,
1999 0x98, 0x10, 0xE2, 0x70, 0xCA, 0xC9, 0x2B, 0x82,
2000 0x06, 0x96, 0x88, 0x0D, 0xB3, 0xAC, 0x9E, 0x6D,
2001 0x43, 0xBC, 0x5B, 0x31, 0xCF, 0x65, 0x8D, 0xA6,
2002 0xC7, 0xFE, 0x73, 0xE1, 0x54, 0xF7, 0x10, 0xF9,
2003 0x86, 0xF7, 0xDF, 0xA1, 0xA1, 0xD8, 0xAE, 0x35,
2004 0xB3, 0x90, 0xDC, 0x6F, 0x43, 0x7A, 0x8B, 0xE0,
2005 0xFE, 0x8F, 0x33, 0x4D, 0x29, 0x6C, 0x45, 0x53,
2006 0x73, 0xDD, 0x21, 0x0B, 0x85, 0x30, 0xB5, 0xA5,
2007 0xF3, 0x5D, 0xEC, 0x79, 0x61, 0x9D, 0x9E, 0xB3
2011 static uint8_t ms_hmac_key1[] = {
2012 0xFE, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
2013 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
2014 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
2015 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
2016 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
2017 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
2018 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
2019 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
2022 static const uint8_t ms_hmac_digest1[] = {
2023 0xCE, 0x6E, 0x5F, 0x77, 0x96, 0x9A, 0xB1, 0x69,
2024 0x2D, 0x5E, 0xF3, 0x2F, 0x32, 0x10, 0xCB, 0x50,
2025 0x0E, 0x09, 0x56, 0x25, 0x07, 0x34, 0xC9, 0x20,
2026 0xEC, 0x13, 0x43, 0x23, 0x5C, 0x08, 0x8B, 0xCD,
2027 0xDC, 0x86, 0x8C, 0xEE, 0x0A, 0x95, 0x2E, 0xB9,
2028 0x8C, 0x7B, 0x02, 0x7A, 0xD4, 0xE1, 0x49, 0xB4,
2029 0x45, 0xB5, 0x52, 0x37, 0xC6, 0xFF, 0xFE, 0xAA,
2030 0x0A, 0x87, 0xB8, 0x51, 0xF9, 0x2A, 0x01, 0x8F
2033 /* Begin Session 2 */
2034 static uint8_t ms_aes_cbc_key2[] = {
2035 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
2036 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
2039 static uint8_t ms_aes_cbc_iv2[] = {
2040 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
2041 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
2044 static const uint8_t ms_aes_cbc_cipher2[] = {
2045 0xBB, 0x3C, 0x68, 0x25, 0xFD, 0xB6, 0xA2, 0x91,
2046 0x20, 0x56, 0xF6, 0x30, 0x35, 0xFC, 0x9E, 0x97,
2047 0xF2, 0x90, 0xFC, 0x7E, 0x3E, 0x0A, 0x75, 0xC8,
2048 0x4C, 0xF2, 0x2D, 0xAC, 0xD3, 0x93, 0xF0, 0xC5,
2049 0x14, 0x88, 0x8A, 0x23, 0xC2, 0x59, 0x9A, 0x98,
2050 0x4B, 0xD5, 0x2C, 0xDA, 0x43, 0xA9, 0x34, 0x69,
2051 0x7C, 0x6D, 0xDB, 0xDC, 0xCB, 0xC0, 0xA0, 0x09,
2052 0xA7, 0x86, 0x16, 0x4B, 0xBF, 0xA8, 0xB6, 0xCF,
2053 0x7F, 0x74, 0x1F, 0x22, 0xF0, 0xF6, 0xBB, 0x44,
2054 0x8B, 0x4C, 0x9E, 0x23, 0xF8, 0x9F, 0xFC, 0x5B,
2055 0x9E, 0x9C, 0x2A, 0x79, 0x30, 0x8F, 0xBF, 0xA9,
2056 0x68, 0xA1, 0x20, 0x71, 0x7C, 0x77, 0x22, 0x34,
2057 0x07, 0xCD, 0xC6, 0xF6, 0x50, 0x0A, 0x08, 0x99,
2058 0x17, 0x98, 0xE3, 0x93, 0x8A, 0xB0, 0xEE, 0xDF,
2059 0xC2, 0xBA, 0x3B, 0x44, 0x73, 0xDF, 0xDD, 0xDC,
2060 0x14, 0x4D, 0x3B, 0xBB, 0x5E, 0x58, 0xC1, 0x26,
2061 0xA7, 0xAE, 0x47, 0xF3, 0x24, 0x6D, 0x4F, 0xD3,
2062 0x6E, 0x3E, 0x33, 0xE6, 0x7F, 0xCA, 0x50, 0xAF,
2063 0x5D, 0x3D, 0xA0, 0xDD, 0xC9, 0xF3, 0x30, 0xD3,
2064 0x6E, 0x8B, 0x2E, 0x12, 0x24, 0x34, 0xF0, 0xD3,
2065 0xC7, 0x8D, 0x23, 0x29, 0xAA, 0x05, 0xE1, 0xFA,
2066 0x2E, 0xF6, 0x8D, 0x37, 0x86, 0xC0, 0x6D, 0x13,
2067 0x2D, 0x98, 0xF3, 0x52, 0x39, 0x22, 0xCE, 0x38,
2068 0xC2, 0x1A, 0x72, 0xED, 0xFB, 0xCC, 0xE4, 0x71,
2069 0x5A, 0x0C, 0x0D, 0x09, 0xF8, 0xE8, 0x1B, 0xBC,
2070 0x53, 0xC8, 0xD8, 0x8F, 0xE5, 0x98, 0x5A, 0xB1,
2071 0x06, 0xA6, 0x5B, 0xE6, 0xA2, 0x88, 0x21, 0x9E,
2072 0x36, 0xC0, 0x34, 0xF9, 0xFB, 0x3B, 0x0A, 0x22,
2073 0x00, 0x00, 0x39, 0x48, 0x8D, 0x23, 0x74, 0x62,
2074 0x72, 0x91, 0xE6, 0x36, 0xAA, 0x77, 0x9C, 0x72,
2075 0x9D, 0xA8, 0xC3, 0xA9, 0xD5, 0x44, 0x72, 0xA6,
2076 0xB9, 0x28, 0x8F, 0x64, 0x4C, 0x8A, 0x64, 0xE6,
2077 0x4E, 0xFA, 0xEF, 0x87, 0xDE, 0x7B, 0x22, 0x44,
2078 0xB0, 0xDF, 0x2E, 0x5F, 0x0B, 0xA5, 0xF2, 0x24,
2079 0x07, 0x5C, 0x2D, 0x39, 0xB7, 0x3D, 0x8A, 0xE5,
2080 0x0E, 0x9D, 0x4E, 0x50, 0xED, 0x03, 0x99, 0x8E,
2081 0xF0, 0x06, 0x55, 0x4E, 0xA2, 0x24, 0xE7, 0x17,
2082 0x46, 0xDF, 0x6C, 0xCD, 0xC6, 0x44, 0xE8, 0xF9,
2083 0xB9, 0x1B, 0x36, 0xF6, 0x7F, 0x10, 0xA4, 0x7D,
2084 0x90, 0xBD, 0xE4, 0xAA, 0xD6, 0x9E, 0x18, 0x9D,
2085 0x22, 0x35, 0xD6, 0x55, 0x54, 0xAA, 0xF7, 0x22,
2086 0xA3, 0x3E, 0xEF, 0xC8, 0xA2, 0x34, 0x8D, 0xA9,
2087 0x37, 0x63, 0xA6, 0xC3, 0x57, 0xCB, 0x0C, 0x49,
2088 0x7D, 0x02, 0xBE, 0xAA, 0x13, 0x75, 0xB7, 0x4E,
2089 0x52, 0x62, 0xA5, 0xC2, 0x33, 0xC7, 0x6C, 0x1B,
2090 0xF6, 0x34, 0xF6, 0x09, 0xA5, 0x0C, 0xC7, 0xA2,
2091 0x61, 0x48, 0x62, 0x7D, 0x17, 0x15, 0xE3, 0x95,
2092 0xC8, 0x63, 0xD2, 0xA4, 0x43, 0xA9, 0x49, 0x07,
2093 0xB2, 0x3B, 0x2B, 0x62, 0x7D, 0xCB, 0x51, 0xB3,
2094 0x25, 0x33, 0x47, 0x0E, 0x14, 0x67, 0xDC, 0x6A,
2095 0x9B, 0x51, 0xAC, 0x9D, 0x8F, 0xA2, 0x2B, 0x57,
2096 0x8C, 0x5C, 0x5F, 0x76, 0x23, 0x92, 0x0F, 0x84,
2097 0x46, 0x0E, 0x40, 0x85, 0x38, 0x60, 0xFA, 0x61,
2098 0x20, 0xC5, 0xE3, 0xF1, 0x70, 0xAC, 0x1B, 0xBF,
2099 0xC4, 0x2B, 0xC5, 0x67, 0xD1, 0x43, 0xC5, 0x17,
2100 0x74, 0x71, 0x69, 0x6F, 0x82, 0x89, 0x19, 0x8A,
2101 0x70, 0x43, 0x92, 0x01, 0xC4, 0x63, 0x7E, 0xB1,
2102 0x59, 0x4E, 0xCD, 0xEA, 0x93, 0xA4, 0x52, 0x53,
2103 0x9B, 0x61, 0x5B, 0xD2, 0x3E, 0x19, 0x39, 0xB7,
2104 0x32, 0xEA, 0x8E, 0xF8, 0x1D, 0x76, 0x5C, 0xB2,
2105 0x73, 0x2D, 0x91, 0xC0, 0x18, 0xED, 0x25, 0x2A,
2106 0x53, 0x64, 0xF0, 0x92, 0x31, 0x55, 0x21, 0xA8,
2107 0x24, 0xA9, 0xD1, 0x02, 0xF6, 0x6C, 0x2B, 0x70,
2108 0xA9, 0x59, 0xC1, 0xD6, 0xC3, 0x57, 0x5B, 0x92
2111 static uint8_t ms_hmac_key2[] = {
2112 0xFC, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
2113 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
2114 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
2115 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
2116 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
2117 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
2118 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
2119 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
2122 static const uint8_t ms_hmac_digest2[] = {
2123 0xA5, 0x0F, 0x9C, 0xFB, 0x08, 0x62, 0x59, 0xFF,
2124 0x80, 0x2F, 0xEB, 0x4B, 0xE1, 0x46, 0x21, 0xD6,
2125 0x02, 0x98, 0xF2, 0x8E, 0xF4, 0xEC, 0xD4, 0x77,
2126 0x86, 0x4C, 0x31, 0x28, 0xC8, 0x25, 0x80, 0x27,
2127 0x3A, 0x72, 0x5D, 0x6A, 0x56, 0x8A, 0xD3, 0x82,
2128 0xB0, 0xEC, 0x31, 0x6D, 0x8B, 0x6B, 0xB4, 0x24,
2129 0xE7, 0x62, 0xC1, 0x52, 0xBC, 0x14, 0x1B, 0x8E,
2130 0xEC, 0x9A, 0xF1, 0x47, 0x80, 0xD2, 0xB0, 0x59
2137 test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
2139 struct crypto_testsuite_params *ts_params = &testsuite_params;
2140 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);
2188 /* Create crypto session*/
2189 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
2190 ut_params->sess, &ut_params->cipher_xform,
2191 ts_params->session_priv_mpool);
2192 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2194 /* Generate crypto op data structure */
2195 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2196 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2197 TEST_ASSERT_NOT_NULL(ut_params->op,
2198 "Failed to allocate symmetric crypto operation struct");
2200 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2202 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2204 /* set crypto operation source mbuf */
2205 sym_op->m_src = ut_params->ibuf;
2207 /* Set crypto operation authentication parameters */
2208 sym_op->auth.digest.data = ut_params->digest;
2209 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2210 ut_params->ibuf, QUOTE_512_BYTES);
2212 sym_op->auth.data.offset = 0;
2213 sym_op->auth.data.length = QUOTE_512_BYTES;
2215 /* Copy IV at the end of the crypto operation */
2216 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2217 aes_cbc_iv, CIPHER_IV_LENGTH_AES_CBC);
2219 /* Set crypto operation cipher parameters */
2220 sym_op->cipher.data.offset = 0;
2221 sym_op->cipher.data.length = QUOTE_512_BYTES;
2223 /* Process crypto operation */
2224 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2225 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
2228 TEST_ASSERT_NOT_NULL(
2229 process_crypto_request(ts_params->valid_devs[0],
2231 "failed to process sym crypto op");
2233 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2234 "crypto op processing failed");
2237 uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
2240 TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext,
2241 catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
2243 "ciphertext data not as expected");
2245 uint8_t *digest = ciphertext + QUOTE_512_BYTES;
2247 TEST_ASSERT_BUFFERS_ARE_EQUAL(digest,
2248 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
2249 gbl_driver_id == rte_cryptodev_driver_id_get(
2250 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) ?
2251 TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
2252 DIGEST_BYTE_LENGTH_SHA1,
2253 "Generated digest data not as expected");
2255 return TEST_SUCCESS;
2258 /* ***** AES-CBC / HMAC-SHA512 Hash Tests ***** */
2260 #define HMAC_KEY_LENGTH_SHA512 (DIGEST_BYTE_LENGTH_SHA512)
2262 static uint8_t hmac_sha512_key[] = {
2263 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
2264 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
2265 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
2266 0x9a, 0xaf, 0x88, 0x1b, 0xb6, 0x8f, 0xf8, 0x60,
2267 0xa2, 0x5a, 0x7f, 0x3f, 0xf4, 0x72, 0x70, 0xf1,
2268 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
2269 0x47, 0x3a, 0x75, 0x61, 0x5C, 0xa2, 0x10, 0x76,
2270 0x9a, 0xaf, 0x77, 0x5b, 0xb6, 0x7f, 0xf7, 0x60 };
2272 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest[] = {
2273 0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8,
2274 0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48,
2275 0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8,
2276 0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70,
2277 0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8,
2278 0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E,
2279 0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D,
2280 0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A };
2285 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
2286 struct crypto_unittest_params *ut_params,
2287 uint8_t *cipher_key,
2291 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
2292 struct crypto_unittest_params *ut_params,
2293 struct crypto_testsuite_params *ts_params,
2294 const uint8_t *cipher,
2295 const uint8_t *digest,
2300 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
2301 struct crypto_unittest_params *ut_params,
2302 uint8_t *cipher_key,
2306 /* Setup Cipher Parameters */
2307 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2308 ut_params->cipher_xform.next = NULL;
2310 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
2311 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
2312 ut_params->cipher_xform.cipher.key.data = cipher_key;
2313 ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
2314 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2315 ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
2317 /* Setup HMAC Parameters */
2318 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2319 ut_params->auth_xform.next = &ut_params->cipher_xform;
2321 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
2322 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC;
2323 ut_params->auth_xform.auth.key.data = hmac_key;
2324 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512;
2325 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512;
2327 return TEST_SUCCESS;
2332 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
2333 struct crypto_unittest_params *ut_params,
2334 struct crypto_testsuite_params *ts_params,
2335 const uint8_t *cipher,
2336 const uint8_t *digest,
2339 /* Generate test mbuf data and digest */
2340 ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
2343 QUOTE_512_BYTES, 0);
2345 ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2346 DIGEST_BYTE_LENGTH_SHA512);
2347 TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
2349 rte_memcpy(ut_params->digest,
2351 DIGEST_BYTE_LENGTH_SHA512);
2353 /* Generate Crypto op data structure */
2354 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2355 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2356 TEST_ASSERT_NOT_NULL(ut_params->op,
2357 "Failed to allocate symmetric crypto operation struct");
2359 rte_crypto_op_attach_sym_session(ut_params->op, sess);
2361 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2363 /* set crypto operation source mbuf */
2364 sym_op->m_src = ut_params->ibuf;
2366 sym_op->auth.digest.data = ut_params->digest;
2367 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2368 ut_params->ibuf, QUOTE_512_BYTES);
2370 sym_op->auth.data.offset = 0;
2371 sym_op->auth.data.length = QUOTE_512_BYTES;
2373 /* Copy IV at the end of the crypto operation */
2374 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2375 iv, CIPHER_IV_LENGTH_AES_CBC);
2377 sym_op->cipher.data.offset = 0;
2378 sym_op->cipher.data.length = QUOTE_512_BYTES;
2380 /* Process crypto operation */
2381 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2382 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
2384 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
2385 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
2386 ut_params->op, 1, 1, 0, 0);
2388 TEST_ASSERT_NOT_NULL(
2389 process_crypto_request(ts_params->valid_devs[0],
2391 "failed to process sym crypto op");
2393 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2394 "crypto op processing failed");
2396 ut_params->obuf = ut_params->op->sym->m_src;
2399 TEST_ASSERT_BUFFERS_ARE_EQUAL(
2400 rte_pktmbuf_mtod(ut_params->obuf, uint8_t *),
2403 "Plaintext data not as expected");
2406 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2407 "Digest verification failed");
2409 return TEST_SUCCESS;
2412 /* ***** SNOW 3G Tests ***** */
2414 create_wireless_algo_hash_session(uint8_t dev_id,
2415 const uint8_t *key, const uint8_t key_len,
2416 const uint8_t iv_len, const uint8_t auth_len,
2417 enum rte_crypto_auth_operation op,
2418 enum rte_crypto_auth_algorithm algo)
2420 uint8_t hash_key[key_len];
2423 struct crypto_testsuite_params *ts_params = &testsuite_params;
2424 struct crypto_unittest_params *ut_params = &unittest_params;
2426 memcpy(hash_key, key, key_len);
2428 debug_hexdump(stdout, "key:", key, key_len);
2430 /* Setup Authentication Parameters */
2431 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2432 ut_params->auth_xform.next = NULL;
2434 ut_params->auth_xform.auth.op = op;
2435 ut_params->auth_xform.auth.algo = algo;
2436 ut_params->auth_xform.auth.key.length = key_len;
2437 ut_params->auth_xform.auth.key.data = hash_key;
2438 ut_params->auth_xform.auth.digest_length = auth_len;
2439 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
2440 ut_params->auth_xform.auth.iv.length = iv_len;
2441 ut_params->sess = rte_cryptodev_sym_session_create(
2442 ts_params->session_mpool);
2444 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2445 &ut_params->auth_xform,
2446 ts_params->session_priv_mpool);
2447 if (status == -ENOTSUP)
2448 return TEST_SKIPPED;
2450 TEST_ASSERT_EQUAL(status, 0, "session init failed");
2451 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2456 create_wireless_algo_cipher_session(uint8_t dev_id,
2457 enum rte_crypto_cipher_operation op,
2458 enum rte_crypto_cipher_algorithm algo,
2459 const uint8_t *key, const uint8_t key_len,
2462 uint8_t cipher_key[key_len];
2464 struct crypto_testsuite_params *ts_params = &testsuite_params;
2465 struct crypto_unittest_params *ut_params = &unittest_params;
2467 memcpy(cipher_key, key, key_len);
2469 /* Setup Cipher Parameters */
2470 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2471 ut_params->cipher_xform.next = NULL;
2473 ut_params->cipher_xform.cipher.algo = algo;
2474 ut_params->cipher_xform.cipher.op = op;
2475 ut_params->cipher_xform.cipher.key.data = cipher_key;
2476 ut_params->cipher_xform.cipher.key.length = key_len;
2477 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2478 ut_params->cipher_xform.cipher.iv.length = iv_len;
2480 debug_hexdump(stdout, "key:", key, key_len);
2482 /* Create Crypto session */
2483 ut_params->sess = rte_cryptodev_sym_session_create(
2484 ts_params->session_mpool);
2486 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2487 &ut_params->cipher_xform,
2488 ts_params->session_priv_mpool);
2489 if (status == -ENOTSUP)
2490 return TEST_SKIPPED;
2492 TEST_ASSERT_EQUAL(status, 0, "session init failed");
2493 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2498 create_wireless_algo_cipher_operation(const uint8_t *iv, uint8_t iv_len,
2499 unsigned int cipher_len,
2500 unsigned int cipher_offset)
2502 struct crypto_testsuite_params *ts_params = &testsuite_params;
2503 struct crypto_unittest_params *ut_params = &unittest_params;
2505 /* Generate Crypto op data structure */
2506 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2507 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2508 TEST_ASSERT_NOT_NULL(ut_params->op,
2509 "Failed to allocate pktmbuf offload");
2511 /* Set crypto operation data parameters */
2512 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2514 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2516 /* set crypto operation source mbuf */
2517 sym_op->m_src = ut_params->ibuf;
2520 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2522 sym_op->cipher.data.length = cipher_len;
2523 sym_op->cipher.data.offset = cipher_offset;
2528 create_wireless_algo_cipher_operation_oop(const uint8_t *iv, uint8_t iv_len,
2529 unsigned int cipher_len,
2530 unsigned int cipher_offset)
2532 struct crypto_testsuite_params *ts_params = &testsuite_params;
2533 struct crypto_unittest_params *ut_params = &unittest_params;
2535 /* Generate Crypto op data structure */
2536 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2537 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2538 TEST_ASSERT_NOT_NULL(ut_params->op,
2539 "Failed to allocate pktmbuf offload");
2541 /* Set crypto operation data parameters */
2542 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2544 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2546 /* set crypto operation source mbuf */
2547 sym_op->m_src = ut_params->ibuf;
2548 sym_op->m_dst = ut_params->obuf;
2551 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2553 sym_op->cipher.data.length = cipher_len;
2554 sym_op->cipher.data.offset = cipher_offset;
2559 create_wireless_algo_cipher_auth_session(uint8_t dev_id,
2560 enum rte_crypto_cipher_operation cipher_op,
2561 enum rte_crypto_auth_operation auth_op,
2562 enum rte_crypto_auth_algorithm auth_algo,
2563 enum rte_crypto_cipher_algorithm cipher_algo,
2564 const uint8_t *key, uint8_t key_len,
2565 uint8_t auth_iv_len, uint8_t auth_len,
2566 uint8_t cipher_iv_len)
2569 uint8_t cipher_auth_key[key_len];
2572 struct crypto_testsuite_params *ts_params = &testsuite_params;
2573 struct crypto_unittest_params *ut_params = &unittest_params;
2575 memcpy(cipher_auth_key, key, key_len);
2577 /* Setup Authentication Parameters */
2578 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2579 ut_params->auth_xform.next = NULL;
2581 ut_params->auth_xform.auth.op = auth_op;
2582 ut_params->auth_xform.auth.algo = auth_algo;
2583 ut_params->auth_xform.auth.key.length = key_len;
2584 /* Hash key = cipher key */
2585 ut_params->auth_xform.auth.key.data = cipher_auth_key;
2586 ut_params->auth_xform.auth.digest_length = auth_len;
2587 /* Auth IV will be after cipher IV */
2588 ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2589 ut_params->auth_xform.auth.iv.length = auth_iv_len;
2591 /* Setup Cipher Parameters */
2592 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2593 ut_params->cipher_xform.next = &ut_params->auth_xform;
2595 ut_params->cipher_xform.cipher.algo = cipher_algo;
2596 ut_params->cipher_xform.cipher.op = cipher_op;
2597 ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2598 ut_params->cipher_xform.cipher.key.length = key_len;
2599 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2600 ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2602 debug_hexdump(stdout, "key:", key, key_len);
2604 /* Create Crypto session*/
2605 ut_params->sess = rte_cryptodev_sym_session_create(
2606 ts_params->session_mpool);
2607 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2609 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2610 &ut_params->cipher_xform,
2611 ts_params->session_priv_mpool);
2612 if (status == -ENOTSUP)
2613 return TEST_SKIPPED;
2615 TEST_ASSERT_EQUAL(status, 0, "session init failed");
2620 create_wireless_cipher_auth_session(uint8_t dev_id,
2621 enum rte_crypto_cipher_operation cipher_op,
2622 enum rte_crypto_auth_operation auth_op,
2623 enum rte_crypto_auth_algorithm auth_algo,
2624 enum rte_crypto_cipher_algorithm cipher_algo,
2625 const struct wireless_test_data *tdata)
2627 const uint8_t key_len = tdata->key.len;
2628 uint8_t cipher_auth_key[key_len];
2631 struct crypto_testsuite_params *ts_params = &testsuite_params;
2632 struct crypto_unittest_params *ut_params = &unittest_params;
2633 const uint8_t *key = tdata->key.data;
2634 const uint8_t auth_len = tdata->digest.len;
2635 uint8_t cipher_iv_len = tdata->cipher_iv.len;
2636 uint8_t auth_iv_len = tdata->auth_iv.len;
2638 memcpy(cipher_auth_key, key, key_len);
2640 /* Setup Authentication Parameters */
2641 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2642 ut_params->auth_xform.next = NULL;
2644 ut_params->auth_xform.auth.op = auth_op;
2645 ut_params->auth_xform.auth.algo = auth_algo;
2646 ut_params->auth_xform.auth.key.length = key_len;
2647 /* Hash key = cipher key */
2648 ut_params->auth_xform.auth.key.data = cipher_auth_key;
2649 ut_params->auth_xform.auth.digest_length = auth_len;
2650 /* Auth IV will be after cipher IV */
2651 ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2652 ut_params->auth_xform.auth.iv.length = auth_iv_len;
2654 /* Setup Cipher Parameters */
2655 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2656 ut_params->cipher_xform.next = &ut_params->auth_xform;
2658 ut_params->cipher_xform.cipher.algo = cipher_algo;
2659 ut_params->cipher_xform.cipher.op = cipher_op;
2660 ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2661 ut_params->cipher_xform.cipher.key.length = key_len;
2662 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2663 ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2666 debug_hexdump(stdout, "key:", key, key_len);
2668 /* Create Crypto session*/
2669 ut_params->sess = rte_cryptodev_sym_session_create(
2670 ts_params->session_mpool);
2672 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2673 &ut_params->cipher_xform,
2674 ts_params->session_priv_mpool);
2675 if (status == -ENOTSUP)
2676 return TEST_SKIPPED;
2678 TEST_ASSERT_EQUAL(status, 0, "session init failed");
2679 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2684 create_zuc_cipher_auth_encrypt_generate_session(uint8_t dev_id,
2685 const struct wireless_test_data *tdata)
2687 return create_wireless_cipher_auth_session(dev_id,
2688 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2689 RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_ZUC_EIA3,
2690 RTE_CRYPTO_CIPHER_ZUC_EEA3, tdata);
2694 create_wireless_algo_auth_cipher_session(uint8_t dev_id,
2695 enum rte_crypto_cipher_operation cipher_op,
2696 enum rte_crypto_auth_operation auth_op,
2697 enum rte_crypto_auth_algorithm auth_algo,
2698 enum rte_crypto_cipher_algorithm cipher_algo,
2699 const uint8_t *key, const uint8_t key_len,
2700 uint8_t auth_iv_len, uint8_t auth_len,
2701 uint8_t cipher_iv_len)
2703 uint8_t auth_cipher_key[key_len];
2705 struct crypto_testsuite_params *ts_params = &testsuite_params;
2706 struct crypto_unittest_params *ut_params = &unittest_params;
2708 memcpy(auth_cipher_key, key, key_len);
2710 /* Setup Authentication Parameters */
2711 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2712 ut_params->auth_xform.auth.op = auth_op;
2713 ut_params->auth_xform.next = &ut_params->cipher_xform;
2714 ut_params->auth_xform.auth.algo = auth_algo;
2715 ut_params->auth_xform.auth.key.length = key_len;
2716 ut_params->auth_xform.auth.key.data = auth_cipher_key;
2717 ut_params->auth_xform.auth.digest_length = auth_len;
2718 /* Auth IV will be after cipher IV */
2719 ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2720 ut_params->auth_xform.auth.iv.length = auth_iv_len;
2722 /* Setup Cipher Parameters */
2723 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2724 ut_params->cipher_xform.next = NULL;
2725 ut_params->cipher_xform.cipher.algo = cipher_algo;
2726 ut_params->cipher_xform.cipher.op = cipher_op;
2727 ut_params->cipher_xform.cipher.key.data = auth_cipher_key;
2728 ut_params->cipher_xform.cipher.key.length = key_len;
2729 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2730 ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2732 debug_hexdump(stdout, "key:", key, key_len);
2734 /* Create Crypto session*/
2735 ut_params->sess = rte_cryptodev_sym_session_create(
2736 ts_params->session_mpool);
2737 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2739 if (cipher_op == RTE_CRYPTO_CIPHER_OP_DECRYPT) {
2740 ut_params->auth_xform.next = NULL;
2741 ut_params->cipher_xform.next = &ut_params->auth_xform;
2742 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2743 &ut_params->cipher_xform,
2744 ts_params->session_priv_mpool);
2747 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2748 &ut_params->auth_xform,
2749 ts_params->session_priv_mpool);
2751 if (status == -ENOTSUP)
2752 return TEST_SKIPPED;
2754 TEST_ASSERT_EQUAL(status, 0, "session init failed");
2760 create_wireless_algo_hash_operation(const uint8_t *auth_tag,
2761 unsigned int auth_tag_len,
2762 const uint8_t *iv, unsigned int iv_len,
2763 unsigned int data_pad_len,
2764 enum rte_crypto_auth_operation op,
2765 unsigned int auth_len, unsigned int auth_offset)
2767 struct crypto_testsuite_params *ts_params = &testsuite_params;
2769 struct crypto_unittest_params *ut_params = &unittest_params;
2771 /* Generate Crypto op data structure */
2772 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2773 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2774 TEST_ASSERT_NOT_NULL(ut_params->op,
2775 "Failed to allocate pktmbuf offload");
2777 /* Set crypto operation data parameters */
2778 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2780 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2782 /* set crypto operation source mbuf */
2783 sym_op->m_src = ut_params->ibuf;
2786 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2789 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2790 ut_params->ibuf, auth_tag_len);
2792 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2793 "no room to append auth tag");
2794 ut_params->digest = sym_op->auth.digest.data;
2795 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2796 ut_params->ibuf, data_pad_len);
2797 if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2798 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2800 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2802 debug_hexdump(stdout, "digest:",
2803 sym_op->auth.digest.data,
2806 sym_op->auth.data.length = auth_len;
2807 sym_op->auth.data.offset = auth_offset;
2813 create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata,
2814 enum rte_crypto_auth_operation op)
2816 struct crypto_testsuite_params *ts_params = &testsuite_params;
2817 struct crypto_unittest_params *ut_params = &unittest_params;
2819 const uint8_t *auth_tag = tdata->digest.data;
2820 const unsigned int auth_tag_len = tdata->digest.len;
2821 unsigned int plaintext_len = ceil_byte_length(tdata->plaintext.len);
2822 unsigned int data_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2824 const uint8_t *cipher_iv = tdata->cipher_iv.data;
2825 const uint8_t cipher_iv_len = tdata->cipher_iv.len;
2826 const uint8_t *auth_iv = tdata->auth_iv.data;
2827 const uint8_t auth_iv_len = tdata->auth_iv.len;
2828 const unsigned int cipher_len = tdata->validCipherLenInBits.len;
2829 const unsigned int auth_len = tdata->validAuthLenInBits.len;
2831 /* Generate Crypto op data structure */
2832 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2833 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2834 TEST_ASSERT_NOT_NULL(ut_params->op,
2835 "Failed to allocate pktmbuf offload");
2836 /* Set crypto operation data parameters */
2837 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2839 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2841 /* set crypto operation source mbuf */
2842 sym_op->m_src = ut_params->ibuf;
2845 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2846 ut_params->ibuf, auth_tag_len);
2848 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2849 "no room to append auth tag");
2850 ut_params->digest = sym_op->auth.digest.data;
2851 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2852 ut_params->ibuf, data_pad_len);
2853 if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2854 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2856 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2858 debug_hexdump(stdout, "digest:",
2859 sym_op->auth.digest.data,
2862 /* Copy cipher and auth IVs at the end of the crypto operation */
2863 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2865 rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2866 iv_ptr += cipher_iv_len;
2867 rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2869 sym_op->cipher.data.length = cipher_len;
2870 sym_op->cipher.data.offset = 0;
2871 sym_op->auth.data.length = auth_len;
2872 sym_op->auth.data.offset = 0;
2878 create_zuc_cipher_hash_generate_operation(
2879 const struct wireless_test_data *tdata)
2881 return create_wireless_cipher_hash_operation(tdata,
2882 RTE_CRYPTO_AUTH_OP_GENERATE);
2886 create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
2887 const unsigned auth_tag_len,
2888 const uint8_t *auth_iv, uint8_t auth_iv_len,
2889 unsigned data_pad_len,
2890 enum rte_crypto_auth_operation op,
2891 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2892 const unsigned cipher_len, const unsigned cipher_offset,
2893 const unsigned auth_len, const unsigned auth_offset)
2895 struct crypto_testsuite_params *ts_params = &testsuite_params;
2896 struct crypto_unittest_params *ut_params = &unittest_params;
2898 enum rte_crypto_cipher_algorithm cipher_algo =
2899 ut_params->cipher_xform.cipher.algo;
2900 enum rte_crypto_auth_algorithm auth_algo =
2901 ut_params->auth_xform.auth.algo;
2903 /* Generate Crypto op data structure */
2904 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2905 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2906 TEST_ASSERT_NOT_NULL(ut_params->op,
2907 "Failed to allocate pktmbuf offload");
2908 /* Set crypto operation data parameters */
2909 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2911 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2913 /* set crypto operation source mbuf */
2914 sym_op->m_src = ut_params->ibuf;
2917 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2918 ut_params->ibuf, auth_tag_len);
2920 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2921 "no room to append auth tag");
2922 ut_params->digest = sym_op->auth.digest.data;
2924 if (rte_pktmbuf_is_contiguous(ut_params->ibuf)) {
2925 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2926 ut_params->ibuf, data_pad_len);
2928 struct rte_mbuf *m = ut_params->ibuf;
2929 unsigned int offset = data_pad_len;
2931 while (offset > m->data_len && m->next != NULL) {
2932 offset -= m->data_len;
2935 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2939 if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2940 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2942 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2944 debug_hexdump(stdout, "digest:",
2945 sym_op->auth.digest.data,
2948 /* Copy cipher and auth IVs at the end of the crypto operation */
2949 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2951 rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2952 iv_ptr += cipher_iv_len;
2953 rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2955 if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
2956 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
2957 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
2958 sym_op->cipher.data.length = cipher_len;
2959 sym_op->cipher.data.offset = cipher_offset;
2961 sym_op->cipher.data.length = cipher_len >> 3;
2962 sym_op->cipher.data.offset = cipher_offset >> 3;
2965 if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
2966 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
2967 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
2968 sym_op->auth.data.length = auth_len;
2969 sym_op->auth.data.offset = auth_offset;
2971 sym_op->auth.data.length = auth_len >> 3;
2972 sym_op->auth.data.offset = auth_offset >> 3;
2979 create_wireless_algo_auth_cipher_operation(
2980 const uint8_t *auth_tag, unsigned int auth_tag_len,
2981 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2982 const uint8_t *auth_iv, uint8_t auth_iv_len,
2983 unsigned int data_pad_len,
2984 unsigned int cipher_len, unsigned int cipher_offset,
2985 unsigned int auth_len, unsigned int auth_offset,
2986 uint8_t op_mode, uint8_t do_sgl, uint8_t verify)
2988 struct crypto_testsuite_params *ts_params = &testsuite_params;
2989 struct crypto_unittest_params *ut_params = &unittest_params;
2991 enum rte_crypto_cipher_algorithm cipher_algo =
2992 ut_params->cipher_xform.cipher.algo;
2993 enum rte_crypto_auth_algorithm auth_algo =
2994 ut_params->auth_xform.auth.algo;
2996 /* Generate Crypto op data structure */
2997 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2998 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2999 TEST_ASSERT_NOT_NULL(ut_params->op,
3000 "Failed to allocate pktmbuf offload");
3002 /* Set crypto operation data parameters */
3003 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
3005 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
3007 /* set crypto operation mbufs */
3008 sym_op->m_src = ut_params->ibuf;
3009 if (op_mode == OUT_OF_PLACE)
3010 sym_op->m_dst = ut_params->obuf;
3014 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(
3015 (op_mode == IN_PLACE ?
3016 ut_params->ibuf : ut_params->obuf),
3017 uint8_t *, data_pad_len);
3018 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
3019 (op_mode == IN_PLACE ?
3020 ut_params->ibuf : ut_params->obuf),
3022 memset(sym_op->auth.digest.data, 0, auth_tag_len);
3024 uint16_t remaining_off = (auth_offset >> 3) + (auth_len >> 3);
3025 struct rte_mbuf *sgl_buf = (op_mode == IN_PLACE ?
3026 sym_op->m_src : sym_op->m_dst);
3027 while (remaining_off >= rte_pktmbuf_data_len(sgl_buf)) {
3028 remaining_off -= rte_pktmbuf_data_len(sgl_buf);
3029 sgl_buf = sgl_buf->next;
3031 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(sgl_buf,
3032 uint8_t *, remaining_off);
3033 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(sgl_buf,
3035 memset(sym_op->auth.digest.data, 0, remaining_off);
3036 while (sgl_buf->next != NULL) {
3037 memset(rte_pktmbuf_mtod(sgl_buf, uint8_t *),
3038 0, rte_pktmbuf_data_len(sgl_buf));
3039 sgl_buf = sgl_buf->next;
3043 /* Copy digest for the verification */
3045 memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
3047 /* Copy cipher and auth IVs at the end of the crypto operation */
3048 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(
3049 ut_params->op, uint8_t *, IV_OFFSET);
3051 rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
3052 iv_ptr += cipher_iv_len;
3053 rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
3055 /* Only copy over the offset data needed from src to dst in OOP,
3056 * if the auth and cipher offsets are not aligned
3058 if (op_mode == OUT_OF_PLACE) {
3059 if (cipher_offset > auth_offset)
3061 rte_pktmbuf_mtod_offset(
3063 uint8_t *, auth_offset >> 3),
3064 rte_pktmbuf_mtod_offset(
3066 uint8_t *, auth_offset >> 3),
3067 ((cipher_offset >> 3) - (auth_offset >> 3)));
3070 if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
3071 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
3072 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
3073 sym_op->cipher.data.length = cipher_len;
3074 sym_op->cipher.data.offset = cipher_offset;
3076 sym_op->cipher.data.length = cipher_len >> 3;
3077 sym_op->cipher.data.offset = cipher_offset >> 3;
3080 if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
3081 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
3082 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
3083 sym_op->auth.data.length = auth_len;
3084 sym_op->auth.data.offset = auth_offset;
3086 sym_op->auth.data.length = auth_len >> 3;
3087 sym_op->auth.data.offset = auth_offset >> 3;
3094 test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
3096 struct crypto_testsuite_params *ts_params = &testsuite_params;
3097 struct crypto_unittest_params *ut_params = &unittest_params;
3100 unsigned plaintext_pad_len;
3101 unsigned plaintext_len;
3103 struct rte_cryptodev_info dev_info;
3105 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3106 uint64_t feat_flags = dev_info.feature_flags;
3108 if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
3109 ((tdata->validAuthLenInBits.len % 8) != 0)) {
3110 printf("Device doesn't support NON-Byte Aligned Data.\n");
3111 return TEST_SKIPPED;
3114 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3115 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3116 printf("Device doesn't support RAW data-path APIs.\n");
3117 return TEST_SKIPPED;
3120 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3121 return TEST_SKIPPED;
3123 /* Verify the capabilities */
3124 struct rte_cryptodev_sym_capability_idx cap_idx;
3125 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3126 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
3127 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3129 return TEST_SKIPPED;
3131 /* Create SNOW 3G session */
3132 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3133 tdata->key.data, tdata->key.len,
3134 tdata->auth_iv.len, tdata->digest.len,
3135 RTE_CRYPTO_AUTH_OP_GENERATE,
3136 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
3140 /* alloc mbuf and set payload */
3141 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3143 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3144 rte_pktmbuf_tailroom(ut_params->ibuf));
3146 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3147 /* Append data which is padded to a multiple of */
3148 /* the algorithms block size */
3149 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3150 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3152 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3154 /* Create SNOW 3G operation */
3155 retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
3156 tdata->auth_iv.data, tdata->auth_iv.len,
3157 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3158 tdata->validAuthLenInBits.len,
3163 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3164 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3165 ut_params->op, 0, 1, 1, 0);
3167 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3169 ut_params->obuf = ut_params->op->sym->m_src;
3170 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3171 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3172 + plaintext_pad_len;
3175 TEST_ASSERT_BUFFERS_ARE_EQUAL(
3178 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
3179 "SNOW 3G Generated auth tag not as expected");
3185 test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
3187 struct crypto_testsuite_params *ts_params = &testsuite_params;
3188 struct crypto_unittest_params *ut_params = &unittest_params;
3191 unsigned plaintext_pad_len;
3192 unsigned plaintext_len;
3194 struct rte_cryptodev_info dev_info;
3196 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3197 uint64_t feat_flags = dev_info.feature_flags;
3199 if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
3200 ((tdata->validAuthLenInBits.len % 8) != 0)) {
3201 printf("Device doesn't support NON-Byte Aligned Data.\n");
3202 return TEST_SKIPPED;
3205 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3206 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3207 printf("Device doesn't support RAW data-path APIs.\n");
3208 return TEST_SKIPPED;
3211 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3212 return TEST_SKIPPED;
3214 /* Verify the capabilities */
3215 struct rte_cryptodev_sym_capability_idx cap_idx;
3216 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3217 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
3218 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3220 return TEST_SKIPPED;
3222 /* Create SNOW 3G session */
3223 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3224 tdata->key.data, tdata->key.len,
3225 tdata->auth_iv.len, tdata->digest.len,
3226 RTE_CRYPTO_AUTH_OP_VERIFY,
3227 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
3230 /* alloc mbuf and set payload */
3231 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3233 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3234 rte_pktmbuf_tailroom(ut_params->ibuf));
3236 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3237 /* Append data which is padded to a multiple of */
3238 /* the algorithms block size */
3239 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3240 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3242 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3244 /* Create SNOW 3G operation */
3245 retval = create_wireless_algo_hash_operation(tdata->digest.data,
3247 tdata->auth_iv.data, tdata->auth_iv.len,
3249 RTE_CRYPTO_AUTH_OP_VERIFY,
3250 tdata->validAuthLenInBits.len,
3255 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3256 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3257 ut_params->op, 0, 1, 1, 0);
3259 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3261 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3262 ut_params->obuf = ut_params->op->sym->m_src;
3263 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3264 + plaintext_pad_len;
3267 if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
3276 test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
3278 struct crypto_testsuite_params *ts_params = &testsuite_params;
3279 struct crypto_unittest_params *ut_params = &unittest_params;
3282 unsigned plaintext_pad_len;
3283 unsigned plaintext_len;
3285 struct rte_cryptodev_info dev_info;
3287 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3288 uint64_t feat_flags = dev_info.feature_flags;
3290 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3291 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3292 printf("Device doesn't support RAW data-path APIs.\n");
3293 return TEST_SKIPPED;
3296 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3297 return TEST_SKIPPED;
3299 /* Verify the capabilities */
3300 struct rte_cryptodev_sym_capability_idx cap_idx;
3301 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3302 cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
3303 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3305 return TEST_SKIPPED;
3307 /* Create KASUMI session */
3308 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3309 tdata->key.data, tdata->key.len,
3310 0, tdata->digest.len,
3311 RTE_CRYPTO_AUTH_OP_GENERATE,
3312 RTE_CRYPTO_AUTH_KASUMI_F9);
3316 /* alloc mbuf and set payload */
3317 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3319 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3320 rte_pktmbuf_tailroom(ut_params->ibuf));
3322 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3323 /* Append data which is padded to a multiple of */
3324 /* the algorithms block size */
3325 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3326 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3328 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3330 /* Create KASUMI operation */
3331 retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
3333 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3334 tdata->plaintext.len,
3339 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3340 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
3342 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3343 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3344 ut_params->op, 0, 1, 1, 0);
3346 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3349 ut_params->obuf = ut_params->op->sym->m_src;
3350 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3351 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3352 + plaintext_pad_len;
3355 TEST_ASSERT_BUFFERS_ARE_EQUAL(
3358 DIGEST_BYTE_LENGTH_KASUMI_F9,
3359 "KASUMI Generated auth tag not as expected");
3365 test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
3367 struct crypto_testsuite_params *ts_params = &testsuite_params;
3368 struct crypto_unittest_params *ut_params = &unittest_params;
3371 unsigned plaintext_pad_len;
3372 unsigned plaintext_len;
3374 struct rte_cryptodev_info dev_info;
3376 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3377 uint64_t feat_flags = dev_info.feature_flags;
3379 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3380 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3381 printf("Device doesn't support RAW data-path APIs.\n");
3382 return TEST_SKIPPED;
3385 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3386 return TEST_SKIPPED;
3388 /* Verify the capabilities */
3389 struct rte_cryptodev_sym_capability_idx cap_idx;
3390 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3391 cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
3392 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3394 return TEST_SKIPPED;
3396 /* Create KASUMI session */
3397 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3398 tdata->key.data, tdata->key.len,
3399 0, tdata->digest.len,
3400 RTE_CRYPTO_AUTH_OP_VERIFY,
3401 RTE_CRYPTO_AUTH_KASUMI_F9);
3404 /* alloc mbuf and set payload */
3405 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3407 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3408 rte_pktmbuf_tailroom(ut_params->ibuf));
3410 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3411 /* Append data which is padded to a multiple */
3412 /* of the algorithms block size */
3413 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3414 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3416 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3418 /* Create KASUMI operation */
3419 retval = create_wireless_algo_hash_operation(tdata->digest.data,
3423 RTE_CRYPTO_AUTH_OP_VERIFY,
3424 tdata->plaintext.len,
3429 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3430 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3431 ut_params->op, 0, 1, 1, 0);
3433 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3435 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3436 ut_params->obuf = ut_params->op->sym->m_src;
3437 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3438 + plaintext_pad_len;
3441 if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
3450 test_snow3g_hash_generate_test_case_1(void)
3452 return test_snow3g_authentication(&snow3g_hash_test_case_1);
3456 test_snow3g_hash_generate_test_case_2(void)
3458 return test_snow3g_authentication(&snow3g_hash_test_case_2);
3462 test_snow3g_hash_generate_test_case_3(void)
3464 return test_snow3g_authentication(&snow3g_hash_test_case_3);
3468 test_snow3g_hash_generate_test_case_4(void)
3470 return test_snow3g_authentication(&snow3g_hash_test_case_4);
3474 test_snow3g_hash_generate_test_case_5(void)
3476 return test_snow3g_authentication(&snow3g_hash_test_case_5);
3480 test_snow3g_hash_generate_test_case_6(void)
3482 return test_snow3g_authentication(&snow3g_hash_test_case_6);
3486 test_snow3g_hash_verify_test_case_1(void)
3488 return test_snow3g_authentication_verify(&snow3g_hash_test_case_1);
3493 test_snow3g_hash_verify_test_case_2(void)
3495 return test_snow3g_authentication_verify(&snow3g_hash_test_case_2);
3499 test_snow3g_hash_verify_test_case_3(void)
3501 return test_snow3g_authentication_verify(&snow3g_hash_test_case_3);
3505 test_snow3g_hash_verify_test_case_4(void)
3507 return test_snow3g_authentication_verify(&snow3g_hash_test_case_4);
3511 test_snow3g_hash_verify_test_case_5(void)
3513 return test_snow3g_authentication_verify(&snow3g_hash_test_case_5);
3517 test_snow3g_hash_verify_test_case_6(void)
3519 return test_snow3g_authentication_verify(&snow3g_hash_test_case_6);
3523 test_kasumi_hash_generate_test_case_1(void)
3525 return test_kasumi_authentication(&kasumi_hash_test_case_1);
3529 test_kasumi_hash_generate_test_case_2(void)
3531 return test_kasumi_authentication(&kasumi_hash_test_case_2);
3535 test_kasumi_hash_generate_test_case_3(void)
3537 return test_kasumi_authentication(&kasumi_hash_test_case_3);
3541 test_kasumi_hash_generate_test_case_4(void)
3543 return test_kasumi_authentication(&kasumi_hash_test_case_4);
3547 test_kasumi_hash_generate_test_case_5(void)
3549 return test_kasumi_authentication(&kasumi_hash_test_case_5);
3553 test_kasumi_hash_generate_test_case_6(void)
3555 return test_kasumi_authentication(&kasumi_hash_test_case_6);
3559 test_kasumi_hash_verify_test_case_1(void)
3561 return test_kasumi_authentication_verify(&kasumi_hash_test_case_1);
3565 test_kasumi_hash_verify_test_case_2(void)
3567 return test_kasumi_authentication_verify(&kasumi_hash_test_case_2);
3571 test_kasumi_hash_verify_test_case_3(void)
3573 return test_kasumi_authentication_verify(&kasumi_hash_test_case_3);
3577 test_kasumi_hash_verify_test_case_4(void)
3579 return test_kasumi_authentication_verify(&kasumi_hash_test_case_4);
3583 test_kasumi_hash_verify_test_case_5(void)
3585 return test_kasumi_authentication_verify(&kasumi_hash_test_case_5);
3589 test_kasumi_encryption(const struct kasumi_test_data *tdata)
3591 struct crypto_testsuite_params *ts_params = &testsuite_params;
3592 struct crypto_unittest_params *ut_params = &unittest_params;
3595 uint8_t *plaintext, *ciphertext;
3596 unsigned plaintext_pad_len;
3597 unsigned plaintext_len;
3598 struct rte_cryptodev_info dev_info;
3600 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3601 uint64_t feat_flags = dev_info.feature_flags;
3603 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3604 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3605 printf("Device doesn't support RAW data-path APIs.\n");
3606 return TEST_SKIPPED;
3609 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3610 return TEST_SKIPPED;
3612 /* Verify the capabilities */
3613 struct rte_cryptodev_sym_capability_idx cap_idx;
3614 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3615 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3616 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3618 return TEST_SKIPPED;
3620 /* Create KASUMI session */
3621 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3622 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3623 RTE_CRYPTO_CIPHER_KASUMI_F8,
3624 tdata->key.data, tdata->key.len,
3625 tdata->cipher_iv.len);
3629 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3631 /* Clear mbuf payload */
3632 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3633 rte_pktmbuf_tailroom(ut_params->ibuf));
3635 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3636 /* Append data which is padded to a multiple */
3637 /* of the algorithms block size */
3638 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3639 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3641 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3643 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3645 /* Create KASUMI operation */
3646 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3647 tdata->cipher_iv.len,
3648 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3649 tdata->validCipherOffsetInBits.len);
3653 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3654 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3655 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
3657 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3659 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3661 ut_params->obuf = ut_params->op->sym->m_dst;
3662 if (ut_params->obuf)
3663 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3665 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3667 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3669 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3670 (tdata->validCipherOffsetInBits.len >> 3);
3672 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3674 reference_ciphertext,
3675 tdata->validCipherLenInBits.len,
3676 "KASUMI Ciphertext data not as expected");
3681 test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
3683 struct crypto_testsuite_params *ts_params = &testsuite_params;
3684 struct crypto_unittest_params *ut_params = &unittest_params;
3688 unsigned int plaintext_pad_len;
3689 unsigned int plaintext_len;
3691 uint8_t buffer[10000];
3692 const uint8_t *ciphertext;
3694 struct rte_cryptodev_info dev_info;
3696 /* Verify the capabilities */
3697 struct rte_cryptodev_sym_capability_idx cap_idx;
3698 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3699 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3700 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3702 return TEST_SKIPPED;
3704 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3706 uint64_t feat_flags = dev_info.feature_flags;
3708 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
3709 printf("Device doesn't support in-place scatter-gather. "
3711 return TEST_SKIPPED;
3714 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3715 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3716 printf("Device doesn't support RAW data-path APIs.\n");
3717 return TEST_SKIPPED;
3720 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3721 return TEST_SKIPPED;
3723 /* Create KASUMI session */
3724 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3725 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3726 RTE_CRYPTO_CIPHER_KASUMI_F8,
3727 tdata->key.data, tdata->key.len,
3728 tdata->cipher_iv.len);
3732 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3735 /* Append data which is padded to a multiple */
3736 /* of the algorithms block size */
3737 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3739 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3740 plaintext_pad_len, 10, 0);
3742 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3744 /* Create KASUMI operation */
3745 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3746 tdata->cipher_iv.len,
3747 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3748 tdata->validCipherOffsetInBits.len);
3752 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3753 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3754 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
3756 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3758 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3760 ut_params->obuf = ut_params->op->sym->m_dst;
3762 if (ut_params->obuf)
3763 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3764 plaintext_len, buffer);
3766 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3767 tdata->validCipherOffsetInBits.len >> 3,
3768 plaintext_len, buffer);
3771 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3773 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3774 (tdata->validCipherOffsetInBits.len >> 3);
3776 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3778 reference_ciphertext,
3779 tdata->validCipherLenInBits.len,
3780 "KASUMI Ciphertext data not as expected");
3785 test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
3787 struct crypto_testsuite_params *ts_params = &testsuite_params;
3788 struct crypto_unittest_params *ut_params = &unittest_params;
3791 uint8_t *plaintext, *ciphertext;
3792 unsigned plaintext_pad_len;
3793 unsigned plaintext_len;
3795 /* Verify the capabilities */
3796 struct rte_cryptodev_sym_capability_idx cap_idx;
3797 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3798 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3799 /* Data-path service does not support OOP */
3800 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3802 return TEST_SKIPPED;
3804 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3805 return TEST_SKIPPED;
3807 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3808 return TEST_SKIPPED;
3810 /* Create KASUMI session */
3811 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3812 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3813 RTE_CRYPTO_CIPHER_KASUMI_F8,
3814 tdata->key.data, tdata->key.len,
3815 tdata->cipher_iv.len);
3819 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3820 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3822 /* Clear mbuf payload */
3823 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3824 rte_pktmbuf_tailroom(ut_params->ibuf));
3826 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3827 /* Append data which is padded to a multiple */
3828 /* of the algorithms block size */
3829 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3830 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3832 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3833 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3835 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3837 /* Create KASUMI operation */
3838 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3839 tdata->cipher_iv.len,
3840 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3841 tdata->validCipherOffsetInBits.len);
3845 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3847 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3849 ut_params->obuf = ut_params->op->sym->m_dst;
3850 if (ut_params->obuf)
3851 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3853 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3855 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3857 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3858 (tdata->validCipherOffsetInBits.len >> 3);
3860 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3862 reference_ciphertext,
3863 tdata->validCipherLenInBits.len,
3864 "KASUMI Ciphertext data not as expected");
3869 test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
3871 struct crypto_testsuite_params *ts_params = &testsuite_params;
3872 struct crypto_unittest_params *ut_params = &unittest_params;
3875 unsigned int plaintext_pad_len;
3876 unsigned int plaintext_len;
3878 const uint8_t *ciphertext;
3879 uint8_t buffer[2048];
3881 struct rte_cryptodev_info dev_info;
3883 /* Verify the capabilities */
3884 struct rte_cryptodev_sym_capability_idx cap_idx;
3885 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3886 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3887 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3889 return TEST_SKIPPED;
3891 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3892 return TEST_SKIPPED;
3894 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3895 return TEST_SKIPPED;
3897 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3899 uint64_t feat_flags = dev_info.feature_flags;
3900 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
3901 printf("Device doesn't support out-of-place scatter-gather "
3902 "in both input and output mbufs. "
3904 return TEST_SKIPPED;
3907 /* Create KASUMI session */
3908 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3909 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3910 RTE_CRYPTO_CIPHER_KASUMI_F8,
3911 tdata->key.data, tdata->key.len,
3912 tdata->cipher_iv.len);
3916 plaintext_len = ceil_byte_length(tdata->plaintext.len);
3917 /* Append data which is padded to a multiple */
3918 /* of the algorithms block size */
3919 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3921 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3922 plaintext_pad_len, 10, 0);
3923 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
3924 plaintext_pad_len, 3, 0);
3926 /* Append data which is padded to a multiple */
3927 /* of the algorithms block size */
3928 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3930 /* Create KASUMI operation */
3931 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3932 tdata->cipher_iv.len,
3933 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3934 tdata->validCipherOffsetInBits.len);
3938 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3940 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3942 ut_params->obuf = ut_params->op->sym->m_dst;
3943 if (ut_params->obuf)
3944 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3945 plaintext_pad_len, buffer);
3947 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3948 tdata->validCipherOffsetInBits.len >> 3,
3949 plaintext_pad_len, buffer);
3951 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3952 (tdata->validCipherOffsetInBits.len >> 3);
3954 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3956 reference_ciphertext,
3957 tdata->validCipherLenInBits.len,
3958 "KASUMI Ciphertext data not as expected");
3964 test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
3966 struct crypto_testsuite_params *ts_params = &testsuite_params;
3967 struct crypto_unittest_params *ut_params = &unittest_params;
3970 uint8_t *ciphertext, *plaintext;
3971 unsigned ciphertext_pad_len;
3972 unsigned ciphertext_len;
3974 /* Verify the capabilities */
3975 struct rte_cryptodev_sym_capability_idx cap_idx;
3976 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3977 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3978 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3980 return TEST_SKIPPED;
3982 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3983 return TEST_SKIPPED;
3985 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3986 return TEST_SKIPPED;
3988 /* Create KASUMI session */
3989 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3990 RTE_CRYPTO_CIPHER_OP_DECRYPT,
3991 RTE_CRYPTO_CIPHER_KASUMI_F8,
3992 tdata->key.data, tdata->key.len,
3993 tdata->cipher_iv.len);
3997 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3998 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4000 /* Clear mbuf payload */
4001 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4002 rte_pktmbuf_tailroom(ut_params->ibuf));
4004 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4005 /* Append data which is padded to a multiple */
4006 /* of the algorithms block size */
4007 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
4008 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4009 ciphertext_pad_len);
4010 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4011 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4013 debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4015 /* Create KASUMI operation */
4016 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4017 tdata->cipher_iv.len,
4018 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
4019 tdata->validCipherOffsetInBits.len);
4023 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4025 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4027 ut_params->obuf = ut_params->op->sym->m_dst;
4028 if (ut_params->obuf)
4029 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4031 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
4033 debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4035 const uint8_t *reference_plaintext = tdata->plaintext.data +
4036 (tdata->validCipherOffsetInBits.len >> 3);
4038 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4040 reference_plaintext,
4041 tdata->validCipherLenInBits.len,
4042 "KASUMI Plaintext data not as expected");
4047 test_kasumi_decryption(const struct kasumi_test_data *tdata)
4049 struct crypto_testsuite_params *ts_params = &testsuite_params;
4050 struct crypto_unittest_params *ut_params = &unittest_params;
4053 uint8_t *ciphertext, *plaintext;
4054 unsigned ciphertext_pad_len;
4055 unsigned ciphertext_len;
4056 struct rte_cryptodev_info dev_info;
4058 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4059 uint64_t feat_flags = dev_info.feature_flags;
4061 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4062 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4063 printf("Device doesn't support RAW data-path APIs.\n");
4064 return TEST_SKIPPED;
4067 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4068 return TEST_SKIPPED;
4070 /* Verify the capabilities */
4071 struct rte_cryptodev_sym_capability_idx cap_idx;
4072 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4073 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
4074 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4076 return TEST_SKIPPED;
4078 /* Create KASUMI session */
4079 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4080 RTE_CRYPTO_CIPHER_OP_DECRYPT,
4081 RTE_CRYPTO_CIPHER_KASUMI_F8,
4082 tdata->key.data, tdata->key.len,
4083 tdata->cipher_iv.len);
4087 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4089 /* Clear mbuf payload */
4090 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4091 rte_pktmbuf_tailroom(ut_params->ibuf));
4093 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4094 /* Append data which is padded to a multiple */
4095 /* of the algorithms block size */
4096 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
4097 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4098 ciphertext_pad_len);
4099 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4101 debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4103 /* Create KASUMI operation */
4104 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4105 tdata->cipher_iv.len,
4106 tdata->ciphertext.len,
4107 tdata->validCipherOffsetInBits.len);
4111 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4112 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4113 ut_params->op, 1, 0, 1, 0);
4115 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4117 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4119 ut_params->obuf = ut_params->op->sym->m_dst;
4120 if (ut_params->obuf)
4121 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4123 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
4125 debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4127 const uint8_t *reference_plaintext = tdata->plaintext.data +
4128 (tdata->validCipherOffsetInBits.len >> 3);
4130 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4132 reference_plaintext,
4133 tdata->validCipherLenInBits.len,
4134 "KASUMI Plaintext data not as expected");
4139 test_snow3g_encryption(const struct snow3g_test_data *tdata)
4141 struct crypto_testsuite_params *ts_params = &testsuite_params;
4142 struct crypto_unittest_params *ut_params = &unittest_params;
4145 uint8_t *plaintext, *ciphertext;
4146 unsigned plaintext_pad_len;
4147 unsigned plaintext_len;
4148 struct rte_cryptodev_info dev_info;
4150 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4151 uint64_t feat_flags = dev_info.feature_flags;
4153 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4154 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4155 printf("Device doesn't support RAW data-path APIs.\n");
4156 return TEST_SKIPPED;
4159 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4160 return TEST_SKIPPED;
4162 /* Verify the capabilities */
4163 struct rte_cryptodev_sym_capability_idx cap_idx;
4164 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4165 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4166 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4168 return TEST_SKIPPED;
4170 /* Create SNOW 3G session */
4171 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4172 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4173 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4174 tdata->key.data, tdata->key.len,
4175 tdata->cipher_iv.len);
4179 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4181 /* Clear mbuf payload */
4182 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4183 rte_pktmbuf_tailroom(ut_params->ibuf));
4185 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4186 /* Append data which is padded to a multiple of */
4187 /* the algorithms block size */
4188 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4189 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4191 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4193 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4195 /* Create SNOW 3G operation */
4196 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4197 tdata->cipher_iv.len,
4198 tdata->validCipherLenInBits.len,
4203 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4204 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4205 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4207 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4209 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4211 ut_params->obuf = ut_params->op->sym->m_dst;
4212 if (ut_params->obuf)
4213 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4215 ciphertext = plaintext;
4217 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4220 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4222 tdata->ciphertext.data,
4223 tdata->validDataLenInBits.len,
4224 "SNOW 3G Ciphertext data not as expected");
4230 test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
4232 struct crypto_testsuite_params *ts_params = &testsuite_params;
4233 struct crypto_unittest_params *ut_params = &unittest_params;
4234 uint8_t *plaintext, *ciphertext;
4237 unsigned plaintext_pad_len;
4238 unsigned plaintext_len;
4239 struct rte_cryptodev_info dev_info;
4241 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4242 uint64_t feat_flags = dev_info.feature_flags;
4244 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4245 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4246 printf("Device does not support RAW data-path APIs.\n");
4250 /* Verify the capabilities */
4251 struct rte_cryptodev_sym_capability_idx cap_idx;
4252 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4253 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4254 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4256 return TEST_SKIPPED;
4258 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4259 return TEST_SKIPPED;
4261 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4262 return TEST_SKIPPED;
4264 /* Create SNOW 3G session */
4265 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4266 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4267 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4268 tdata->key.data, tdata->key.len,
4269 tdata->cipher_iv.len);
4273 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4274 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4276 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4277 "Failed to allocate input buffer in mempool");
4278 TEST_ASSERT_NOT_NULL(ut_params->obuf,
4279 "Failed to allocate output buffer in mempool");
4281 /* Clear mbuf payload */
4282 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4283 rte_pktmbuf_tailroom(ut_params->ibuf));
4285 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4286 /* Append data which is padded to a multiple of */
4287 /* the algorithms block size */
4288 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4289 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4291 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4292 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4294 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4296 /* Create SNOW 3G operation */
4297 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4298 tdata->cipher_iv.len,
4299 tdata->validCipherLenInBits.len,
4304 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4305 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4306 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4308 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4310 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4312 ut_params->obuf = ut_params->op->sym->m_dst;
4313 if (ut_params->obuf)
4314 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4316 ciphertext = plaintext;
4318 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4321 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4323 tdata->ciphertext.data,
4324 tdata->validDataLenInBits.len,
4325 "SNOW 3G Ciphertext data not as expected");
4330 test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
4332 struct crypto_testsuite_params *ts_params = &testsuite_params;
4333 struct crypto_unittest_params *ut_params = &unittest_params;
4336 unsigned int plaintext_pad_len;
4337 unsigned int plaintext_len;
4338 uint8_t buffer[10000];
4339 const uint8_t *ciphertext;
4341 struct rte_cryptodev_info dev_info;
4343 /* Verify the capabilities */
4344 struct rte_cryptodev_sym_capability_idx cap_idx;
4345 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4346 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4347 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4349 return TEST_SKIPPED;
4351 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4352 return TEST_SKIPPED;
4354 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4355 return TEST_SKIPPED;
4357 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4359 uint64_t feat_flags = dev_info.feature_flags;
4361 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
4362 printf("Device doesn't support out-of-place scatter-gather "
4363 "in both input and output mbufs. "
4365 return TEST_SKIPPED;
4368 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4369 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4370 printf("Device does not support RAW data-path APIs.\n");
4374 /* Create SNOW 3G session */
4375 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4376 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4377 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4378 tdata->key.data, tdata->key.len,
4379 tdata->cipher_iv.len);
4383 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4384 /* Append data which is padded to a multiple of */
4385 /* the algorithms block size */
4386 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4388 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
4389 plaintext_pad_len, 10, 0);
4390 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
4391 plaintext_pad_len, 3, 0);
4393 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4394 "Failed to allocate input buffer in mempool");
4395 TEST_ASSERT_NOT_NULL(ut_params->obuf,
4396 "Failed to allocate output buffer in mempool");
4398 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
4400 /* Create SNOW 3G operation */
4401 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4402 tdata->cipher_iv.len,
4403 tdata->validCipherLenInBits.len,
4408 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4409 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4410 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4412 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4414 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4416 ut_params->obuf = ut_params->op->sym->m_dst;
4417 if (ut_params->obuf)
4418 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
4419 plaintext_len, buffer);
4421 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
4422 plaintext_len, buffer);
4424 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4427 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4429 tdata->ciphertext.data,
4430 tdata->validDataLenInBits.len,
4431 "SNOW 3G Ciphertext data not as expected");
4436 /* Shift right a buffer by "offset" bits, "offset" < 8 */
4438 buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset)
4440 uint8_t curr_byte, prev_byte;
4441 uint32_t length_in_bytes = ceil_byte_length(length + offset);
4442 uint8_t lower_byte_mask = (1 << offset) - 1;
4445 prev_byte = buffer[0];
4446 buffer[0] >>= offset;
4448 for (i = 1; i < length_in_bytes; i++) {
4449 curr_byte = buffer[i];
4450 buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) |
4451 (curr_byte >> offset);
4452 prev_byte = curr_byte;
4457 test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
4459 struct crypto_testsuite_params *ts_params = &testsuite_params;
4460 struct crypto_unittest_params *ut_params = &unittest_params;
4461 uint8_t *plaintext, *ciphertext;
4463 uint32_t plaintext_len;
4464 uint32_t plaintext_pad_len;
4465 uint8_t extra_offset = 4;
4466 uint8_t *expected_ciphertext_shifted;
4467 struct rte_cryptodev_info dev_info;
4469 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4470 uint64_t feat_flags = dev_info.feature_flags;
4472 if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
4473 ((tdata->validDataLenInBits.len % 8) != 0)) {
4474 printf("Device doesn't support NON-Byte Aligned Data.\n");
4475 return TEST_SKIPPED;
4478 /* Verify the capabilities */
4479 struct rte_cryptodev_sym_capability_idx cap_idx;
4480 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4481 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4482 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4484 return TEST_SKIPPED;
4486 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4487 return TEST_SKIPPED;
4489 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4490 return TEST_SKIPPED;
4492 /* Create SNOW 3G session */
4493 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4494 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4495 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4496 tdata->key.data, tdata->key.len,
4497 tdata->cipher_iv.len);
4501 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4502 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4504 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4505 "Failed to allocate input buffer in mempool");
4506 TEST_ASSERT_NOT_NULL(ut_params->obuf,
4507 "Failed to allocate output buffer in mempool");
4509 /* Clear mbuf payload */
4510 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4511 rte_pktmbuf_tailroom(ut_params->ibuf));
4513 plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset);
4515 * Append data which is padded to a
4516 * multiple of the algorithms block size
4518 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4520 plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf,
4523 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4525 memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3));
4526 buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset);
4528 #ifdef RTE_APP_TEST_DEBUG
4529 rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
4531 /* Create SNOW 3G operation */
4532 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4533 tdata->cipher_iv.len,
4534 tdata->validCipherLenInBits.len,
4539 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4540 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4541 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4543 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4545 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4547 ut_params->obuf = ut_params->op->sym->m_dst;
4548 if (ut_params->obuf)
4549 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4551 ciphertext = plaintext;
4553 #ifdef RTE_APP_TEST_DEBUG
4554 rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4557 expected_ciphertext_shifted = rte_malloc(NULL, plaintext_len, 8);
4559 TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted,
4560 "failed to reserve memory for ciphertext shifted\n");
4562 memcpy(expected_ciphertext_shifted, tdata->ciphertext.data,
4563 ceil_byte_length(tdata->ciphertext.len));
4564 buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len,
4567 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
4569 expected_ciphertext_shifted,
4570 tdata->validDataLenInBits.len,
4572 "SNOW 3G Ciphertext data not as expected");
4576 static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
4578 struct crypto_testsuite_params *ts_params = &testsuite_params;
4579 struct crypto_unittest_params *ut_params = &unittest_params;
4583 uint8_t *plaintext, *ciphertext;
4584 unsigned ciphertext_pad_len;
4585 unsigned ciphertext_len;
4586 struct rte_cryptodev_info dev_info;
4588 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4589 uint64_t feat_flags = dev_info.feature_flags;
4591 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4592 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4593 printf("Device doesn't support RAW data-path APIs.\n");
4594 return TEST_SKIPPED;
4597 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4598 return TEST_SKIPPED;
4600 /* Verify the capabilities */
4601 struct rte_cryptodev_sym_capability_idx cap_idx;
4602 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4603 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4604 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4606 return TEST_SKIPPED;
4608 /* Create SNOW 3G session */
4609 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4610 RTE_CRYPTO_CIPHER_OP_DECRYPT,
4611 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4612 tdata->key.data, tdata->key.len,
4613 tdata->cipher_iv.len);
4617 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4619 /* Clear mbuf payload */
4620 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4621 rte_pktmbuf_tailroom(ut_params->ibuf));
4623 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4624 /* Append data which is padded to a multiple of */
4625 /* the algorithms block size */
4626 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4627 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4628 ciphertext_pad_len);
4629 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4631 debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4633 /* Create SNOW 3G operation */
4634 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4635 tdata->cipher_iv.len,
4636 tdata->validCipherLenInBits.len,
4637 tdata->cipher.offset_bits);
4641 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4642 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4643 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4645 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4647 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4648 ut_params->obuf = ut_params->op->sym->m_dst;
4649 if (ut_params->obuf)
4650 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4652 plaintext = ciphertext;
4654 debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4657 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4658 tdata->plaintext.data,
4659 tdata->validDataLenInBits.len,
4660 "SNOW 3G Plaintext data not as expected");
4664 static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
4666 struct crypto_testsuite_params *ts_params = &testsuite_params;
4667 struct crypto_unittest_params *ut_params = &unittest_params;
4671 uint8_t *plaintext, *ciphertext;
4672 unsigned ciphertext_pad_len;
4673 unsigned ciphertext_len;
4674 struct rte_cryptodev_info dev_info;
4676 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4677 uint64_t feat_flags = dev_info.feature_flags;
4679 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4680 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4681 printf("Device does not support RAW data-path APIs.\n");
4684 /* Verify the capabilities */
4685 struct rte_cryptodev_sym_capability_idx cap_idx;
4686 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4687 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4688 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4690 return TEST_SKIPPED;
4692 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4693 return TEST_SKIPPED;
4695 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4696 return TEST_SKIPPED;
4698 /* Create SNOW 3G session */
4699 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4700 RTE_CRYPTO_CIPHER_OP_DECRYPT,
4701 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4702 tdata->key.data, tdata->key.len,
4703 tdata->cipher_iv.len);
4707 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4708 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4710 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4711 "Failed to allocate input buffer");
4712 TEST_ASSERT_NOT_NULL(ut_params->obuf,
4713 "Failed to allocate output buffer");
4715 /* Clear mbuf payload */
4716 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4717 rte_pktmbuf_tailroom(ut_params->ibuf));
4719 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
4720 rte_pktmbuf_tailroom(ut_params->obuf));
4722 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4723 /* Append data which is padded to a multiple of */
4724 /* the algorithms block size */
4725 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4726 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4727 ciphertext_pad_len);
4728 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4729 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4731 debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4733 /* Create SNOW 3G operation */
4734 retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4735 tdata->cipher_iv.len,
4736 tdata->validCipherLenInBits.len,
4741 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4742 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4743 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4745 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4747 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4748 ut_params->obuf = ut_params->op->sym->m_dst;
4749 if (ut_params->obuf)
4750 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4752 plaintext = ciphertext;
4754 debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4757 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4758 tdata->plaintext.data,
4759 tdata->validDataLenInBits.len,
4760 "SNOW 3G Plaintext data not as expected");
4765 test_zuc_cipher_auth(const struct wireless_test_data *tdata)
4767 struct crypto_testsuite_params *ts_params = &testsuite_params;
4768 struct crypto_unittest_params *ut_params = &unittest_params;
4772 uint8_t *plaintext, *ciphertext;
4773 unsigned int plaintext_pad_len;
4774 unsigned int plaintext_len;
4776 struct rte_cryptodev_info dev_info;
4777 struct rte_cryptodev_sym_capability_idx cap_idx;
4779 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4780 uint64_t feat_flags = dev_info.feature_flags;
4782 if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
4783 ((tdata->validAuthLenInBits.len % 8 != 0) ||
4784 (tdata->validDataLenInBits.len % 8 != 0))) {
4785 printf("Device doesn't support NON-Byte Aligned Data.\n");
4786 return TEST_SKIPPED;
4789 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4790 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4791 printf("Device doesn't support RAW data-path APIs.\n");
4792 return TEST_SKIPPED;
4795 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4796 return TEST_SKIPPED;
4798 /* Check if device supports ZUC EEA3 */
4799 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4800 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
4802 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4804 return TEST_SKIPPED;
4806 /* Check if device supports ZUC EIA3 */
4807 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4808 cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
4810 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4812 return TEST_SKIPPED;
4814 /* Create ZUC session */
4815 retval = create_zuc_cipher_auth_encrypt_generate_session(
4816 ts_params->valid_devs[0],
4820 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4822 /* clear mbuf payload */
4823 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4824 rte_pktmbuf_tailroom(ut_params->ibuf));
4826 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4827 /* Append data which is padded to a multiple of */
4828 /* the algorithms block size */
4829 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4830 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4832 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4834 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4836 /* Create ZUC operation */
4837 retval = create_zuc_cipher_hash_generate_operation(tdata);
4841 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4842 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4843 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4845 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4847 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4848 ut_params->obuf = ut_params->op->sym->m_src;
4849 if (ut_params->obuf)
4850 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4852 ciphertext = plaintext;
4854 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4856 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4858 tdata->ciphertext.data,
4859 tdata->validDataLenInBits.len,
4860 "ZUC Ciphertext data not as expected");
4862 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4863 + plaintext_pad_len;
4866 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4870 "ZUC Generated auth tag not as expected");
4875 test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
4877 struct crypto_testsuite_params *ts_params = &testsuite_params;
4878 struct crypto_unittest_params *ut_params = &unittest_params;
4882 uint8_t *plaintext, *ciphertext;
4883 unsigned plaintext_pad_len;
4884 unsigned plaintext_len;
4885 struct rte_cryptodev_info dev_info;
4887 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4888 uint64_t feat_flags = dev_info.feature_flags;
4890 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4891 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4892 printf("Device doesn't support RAW data-path APIs.\n");
4893 return TEST_SKIPPED;
4896 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4897 return TEST_SKIPPED;
4899 /* Verify the capabilities */
4900 struct rte_cryptodev_sym_capability_idx cap_idx;
4901 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4902 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
4903 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4905 return TEST_SKIPPED;
4906 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4907 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4908 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4910 return TEST_SKIPPED;
4912 /* Create SNOW 3G session */
4913 retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0],
4914 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4915 RTE_CRYPTO_AUTH_OP_GENERATE,
4916 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4917 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4918 tdata->key.data, tdata->key.len,
4919 tdata->auth_iv.len, tdata->digest.len,
4920 tdata->cipher_iv.len);
4923 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4925 /* clear mbuf payload */
4926 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4927 rte_pktmbuf_tailroom(ut_params->ibuf));
4929 plaintext_len = ceil_byte_length(tdata->plaintext.len);
4930 /* Append data which is padded to a multiple of */
4931 /* the algorithms block size */
4932 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4933 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4935 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4937 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4939 /* Create SNOW 3G operation */
4940 retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
4941 tdata->digest.len, tdata->auth_iv.data,
4943 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
4944 tdata->cipher_iv.data, tdata->cipher_iv.len,
4945 tdata->validCipherLenInBits.len,
4947 tdata->validAuthLenInBits.len,
4953 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4954 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4955 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4957 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4959 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4960 ut_params->obuf = ut_params->op->sym->m_src;
4961 if (ut_params->obuf)
4962 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4964 ciphertext = plaintext;
4966 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4968 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4970 tdata->ciphertext.data,
4971 tdata->validDataLenInBits.len,
4972 "SNOW 3G Ciphertext data not as expected");
4974 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4975 + plaintext_pad_len;
4978 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4981 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4982 "SNOW 3G Generated auth tag not as expected");
4987 test_snow3g_auth_cipher(const struct snow3g_test_data *tdata,
4988 uint8_t op_mode, uint8_t verify)
4990 struct crypto_testsuite_params *ts_params = &testsuite_params;
4991 struct crypto_unittest_params *ut_params = &unittest_params;
4995 uint8_t *plaintext = NULL, *ciphertext = NULL;
4996 unsigned int plaintext_pad_len;
4997 unsigned int plaintext_len;
4998 unsigned int ciphertext_pad_len;
4999 unsigned int ciphertext_len;
5001 struct rte_cryptodev_info dev_info;
5003 /* Verify the capabilities */
5004 struct rte_cryptodev_sym_capability_idx cap_idx;
5005 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5006 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
5007 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5009 return TEST_SKIPPED;
5010 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5011 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
5012 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5014 return TEST_SKIPPED;
5016 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5017 return TEST_SKIPPED;
5019 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5021 uint64_t feat_flags = dev_info.feature_flags;
5023 if (op_mode == OUT_OF_PLACE) {
5024 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5025 printf("Device doesn't support digest encrypted.\n");
5026 return TEST_SKIPPED;
5028 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5029 return TEST_SKIPPED;
5032 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5033 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5034 printf("Device doesn't support RAW data-path APIs.\n");
5035 return TEST_SKIPPED;
5038 /* Create SNOW 3G session */
5039 retval = create_wireless_algo_auth_cipher_session(
5040 ts_params->valid_devs[0],
5041 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5042 : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5043 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5044 : RTE_CRYPTO_AUTH_OP_GENERATE),
5045 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
5046 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
5047 tdata->key.data, tdata->key.len,
5048 tdata->auth_iv.len, tdata->digest.len,
5049 tdata->cipher_iv.len);
5053 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5054 if (op_mode == OUT_OF_PLACE)
5055 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5057 /* clear mbuf payload */
5058 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5059 rte_pktmbuf_tailroom(ut_params->ibuf));
5060 if (op_mode == OUT_OF_PLACE)
5061 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5062 rte_pktmbuf_tailroom(ut_params->obuf));
5064 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5065 plaintext_len = ceil_byte_length(tdata->plaintext.len);
5066 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5067 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5070 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5071 ciphertext_pad_len);
5072 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
5073 if (op_mode == OUT_OF_PLACE)
5074 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
5075 debug_hexdump(stdout, "ciphertext:", ciphertext,
5078 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5080 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5081 if (op_mode == OUT_OF_PLACE)
5082 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
5083 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5086 /* Create SNOW 3G operation */
5087 retval = create_wireless_algo_auth_cipher_operation(
5088 tdata->digest.data, tdata->digest.len,
5089 tdata->cipher_iv.data, tdata->cipher_iv.len,
5090 tdata->auth_iv.data, tdata->auth_iv.len,
5091 (tdata->digest.offset_bytes == 0 ?
5092 (verify ? ciphertext_pad_len : plaintext_pad_len)
5093 : tdata->digest.offset_bytes),
5094 tdata->validCipherLenInBits.len,
5095 tdata->cipher.offset_bits,
5096 tdata->validAuthLenInBits.len,
5097 tdata->auth.offset_bits,
5098 op_mode, 0, verify);
5103 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5104 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5105 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5107 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5110 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5112 ut_params->obuf = (op_mode == IN_PLACE ?
5113 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5116 if (ut_params->obuf)
5117 plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5120 plaintext = ciphertext +
5121 (tdata->cipher.offset_bits >> 3);
5123 debug_hexdump(stdout, "plaintext:", plaintext,
5124 (tdata->plaintext.len >> 3) - tdata->digest.len);
5125 debug_hexdump(stdout, "plaintext expected:",
5126 tdata->plaintext.data,
5127 (tdata->plaintext.len >> 3) - tdata->digest.len);
5129 if (ut_params->obuf)
5130 ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5133 ciphertext = plaintext;
5135 debug_hexdump(stdout, "ciphertext:", ciphertext,
5137 debug_hexdump(stdout, "ciphertext expected:",
5138 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5140 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5141 + (tdata->digest.offset_bytes == 0 ?
5142 plaintext_pad_len : tdata->digest.offset_bytes);
5144 debug_hexdump(stdout, "digest:", ut_params->digest,
5146 debug_hexdump(stdout, "digest expected:", tdata->digest.data,
5152 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5154 tdata->plaintext.data,
5155 (tdata->plaintext.len - tdata->cipher.offset_bits -
5156 (tdata->digest.len << 3)),
5157 tdata->cipher.offset_bits,
5158 "SNOW 3G Plaintext data not as expected");
5160 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5162 tdata->ciphertext.data,
5163 (tdata->validDataLenInBits.len -
5164 tdata->cipher.offset_bits),
5165 tdata->cipher.offset_bits,
5166 "SNOW 3G Ciphertext data not as expected");
5168 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5171 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5172 "SNOW 3G Generated auth tag not as expected");
5178 test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata,
5179 uint8_t op_mode, uint8_t verify)
5181 struct crypto_testsuite_params *ts_params = &testsuite_params;
5182 struct crypto_unittest_params *ut_params = &unittest_params;
5186 const uint8_t *plaintext = NULL;
5187 const uint8_t *ciphertext = NULL;
5188 const uint8_t *digest = NULL;
5189 unsigned int plaintext_pad_len;
5190 unsigned int plaintext_len;
5191 unsigned int ciphertext_pad_len;
5192 unsigned int ciphertext_len;
5193 uint8_t buffer[10000];
5194 uint8_t digest_buffer[10000];
5196 struct rte_cryptodev_info dev_info;
5198 /* Verify the capabilities */
5199 struct rte_cryptodev_sym_capability_idx cap_idx;
5200 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5201 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
5202 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5204 return TEST_SKIPPED;
5205 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5206 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
5207 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5209 return TEST_SKIPPED;
5211 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5212 return TEST_SKIPPED;
5214 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5216 uint64_t feat_flags = dev_info.feature_flags;
5218 if (op_mode == IN_PLACE) {
5219 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5220 printf("Device doesn't support in-place scatter-gather "
5221 "in both input and output mbufs.\n");
5222 return TEST_SKIPPED;
5224 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5225 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5226 printf("Device doesn't support RAW data-path APIs.\n");
5227 return TEST_SKIPPED;
5230 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5231 return TEST_SKIPPED;
5232 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5233 printf("Device doesn't support out-of-place scatter-gather "
5234 "in both input and output mbufs.\n");
5235 return TEST_SKIPPED;
5237 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5238 printf("Device doesn't support digest encrypted.\n");
5239 return TEST_SKIPPED;
5243 /* Create SNOW 3G session */
5244 retval = create_wireless_algo_auth_cipher_session(
5245 ts_params->valid_devs[0],
5246 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5247 : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5248 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5249 : RTE_CRYPTO_AUTH_OP_GENERATE),
5250 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
5251 RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
5252 tdata->key.data, tdata->key.len,
5253 tdata->auth_iv.len, tdata->digest.len,
5254 tdata->cipher_iv.len);
5259 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5260 plaintext_len = ceil_byte_length(tdata->plaintext.len);
5261 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5262 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5264 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5265 plaintext_pad_len, 15, 0);
5266 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5267 "Failed to allocate input buffer in mempool");
5269 if (op_mode == OUT_OF_PLACE) {
5270 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5271 plaintext_pad_len, 15, 0);
5272 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5273 "Failed to allocate output buffer in mempool");
5277 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
5278 tdata->ciphertext.data);
5279 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5280 ciphertext_len, buffer);
5281 debug_hexdump(stdout, "ciphertext:", ciphertext,
5284 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5285 tdata->plaintext.data);
5286 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5287 plaintext_len, buffer);
5288 debug_hexdump(stdout, "plaintext:", plaintext,
5291 memset(buffer, 0, sizeof(buffer));
5293 /* Create SNOW 3G operation */
5294 retval = create_wireless_algo_auth_cipher_operation(
5295 tdata->digest.data, tdata->digest.len,
5296 tdata->cipher_iv.data, tdata->cipher_iv.len,
5297 tdata->auth_iv.data, tdata->auth_iv.len,
5298 (tdata->digest.offset_bytes == 0 ?
5299 (verify ? ciphertext_pad_len : plaintext_pad_len)
5300 : tdata->digest.offset_bytes),
5301 tdata->validCipherLenInBits.len,
5302 tdata->cipher.offset_bits,
5303 tdata->validAuthLenInBits.len,
5304 tdata->auth.offset_bits,
5305 op_mode, 1, verify);
5310 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5311 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5312 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5314 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5317 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5319 ut_params->obuf = (op_mode == IN_PLACE ?
5320 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5323 if (ut_params->obuf)
5324 plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
5325 plaintext_len, buffer);
5327 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5328 plaintext_len, buffer);
5330 debug_hexdump(stdout, "plaintext:", plaintext,
5331 (tdata->plaintext.len >> 3) - tdata->digest.len);
5332 debug_hexdump(stdout, "plaintext expected:",
5333 tdata->plaintext.data,
5334 (tdata->plaintext.len >> 3) - tdata->digest.len);
5336 if (ut_params->obuf)
5337 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
5338 ciphertext_len, buffer);
5340 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5341 ciphertext_len, buffer);
5343 debug_hexdump(stdout, "ciphertext:", ciphertext,
5345 debug_hexdump(stdout, "ciphertext expected:",
5346 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5348 if (ut_params->obuf)
5349 digest = rte_pktmbuf_read(ut_params->obuf,
5350 (tdata->digest.offset_bytes == 0 ?
5351 plaintext_pad_len : tdata->digest.offset_bytes),
5352 tdata->digest.len, digest_buffer);
5354 digest = rte_pktmbuf_read(ut_params->ibuf,
5355 (tdata->digest.offset_bytes == 0 ?
5356 plaintext_pad_len : tdata->digest.offset_bytes),
5357 tdata->digest.len, digest_buffer);
5359 debug_hexdump(stdout, "digest:", digest,
5361 debug_hexdump(stdout, "digest expected:",
5362 tdata->digest.data, tdata->digest.len);
5367 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5369 tdata->plaintext.data,
5370 (tdata->plaintext.len - tdata->cipher.offset_bits -
5371 (tdata->digest.len << 3)),
5372 tdata->cipher.offset_bits,
5373 "SNOW 3G Plaintext data not as expected");
5375 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5377 tdata->ciphertext.data,
5378 (tdata->validDataLenInBits.len -
5379 tdata->cipher.offset_bits),
5380 tdata->cipher.offset_bits,
5381 "SNOW 3G Ciphertext data not as expected");
5383 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5386 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5387 "SNOW 3G Generated auth tag not as expected");
5393 test_kasumi_auth_cipher(const struct kasumi_test_data *tdata,
5394 uint8_t op_mode, uint8_t verify)
5396 struct crypto_testsuite_params *ts_params = &testsuite_params;
5397 struct crypto_unittest_params *ut_params = &unittest_params;
5401 uint8_t *plaintext = NULL, *ciphertext = NULL;
5402 unsigned int plaintext_pad_len;
5403 unsigned int plaintext_len;
5404 unsigned int ciphertext_pad_len;
5405 unsigned int ciphertext_len;
5407 struct rte_cryptodev_info dev_info;
5409 /* Verify the capabilities */
5410 struct rte_cryptodev_sym_capability_idx cap_idx;
5411 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5412 cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5413 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5415 return TEST_SKIPPED;
5416 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5417 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5418 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5420 return TEST_SKIPPED;
5422 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5424 uint64_t feat_flags = dev_info.feature_flags;
5426 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5427 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5428 printf("Device doesn't support RAW data-path APIs.\n");
5429 return TEST_SKIPPED;
5432 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5433 return TEST_SKIPPED;
5435 if (op_mode == OUT_OF_PLACE) {
5436 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5437 return TEST_SKIPPED;
5438 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5439 printf("Device doesn't support digest encrypted.\n");
5440 return TEST_SKIPPED;
5444 /* Create KASUMI session */
5445 retval = create_wireless_algo_auth_cipher_session(
5446 ts_params->valid_devs[0],
5447 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5448 : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5449 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5450 : RTE_CRYPTO_AUTH_OP_GENERATE),
5451 RTE_CRYPTO_AUTH_KASUMI_F9,
5452 RTE_CRYPTO_CIPHER_KASUMI_F8,
5453 tdata->key.data, tdata->key.len,
5454 0, tdata->digest.len,
5455 tdata->cipher_iv.len);
5460 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5461 if (op_mode == OUT_OF_PLACE)
5462 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5464 /* clear mbuf payload */
5465 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5466 rte_pktmbuf_tailroom(ut_params->ibuf));
5467 if (op_mode == OUT_OF_PLACE)
5468 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5469 rte_pktmbuf_tailroom(ut_params->obuf));
5471 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5472 plaintext_len = ceil_byte_length(tdata->plaintext.len);
5473 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5474 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5477 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5478 ciphertext_pad_len);
5479 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
5480 if (op_mode == OUT_OF_PLACE)
5481 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
5482 debug_hexdump(stdout, "ciphertext:", ciphertext,
5485 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5487 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5488 if (op_mode == OUT_OF_PLACE)
5489 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
5490 debug_hexdump(stdout, "plaintext:", plaintext,
5494 /* Create KASUMI operation */
5495 retval = create_wireless_algo_auth_cipher_operation(
5496 tdata->digest.data, tdata->digest.len,
5497 tdata->cipher_iv.data, tdata->cipher_iv.len,
5499 (tdata->digest.offset_bytes == 0 ?
5500 (verify ? ciphertext_pad_len : plaintext_pad_len)
5501 : tdata->digest.offset_bytes),
5502 tdata->validCipherLenInBits.len,
5503 tdata->validCipherOffsetInBits.len,
5504 tdata->validAuthLenInBits.len,
5506 op_mode, 0, verify);
5511 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5512 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5513 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5515 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5518 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5520 ut_params->obuf = (op_mode == IN_PLACE ?
5521 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5525 if (ut_params->obuf)
5526 plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5529 plaintext = ciphertext;
5531 debug_hexdump(stdout, "plaintext:", plaintext,
5532 (tdata->plaintext.len >> 3) - tdata->digest.len);
5533 debug_hexdump(stdout, "plaintext expected:",
5534 tdata->plaintext.data,
5535 (tdata->plaintext.len >> 3) - tdata->digest.len);
5537 if (ut_params->obuf)
5538 ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5541 ciphertext = plaintext;
5543 debug_hexdump(stdout, "ciphertext:", ciphertext,
5545 debug_hexdump(stdout, "ciphertext expected:",
5546 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5548 ut_params->digest = rte_pktmbuf_mtod(
5549 ut_params->obuf, uint8_t *) +
5550 (tdata->digest.offset_bytes == 0 ?
5551 plaintext_pad_len : tdata->digest.offset_bytes);
5553 debug_hexdump(stdout, "digest:", ut_params->digest,
5555 debug_hexdump(stdout, "digest expected:",
5556 tdata->digest.data, tdata->digest.len);
5561 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5563 tdata->plaintext.data,
5564 tdata->plaintext.len >> 3,
5565 "KASUMI Plaintext data not as expected");
5567 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5569 tdata->ciphertext.data,
5570 tdata->ciphertext.len >> 3,
5571 "KASUMI Ciphertext data not as expected");
5573 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5576 DIGEST_BYTE_LENGTH_KASUMI_F9,
5577 "KASUMI Generated auth tag not as expected");
5583 test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata,
5584 uint8_t op_mode, uint8_t verify)
5586 struct crypto_testsuite_params *ts_params = &testsuite_params;
5587 struct crypto_unittest_params *ut_params = &unittest_params;
5591 const uint8_t *plaintext = NULL;
5592 const uint8_t *ciphertext = NULL;
5593 const uint8_t *digest = NULL;
5594 unsigned int plaintext_pad_len;
5595 unsigned int plaintext_len;
5596 unsigned int ciphertext_pad_len;
5597 unsigned int ciphertext_len;
5598 uint8_t buffer[10000];
5599 uint8_t digest_buffer[10000];
5601 struct rte_cryptodev_info dev_info;
5603 /* Verify the capabilities */
5604 struct rte_cryptodev_sym_capability_idx cap_idx;
5605 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5606 cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5607 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5609 return TEST_SKIPPED;
5610 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5611 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5612 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5614 return TEST_SKIPPED;
5616 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5617 return TEST_SKIPPED;
5619 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5621 uint64_t feat_flags = dev_info.feature_flags;
5623 if (op_mode == IN_PLACE) {
5624 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5625 printf("Device doesn't support in-place scatter-gather "
5626 "in both input and output mbufs.\n");
5627 return TEST_SKIPPED;
5629 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5630 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5631 printf("Device doesn't support RAW data-path APIs.\n");
5632 return TEST_SKIPPED;
5635 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5636 return TEST_SKIPPED;
5637 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5638 printf("Device doesn't support out-of-place scatter-gather "
5639 "in both input and output mbufs.\n");
5640 return TEST_SKIPPED;
5642 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5643 printf("Device doesn't support digest encrypted.\n");
5644 return TEST_SKIPPED;
5648 /* Create KASUMI session */
5649 retval = create_wireless_algo_auth_cipher_session(
5650 ts_params->valid_devs[0],
5651 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5652 : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5653 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5654 : RTE_CRYPTO_AUTH_OP_GENERATE),
5655 RTE_CRYPTO_AUTH_KASUMI_F9,
5656 RTE_CRYPTO_CIPHER_KASUMI_F8,
5657 tdata->key.data, tdata->key.len,
5658 0, tdata->digest.len,
5659 tdata->cipher_iv.len);
5664 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5665 plaintext_len = ceil_byte_length(tdata->plaintext.len);
5666 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5667 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5669 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5670 plaintext_pad_len, 15, 0);
5671 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5672 "Failed to allocate input buffer in mempool");
5674 if (op_mode == OUT_OF_PLACE) {
5675 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5676 plaintext_pad_len, 15, 0);
5677 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5678 "Failed to allocate output buffer in mempool");
5682 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
5683 tdata->ciphertext.data);
5684 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5685 ciphertext_len, buffer);
5686 debug_hexdump(stdout, "ciphertext:", ciphertext,
5689 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5690 tdata->plaintext.data);
5691 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5692 plaintext_len, buffer);
5693 debug_hexdump(stdout, "plaintext:", plaintext,
5696 memset(buffer, 0, sizeof(buffer));
5698 /* Create KASUMI operation */
5699 retval = create_wireless_algo_auth_cipher_operation(
5700 tdata->digest.data, tdata->digest.len,
5701 tdata->cipher_iv.data, tdata->cipher_iv.len,
5703 (tdata->digest.offset_bytes == 0 ?
5704 (verify ? ciphertext_pad_len : plaintext_pad_len)
5705 : tdata->digest.offset_bytes),
5706 tdata->validCipherLenInBits.len,
5707 tdata->validCipherOffsetInBits.len,
5708 tdata->validAuthLenInBits.len,
5710 op_mode, 1, verify);
5715 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5716 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5717 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5719 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5722 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5724 ut_params->obuf = (op_mode == IN_PLACE ?
5725 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5728 if (ut_params->obuf)
5729 plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
5730 plaintext_len, buffer);
5732 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5733 plaintext_len, buffer);
5735 debug_hexdump(stdout, "plaintext:", plaintext,
5736 (tdata->plaintext.len >> 3) - tdata->digest.len);
5737 debug_hexdump(stdout, "plaintext expected:",
5738 tdata->plaintext.data,
5739 (tdata->plaintext.len >> 3) - tdata->digest.len);
5741 if (ut_params->obuf)
5742 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
5743 ciphertext_len, buffer);
5745 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5746 ciphertext_len, buffer);
5748 debug_hexdump(stdout, "ciphertext:", ciphertext,
5750 debug_hexdump(stdout, "ciphertext expected:",
5751 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5753 if (ut_params->obuf)
5754 digest = rte_pktmbuf_read(ut_params->obuf,
5755 (tdata->digest.offset_bytes == 0 ?
5756 plaintext_pad_len : tdata->digest.offset_bytes),
5757 tdata->digest.len, digest_buffer);
5759 digest = rte_pktmbuf_read(ut_params->ibuf,
5760 (tdata->digest.offset_bytes == 0 ?
5761 plaintext_pad_len : tdata->digest.offset_bytes),
5762 tdata->digest.len, digest_buffer);
5764 debug_hexdump(stdout, "digest:", digest,
5766 debug_hexdump(stdout, "digest expected:",
5767 tdata->digest.data, tdata->digest.len);
5772 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5774 tdata->plaintext.data,
5775 tdata->plaintext.len >> 3,
5776 "KASUMI Plaintext data not as expected");
5778 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5780 tdata->ciphertext.data,
5781 tdata->validDataLenInBits.len,
5782 "KASUMI Ciphertext data not as expected");
5784 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5787 DIGEST_BYTE_LENGTH_KASUMI_F9,
5788 "KASUMI Generated auth tag not as expected");
5794 test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
5796 struct crypto_testsuite_params *ts_params = &testsuite_params;
5797 struct crypto_unittest_params *ut_params = &unittest_params;
5801 uint8_t *plaintext, *ciphertext;
5802 unsigned plaintext_pad_len;
5803 unsigned plaintext_len;
5804 struct rte_cryptodev_info dev_info;
5806 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5807 uint64_t feat_flags = dev_info.feature_flags;
5809 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5810 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5811 printf("Device doesn't support RAW data-path APIs.\n");
5812 return TEST_SKIPPED;
5815 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5816 return TEST_SKIPPED;
5818 /* Verify the capabilities */
5819 struct rte_cryptodev_sym_capability_idx cap_idx;
5820 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5821 cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5822 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5824 return TEST_SKIPPED;
5825 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5826 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5827 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5829 return TEST_SKIPPED;
5831 /* Create KASUMI session */
5832 retval = create_wireless_algo_cipher_auth_session(
5833 ts_params->valid_devs[0],
5834 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5835 RTE_CRYPTO_AUTH_OP_GENERATE,
5836 RTE_CRYPTO_AUTH_KASUMI_F9,
5837 RTE_CRYPTO_CIPHER_KASUMI_F8,
5838 tdata->key.data, tdata->key.len,
5839 0, tdata->digest.len,
5840 tdata->cipher_iv.len);
5844 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5846 /* clear mbuf payload */
5847 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5848 rte_pktmbuf_tailroom(ut_params->ibuf));
5850 plaintext_len = ceil_byte_length(tdata->plaintext.len);
5851 /* Append data which is padded to a multiple of */
5852 /* the algorithms block size */
5853 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5854 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5856 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5858 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5860 /* Create KASUMI operation */
5861 retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
5862 tdata->digest.len, NULL, 0,
5863 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
5864 tdata->cipher_iv.data, tdata->cipher_iv.len,
5865 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
5866 tdata->validCipherOffsetInBits.len,
5867 tdata->validAuthLenInBits.len,
5873 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5874 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5875 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5877 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5879 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5881 if (ut_params->op->sym->m_dst)
5882 ut_params->obuf = ut_params->op->sym->m_dst;
5884 ut_params->obuf = ut_params->op->sym->m_src;
5886 ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
5887 tdata->validCipherOffsetInBits.len >> 3);
5889 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5890 + plaintext_pad_len;
5892 const uint8_t *reference_ciphertext = tdata->ciphertext.data +
5893 (tdata->validCipherOffsetInBits.len >> 3);
5895 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5897 reference_ciphertext,
5898 tdata->validCipherLenInBits.len,
5899 "KASUMI Ciphertext data not as expected");
5902 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5905 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5906 "KASUMI Generated auth tag not as expected");
5911 check_cipher_capability(const struct crypto_testsuite_params *ts_params,
5912 const enum rte_crypto_cipher_algorithm cipher_algo,
5913 const uint16_t key_size, const uint16_t iv_size)
5915 struct rte_cryptodev_sym_capability_idx cap_idx;
5916 const struct rte_cryptodev_symmetric_capability *cap;
5918 /* Check if device supports the algorithm */
5919 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5920 cap_idx.algo.cipher = cipher_algo;
5922 cap = rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5928 /* Check if device supports key size and IV size */
5929 if (rte_cryptodev_sym_capability_check_cipher(cap, key_size,
5938 check_auth_capability(const struct crypto_testsuite_params *ts_params,
5939 const enum rte_crypto_auth_algorithm auth_algo,
5940 const uint16_t key_size, const uint16_t iv_size,
5941 const uint16_t tag_size)
5943 struct rte_cryptodev_sym_capability_idx cap_idx;
5944 const struct rte_cryptodev_symmetric_capability *cap;
5946 /* Check if device supports the algorithm */
5947 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5948 cap_idx.algo.auth = auth_algo;
5950 cap = rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5956 /* Check if device supports key size and IV size */
5957 if (rte_cryptodev_sym_capability_check_auth(cap, key_size,
5958 tag_size, iv_size) < 0) {
5966 test_zuc_encryption(const struct wireless_test_data *tdata)
5968 struct crypto_testsuite_params *ts_params = &testsuite_params;
5969 struct crypto_unittest_params *ut_params = &unittest_params;
5972 uint8_t *plaintext, *ciphertext;
5973 unsigned plaintext_pad_len;
5974 unsigned plaintext_len;
5975 struct rte_cryptodev_info dev_info;
5977 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5978 uint64_t feat_flags = dev_info.feature_flags;
5980 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5981 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5982 printf("Device doesn't support RAW data-path APIs.\n");
5983 return TEST_SKIPPED;
5986 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5987 return TEST_SKIPPED;
5989 /* Check if device supports ZUC EEA3 */
5990 if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
5991 tdata->key.len, tdata->cipher_iv.len) < 0)
5992 return TEST_SKIPPED;
5994 /* Create ZUC session */
5995 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
5996 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5997 RTE_CRYPTO_CIPHER_ZUC_EEA3,
5998 tdata->key.data, tdata->key.len,
5999 tdata->cipher_iv.len);
6003 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6005 /* Clear mbuf payload */
6006 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6007 rte_pktmbuf_tailroom(ut_params->ibuf));
6009 plaintext_len = ceil_byte_length(tdata->plaintext.len);
6010 /* Append data which is padded to a multiple */
6011 /* of the algorithms block size */
6012 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
6013 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6015 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6017 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
6019 /* Create ZUC operation */
6020 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
6021 tdata->cipher_iv.len,
6022 tdata->plaintext.len,
6027 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6028 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6029 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
6031 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6033 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6035 ut_params->obuf = ut_params->op->sym->m_dst;
6036 if (ut_params->obuf)
6037 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
6039 ciphertext = plaintext;
6041 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
6044 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6046 tdata->ciphertext.data,
6047 tdata->validCipherLenInBits.len,
6048 "ZUC Ciphertext data not as expected");
6053 test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
6055 struct crypto_testsuite_params *ts_params = &testsuite_params;
6056 struct crypto_unittest_params *ut_params = &unittest_params;
6060 unsigned int plaintext_pad_len;
6061 unsigned int plaintext_len;
6062 const uint8_t *ciphertext;
6063 uint8_t ciphertext_buffer[2048];
6064 struct rte_cryptodev_info dev_info;
6066 /* Check if device supports ZUC EEA3 */
6067 if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
6068 tdata->key.len, tdata->cipher_iv.len) < 0)
6069 return TEST_SKIPPED;
6071 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
6072 return TEST_SKIPPED;
6074 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6076 uint64_t feat_flags = dev_info.feature_flags;
6078 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6079 printf("Device doesn't support in-place scatter-gather. "
6081 return TEST_SKIPPED;
6084 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6085 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6086 printf("Device doesn't support RAW data-path APIs.\n");
6087 return TEST_SKIPPED;
6090 plaintext_len = ceil_byte_length(tdata->plaintext.len);
6092 /* Append data which is padded to a multiple */
6093 /* of the algorithms block size */
6094 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
6096 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
6097 plaintext_pad_len, 10, 0);
6099 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
6100 tdata->plaintext.data);
6102 /* Create ZUC session */
6103 retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
6104 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
6105 RTE_CRYPTO_CIPHER_ZUC_EEA3,
6106 tdata->key.data, tdata->key.len,
6107 tdata->cipher_iv.len);
6111 /* Clear mbuf payload */
6113 pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
6115 /* Create ZUC operation */
6116 retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
6117 tdata->cipher_iv.len, tdata->plaintext.len,
6122 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6123 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6124 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
6126 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6128 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6130 ut_params->obuf = ut_params->op->sym->m_dst;
6131 if (ut_params->obuf)
6132 ciphertext = rte_pktmbuf_read(ut_params->obuf,
6133 0, plaintext_len, ciphertext_buffer);
6135 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
6136 0, plaintext_len, ciphertext_buffer);
6139 debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
6142 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6144 tdata->ciphertext.data,
6145 tdata->validCipherLenInBits.len,
6146 "ZUC Ciphertext data not as expected");
6152 test_zuc_authentication(const struct wireless_test_data *tdata)
6154 struct crypto_testsuite_params *ts_params = &testsuite_params;
6155 struct crypto_unittest_params *ut_params = &unittest_params;
6158 unsigned plaintext_pad_len;
6159 unsigned plaintext_len;
6162 struct rte_cryptodev_info dev_info;
6164 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6165 uint64_t feat_flags = dev_info.feature_flags;
6167 if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
6168 (tdata->validAuthLenInBits.len % 8 != 0)) {
6169 printf("Device doesn't support NON-Byte Aligned Data.\n");
6170 return TEST_SKIPPED;
6173 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6174 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6175 printf("Device doesn't support RAW data-path APIs.\n");
6176 return TEST_SKIPPED;
6179 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
6180 return TEST_SKIPPED;
6182 /* Check if device supports ZUC EIA3 */
6183 if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3,
6184 tdata->key.len, tdata->auth_iv.len,
6185 tdata->digest.len) < 0)
6186 return TEST_SKIPPED;
6188 /* Create ZUC session */
6189 retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
6190 tdata->key.data, tdata->key.len,
6191 tdata->auth_iv.len, tdata->digest.len,
6192 RTE_CRYPTO_AUTH_OP_GENERATE,
6193 RTE_CRYPTO_AUTH_ZUC_EIA3);
6197 /* alloc mbuf and set payload */
6198 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6200 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6201 rte_pktmbuf_tailroom(ut_params->ibuf));
6203 plaintext_len = ceil_byte_length(tdata->plaintext.len);
6204 /* Append data which is padded to a multiple of */
6205 /* the algorithms block size */
6206 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
6207 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6209 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6211 /* Create ZUC operation */
6212 retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
6213 tdata->auth_iv.data, tdata->auth_iv.len,
6214 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
6215 tdata->validAuthLenInBits.len,
6220 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6221 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6222 ut_params->op, 0, 1, 1, 0);
6224 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6226 ut_params->obuf = ut_params->op->sym->m_src;
6227 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6228 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
6229 + plaintext_pad_len;
6232 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6236 "ZUC Generated auth tag not as expected");
6242 test_zuc_auth_cipher(const struct wireless_test_data *tdata,
6243 uint8_t op_mode, uint8_t verify)
6245 struct crypto_testsuite_params *ts_params = &testsuite_params;
6246 struct crypto_unittest_params *ut_params = &unittest_params;
6250 uint8_t *plaintext = NULL, *ciphertext = NULL;
6251 unsigned int plaintext_pad_len;
6252 unsigned int plaintext_len;
6253 unsigned int ciphertext_pad_len;
6254 unsigned int ciphertext_len;
6256 struct rte_cryptodev_info dev_info;
6258 /* Check if device supports ZUC EEA3 */
6259 if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
6260 tdata->key.len, tdata->cipher_iv.len) < 0)
6261 return TEST_SKIPPED;
6263 /* Check if device supports ZUC EIA3 */
6264 if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3,
6265 tdata->key.len, tdata->auth_iv.len,
6266 tdata->digest.len) < 0)
6267 return TEST_SKIPPED;
6269 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6271 uint64_t feat_flags = dev_info.feature_flags;
6273 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6274 printf("Device doesn't support digest encrypted.\n");
6275 return TEST_SKIPPED;
6277 if (op_mode == IN_PLACE) {
6278 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6279 printf("Device doesn't support in-place scatter-gather "
6280 "in both input and output mbufs.\n");
6281 return TEST_SKIPPED;
6284 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6285 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6286 printf("Device doesn't support RAW data-path APIs.\n");
6287 return TEST_SKIPPED;
6290 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6291 return TEST_SKIPPED;
6292 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
6293 printf("Device doesn't support out-of-place scatter-gather "
6294 "in both input and output mbufs.\n");
6295 return TEST_SKIPPED;
6299 /* Create ZUC session */
6300 retval = create_wireless_algo_auth_cipher_session(
6301 ts_params->valid_devs[0],
6302 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
6303 : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
6304 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
6305 : RTE_CRYPTO_AUTH_OP_GENERATE),
6306 RTE_CRYPTO_AUTH_ZUC_EIA3,
6307 RTE_CRYPTO_CIPHER_ZUC_EEA3,
6308 tdata->key.data, tdata->key.len,
6309 tdata->auth_iv.len, tdata->digest.len,
6310 tdata->cipher_iv.len);
6315 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6316 if (op_mode == OUT_OF_PLACE)
6317 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6319 /* clear mbuf payload */
6320 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6321 rte_pktmbuf_tailroom(ut_params->ibuf));
6322 if (op_mode == OUT_OF_PLACE)
6323 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
6324 rte_pktmbuf_tailroom(ut_params->obuf));
6326 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
6327 plaintext_len = ceil_byte_length(tdata->plaintext.len);
6328 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6329 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6332 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6333 ciphertext_pad_len);
6334 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
6335 if (op_mode == OUT_OF_PLACE)
6336 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
6337 debug_hexdump(stdout, "ciphertext:", ciphertext,
6340 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6342 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6343 if (op_mode == OUT_OF_PLACE)
6344 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
6345 debug_hexdump(stdout, "plaintext:", plaintext,
6349 /* Create ZUC operation */
6350 retval = create_wireless_algo_auth_cipher_operation(
6351 tdata->digest.data, tdata->digest.len,
6352 tdata->cipher_iv.data, tdata->cipher_iv.len,
6353 tdata->auth_iv.data, tdata->auth_iv.len,
6354 (tdata->digest.offset_bytes == 0 ?
6355 (verify ? ciphertext_pad_len : plaintext_pad_len)
6356 : tdata->digest.offset_bytes),
6357 tdata->validCipherLenInBits.len,
6358 tdata->validCipherOffsetInBits.len,
6359 tdata->validAuthLenInBits.len,
6361 op_mode, 0, verify);
6366 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6367 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6368 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
6370 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6373 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6375 ut_params->obuf = (op_mode == IN_PLACE ?
6376 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6380 if (ut_params->obuf)
6381 plaintext = rte_pktmbuf_mtod(ut_params->obuf,
6384 plaintext = ciphertext;
6386 debug_hexdump(stdout, "plaintext:", plaintext,
6387 (tdata->plaintext.len >> 3) - tdata->digest.len);
6388 debug_hexdump(stdout, "plaintext expected:",
6389 tdata->plaintext.data,
6390 (tdata->plaintext.len >> 3) - tdata->digest.len);
6392 if (ut_params->obuf)
6393 ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
6396 ciphertext = plaintext;
6398 debug_hexdump(stdout, "ciphertext:", ciphertext,
6400 debug_hexdump(stdout, "ciphertext expected:",
6401 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
6403 ut_params->digest = rte_pktmbuf_mtod(
6404 ut_params->obuf, uint8_t *) +
6405 (tdata->digest.offset_bytes == 0 ?
6406 plaintext_pad_len : tdata->digest.offset_bytes);
6408 debug_hexdump(stdout, "digest:", ut_params->digest,
6410 debug_hexdump(stdout, "digest expected:",
6411 tdata->digest.data, tdata->digest.len);
6416 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6418 tdata->plaintext.data,
6419 tdata->plaintext.len >> 3,
6420 "ZUC Plaintext data not as expected");
6422 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6424 tdata->ciphertext.data,
6425 tdata->ciphertext.len >> 3,
6426 "ZUC Ciphertext data not as expected");
6428 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6431 DIGEST_BYTE_LENGTH_KASUMI_F9,
6432 "ZUC Generated auth tag not as expected");
6438 test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata,
6439 uint8_t op_mode, uint8_t verify)
6441 struct crypto_testsuite_params *ts_params = &testsuite_params;
6442 struct crypto_unittest_params *ut_params = &unittest_params;
6446 const uint8_t *plaintext = NULL;
6447 const uint8_t *ciphertext = NULL;
6448 const uint8_t *digest = NULL;
6449 unsigned int plaintext_pad_len;
6450 unsigned int plaintext_len;
6451 unsigned int ciphertext_pad_len;
6452 unsigned int ciphertext_len;
6453 uint8_t buffer[10000];
6454 uint8_t digest_buffer[10000];
6456 struct rte_cryptodev_info dev_info;
6458 /* Check if device supports ZUC EEA3 */
6459 if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
6460 tdata->key.len, tdata->cipher_iv.len) < 0)
6461 return TEST_SKIPPED;
6463 /* Check if device supports ZUC EIA3 */
6464 if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3,
6465 tdata->key.len, tdata->auth_iv.len,
6466 tdata->digest.len) < 0)
6467 return TEST_SKIPPED;
6469 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6471 uint64_t feat_flags = dev_info.feature_flags;
6473 if (op_mode == IN_PLACE) {
6474 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6475 printf("Device doesn't support in-place scatter-gather "
6476 "in both input and output mbufs.\n");
6477 return TEST_SKIPPED;
6480 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6481 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6482 printf("Device doesn't support RAW data-path APIs.\n");
6483 return TEST_SKIPPED;
6486 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6487 return TEST_SKIPPED;
6488 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
6489 printf("Device doesn't support out-of-place scatter-gather "
6490 "in both input and output mbufs.\n");
6491 return TEST_SKIPPED;
6493 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6494 printf("Device doesn't support digest encrypted.\n");
6495 return TEST_SKIPPED;
6499 /* Create ZUC session */
6500 retval = create_wireless_algo_auth_cipher_session(
6501 ts_params->valid_devs[0],
6502 (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
6503 : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
6504 (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
6505 : RTE_CRYPTO_AUTH_OP_GENERATE),
6506 RTE_CRYPTO_AUTH_ZUC_EIA3,
6507 RTE_CRYPTO_CIPHER_ZUC_EEA3,
6508 tdata->key.data, tdata->key.len,
6509 tdata->auth_iv.len, tdata->digest.len,
6510 tdata->cipher_iv.len);
6515 ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
6516 plaintext_len = ceil_byte_length(tdata->plaintext.len);
6517 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6518 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6520 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
6521 plaintext_pad_len, 15, 0);
6522 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
6523 "Failed to allocate input buffer in mempool");
6525 if (op_mode == OUT_OF_PLACE) {
6526 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
6527 plaintext_pad_len, 15, 0);
6528 TEST_ASSERT_NOT_NULL(ut_params->obuf,
6529 "Failed to allocate output buffer in mempool");
6533 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
6534 tdata->ciphertext.data);
6535 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6536 ciphertext_len, buffer);
6537 debug_hexdump(stdout, "ciphertext:", ciphertext,
6540 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
6541 tdata->plaintext.data);
6542 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6543 plaintext_len, buffer);
6544 debug_hexdump(stdout, "plaintext:", plaintext,
6547 memset(buffer, 0, sizeof(buffer));
6549 /* Create ZUC operation */
6550 retval = create_wireless_algo_auth_cipher_operation(
6551 tdata->digest.data, tdata->digest.len,
6552 tdata->cipher_iv.data, tdata->cipher_iv.len,
6554 (tdata->digest.offset_bytes == 0 ?
6555 (verify ? ciphertext_pad_len : plaintext_pad_len)
6556 : tdata->digest.offset_bytes),
6557 tdata->validCipherLenInBits.len,
6558 tdata->validCipherOffsetInBits.len,
6559 tdata->validAuthLenInBits.len,
6561 op_mode, 1, verify);
6566 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6567 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6568 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
6570 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6573 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6575 ut_params->obuf = (op_mode == IN_PLACE ?
6576 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6579 if (ut_params->obuf)
6580 plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
6581 plaintext_len, buffer);
6583 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6584 plaintext_len, buffer);
6586 debug_hexdump(stdout, "plaintext:", plaintext,
6587 (tdata->plaintext.len >> 3) - tdata->digest.len);
6588 debug_hexdump(stdout, "plaintext expected:",
6589 tdata->plaintext.data,
6590 (tdata->plaintext.len >> 3) - tdata->digest.len);
6592 if (ut_params->obuf)
6593 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
6594 ciphertext_len, buffer);
6596 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6597 ciphertext_len, buffer);
6599 debug_hexdump(stdout, "ciphertext:", ciphertext,
6601 debug_hexdump(stdout, "ciphertext expected:",
6602 tdata->ciphertext.data, tdata->ciphertext.len >> 3);
6604 if (ut_params->obuf)
6605 digest = rte_pktmbuf_read(ut_params->obuf,
6606 (tdata->digest.offset_bytes == 0 ?
6607 plaintext_pad_len : tdata->digest.offset_bytes),
6608 tdata->digest.len, digest_buffer);
6610 digest = rte_pktmbuf_read(ut_params->ibuf,
6611 (tdata->digest.offset_bytes == 0 ?
6612 plaintext_pad_len : tdata->digest.offset_bytes),
6613 tdata->digest.len, digest_buffer);
6615 debug_hexdump(stdout, "digest:", digest,
6617 debug_hexdump(stdout, "digest expected:",
6618 tdata->digest.data, tdata->digest.len);
6623 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6625 tdata->plaintext.data,
6626 tdata->plaintext.len >> 3,
6627 "ZUC Plaintext data not as expected");
6629 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6631 tdata->ciphertext.data,
6632 tdata->validDataLenInBits.len,
6633 "ZUC Ciphertext data not as expected");
6635 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6638 DIGEST_BYTE_LENGTH_KASUMI_F9,
6639 "ZUC Generated auth tag not as expected");
6645 test_kasumi_encryption_test_case_1(void)
6647 return test_kasumi_encryption(&kasumi_test_case_1);
6651 test_kasumi_encryption_test_case_1_sgl(void)
6653 return test_kasumi_encryption_sgl(&kasumi_test_case_1);
6657 test_kasumi_encryption_test_case_1_oop(void)
6659 return test_kasumi_encryption_oop(&kasumi_test_case_1);
6663 test_kasumi_encryption_test_case_1_oop_sgl(void)
6665 return test_kasumi_encryption_oop_sgl(&kasumi_test_case_1);
6669 test_kasumi_encryption_test_case_2(void)
6671 return test_kasumi_encryption(&kasumi_test_case_2);
6675 test_kasumi_encryption_test_case_3(void)
6677 return test_kasumi_encryption(&kasumi_test_case_3);
6681 test_kasumi_encryption_test_case_4(void)
6683 return test_kasumi_encryption(&kasumi_test_case_4);
6687 test_kasumi_encryption_test_case_5(void)
6689 return test_kasumi_encryption(&kasumi_test_case_5);
6693 test_kasumi_decryption_test_case_1(void)
6695 return test_kasumi_decryption(&kasumi_test_case_1);
6699 test_kasumi_decryption_test_case_1_oop(void)
6701 return test_kasumi_decryption_oop(&kasumi_test_case_1);
6705 test_kasumi_decryption_test_case_2(void)
6707 return test_kasumi_decryption(&kasumi_test_case_2);
6711 test_kasumi_decryption_test_case_3(void)
6713 /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6714 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6715 return TEST_SKIPPED;
6716 return test_kasumi_decryption(&kasumi_test_case_3);
6720 test_kasumi_decryption_test_case_4(void)
6722 return test_kasumi_decryption(&kasumi_test_case_4);
6726 test_kasumi_decryption_test_case_5(void)
6728 return test_kasumi_decryption(&kasumi_test_case_5);
6731 test_snow3g_encryption_test_case_1(void)
6733 return test_snow3g_encryption(&snow3g_test_case_1);
6737 test_snow3g_encryption_test_case_1_oop(void)
6739 return test_snow3g_encryption_oop(&snow3g_test_case_1);
6743 test_snow3g_encryption_test_case_1_oop_sgl(void)
6745 return test_snow3g_encryption_oop_sgl(&snow3g_test_case_1);
6750 test_snow3g_encryption_test_case_1_offset_oop(void)
6752 return test_snow3g_encryption_offset_oop(&snow3g_test_case_1);
6756 test_snow3g_encryption_test_case_2(void)
6758 return test_snow3g_encryption(&snow3g_test_case_2);
6762 test_snow3g_encryption_test_case_3(void)
6764 return test_snow3g_encryption(&snow3g_test_case_3);
6768 test_snow3g_encryption_test_case_4(void)
6770 return test_snow3g_encryption(&snow3g_test_case_4);
6774 test_snow3g_encryption_test_case_5(void)
6776 return test_snow3g_encryption(&snow3g_test_case_5);
6780 test_snow3g_decryption_test_case_1(void)
6782 return test_snow3g_decryption(&snow3g_test_case_1);
6786 test_snow3g_decryption_test_case_1_oop(void)
6788 return test_snow3g_decryption_oop(&snow3g_test_case_1);
6792 test_snow3g_decryption_test_case_2(void)
6794 return test_snow3g_decryption(&snow3g_test_case_2);
6798 test_snow3g_decryption_test_case_3(void)
6800 return test_snow3g_decryption(&snow3g_test_case_3);
6804 test_snow3g_decryption_test_case_4(void)
6806 return test_snow3g_decryption(&snow3g_test_case_4);
6810 test_snow3g_decryption_test_case_5(void)
6812 return test_snow3g_decryption(&snow3g_test_case_5);
6816 * Function prepares snow3g_hash_test_data from snow3g_test_data.
6817 * Pattern digest from snow3g_test_data must be allocated as
6818 * 4 last bytes in plaintext.
6821 snow3g_hash_test_vector_setup(const struct snow3g_test_data *pattern,
6822 struct snow3g_hash_test_data *output)
6824 if ((pattern != NULL) && (output != NULL)) {
6825 output->key.len = pattern->key.len;
6827 memcpy(output->key.data,
6828 pattern->key.data, pattern->key.len);
6830 output->auth_iv.len = pattern->auth_iv.len;
6832 memcpy(output->auth_iv.data,
6833 pattern->auth_iv.data, pattern->auth_iv.len);
6835 output->plaintext.len = pattern->plaintext.len;
6837 memcpy(output->plaintext.data,
6838 pattern->plaintext.data, pattern->plaintext.len >> 3);
6840 output->digest.len = pattern->digest.len;
6842 memcpy(output->digest.data,
6843 &pattern->plaintext.data[pattern->digest.offset_bytes],
6844 pattern->digest.len);
6846 output->validAuthLenInBits.len =
6847 pattern->validAuthLenInBits.len;
6852 * Test case verify computed cipher and digest from snow3g_test_case_7 data.
6855 test_snow3g_decryption_with_digest_test_case_1(void)
6857 struct snow3g_hash_test_data snow3g_hash_data;
6858 struct rte_cryptodev_info dev_info;
6859 struct crypto_testsuite_params *ts_params = &testsuite_params;
6861 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6862 uint64_t feat_flags = dev_info.feature_flags;
6864 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6865 printf("Device doesn't support encrypted digest operations.\n");
6866 return TEST_SKIPPED;
6870 * Function prepare data for hash veryfication test case.
6871 * Digest is allocated in 4 last bytes in plaintext, pattern.
6873 snow3g_hash_test_vector_setup(&snow3g_test_case_7, &snow3g_hash_data);
6875 return test_snow3g_decryption(&snow3g_test_case_7) &
6876 test_snow3g_authentication_verify(&snow3g_hash_data);
6880 test_snow3g_cipher_auth_test_case_1(void)
6882 return test_snow3g_cipher_auth(&snow3g_test_case_3);
6886 test_snow3g_auth_cipher_test_case_1(void)
6888 return test_snow3g_auth_cipher(
6889 &snow3g_auth_cipher_test_case_1, IN_PLACE, 0);
6893 test_snow3g_auth_cipher_test_case_2(void)
6895 return test_snow3g_auth_cipher(
6896 &snow3g_auth_cipher_test_case_2, IN_PLACE, 0);
6900 test_snow3g_auth_cipher_test_case_2_oop(void)
6902 return test_snow3g_auth_cipher(
6903 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
6907 test_snow3g_auth_cipher_part_digest_enc(void)
6909 return test_snow3g_auth_cipher(
6910 &snow3g_auth_cipher_partial_digest_encryption,
6915 test_snow3g_auth_cipher_part_digest_enc_oop(void)
6917 return test_snow3g_auth_cipher(
6918 &snow3g_auth_cipher_partial_digest_encryption,
6923 test_snow3g_auth_cipher_test_case_3_sgl(void)
6925 /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6926 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6927 return TEST_SKIPPED;
6928 return test_snow3g_auth_cipher_sgl(
6929 &snow3g_auth_cipher_test_case_3, IN_PLACE, 0);
6933 test_snow3g_auth_cipher_test_case_3_oop_sgl(void)
6935 return test_snow3g_auth_cipher_sgl(
6936 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 0);
6940 test_snow3g_auth_cipher_part_digest_enc_sgl(void)
6942 /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6943 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6944 return TEST_SKIPPED;
6945 return test_snow3g_auth_cipher_sgl(
6946 &snow3g_auth_cipher_partial_digest_encryption,
6951 test_snow3g_auth_cipher_part_digest_enc_oop_sgl(void)
6953 return test_snow3g_auth_cipher_sgl(
6954 &snow3g_auth_cipher_partial_digest_encryption,
6959 test_snow3g_auth_cipher_verify_test_case_1(void)
6961 return test_snow3g_auth_cipher(
6962 &snow3g_auth_cipher_test_case_1, IN_PLACE, 1);
6966 test_snow3g_auth_cipher_verify_test_case_2(void)
6968 return test_snow3g_auth_cipher(
6969 &snow3g_auth_cipher_test_case_2, IN_PLACE, 1);
6973 test_snow3g_auth_cipher_verify_test_case_2_oop(void)
6975 return test_snow3g_auth_cipher(
6976 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
6980 test_snow3g_auth_cipher_verify_part_digest_enc(void)
6982 return test_snow3g_auth_cipher(
6983 &snow3g_auth_cipher_partial_digest_encryption,
6988 test_snow3g_auth_cipher_verify_part_digest_enc_oop(void)
6990 return test_snow3g_auth_cipher(
6991 &snow3g_auth_cipher_partial_digest_encryption,
6996 test_snow3g_auth_cipher_verify_test_case_3_sgl(void)
6998 return test_snow3g_auth_cipher_sgl(
6999 &snow3g_auth_cipher_test_case_3, IN_PLACE, 1);
7003 test_snow3g_auth_cipher_verify_test_case_3_oop_sgl(void)
7005 return test_snow3g_auth_cipher_sgl(
7006 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 1);
7010 test_snow3g_auth_cipher_verify_part_digest_enc_sgl(void)
7012 return test_snow3g_auth_cipher_sgl(
7013 &snow3g_auth_cipher_partial_digest_encryption,
7018 test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl(void)
7020 return test_snow3g_auth_cipher_sgl(
7021 &snow3g_auth_cipher_partial_digest_encryption,
7026 test_snow3g_auth_cipher_with_digest_test_case_1(void)
7028 return test_snow3g_auth_cipher(
7029 &snow3g_test_case_7, IN_PLACE, 0);
7033 test_kasumi_auth_cipher_test_case_1(void)
7035 return test_kasumi_auth_cipher(
7036 &kasumi_test_case_3, IN_PLACE, 0);
7040 test_kasumi_auth_cipher_test_case_2(void)
7042 return test_kasumi_auth_cipher(
7043 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
7047 test_kasumi_auth_cipher_test_case_2_oop(void)
7049 return test_kasumi_auth_cipher(
7050 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
7054 test_kasumi_auth_cipher_test_case_2_sgl(void)
7056 return test_kasumi_auth_cipher_sgl(
7057 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
7061 test_kasumi_auth_cipher_test_case_2_oop_sgl(void)
7063 return test_kasumi_auth_cipher_sgl(
7064 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
7068 test_kasumi_auth_cipher_verify_test_case_1(void)
7070 return test_kasumi_auth_cipher(
7071 &kasumi_test_case_3, IN_PLACE, 1);
7075 test_kasumi_auth_cipher_verify_test_case_2(void)
7077 return test_kasumi_auth_cipher(
7078 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
7082 test_kasumi_auth_cipher_verify_test_case_2_oop(void)
7084 return test_kasumi_auth_cipher(
7085 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
7089 test_kasumi_auth_cipher_verify_test_case_2_sgl(void)
7091 return test_kasumi_auth_cipher_sgl(
7092 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
7096 test_kasumi_auth_cipher_verify_test_case_2_oop_sgl(void)
7098 return test_kasumi_auth_cipher_sgl(
7099 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
7103 test_kasumi_cipher_auth_test_case_1(void)
7105 return test_kasumi_cipher_auth(&kasumi_test_case_6);
7109 test_zuc_encryption_test_case_1(void)
7111 return test_zuc_encryption(&zuc_test_case_cipher_193b);
7115 test_zuc_encryption_test_case_2(void)
7117 return test_zuc_encryption(&zuc_test_case_cipher_800b);
7121 test_zuc_encryption_test_case_3(void)
7123 return test_zuc_encryption(&zuc_test_case_cipher_1570b);
7127 test_zuc_encryption_test_case_4(void)
7129 return test_zuc_encryption(&zuc_test_case_cipher_2798b);
7133 test_zuc_encryption_test_case_5(void)
7135 return test_zuc_encryption(&zuc_test_case_cipher_4019b);
7139 test_zuc_encryption_test_case_6_sgl(void)
7141 return test_zuc_encryption_sgl(&zuc_test_case_cipher_193b);
7145 test_zuc_hash_generate_test_case_1(void)
7147 return test_zuc_authentication(&zuc_test_case_auth_1b);
7151 test_zuc_hash_generate_test_case_2(void)
7153 return test_zuc_authentication(&zuc_test_case_auth_90b);
7157 test_zuc_hash_generate_test_case_3(void)
7159 return test_zuc_authentication(&zuc_test_case_auth_577b);
7163 test_zuc_hash_generate_test_case_4(void)
7165 return test_zuc_authentication(&zuc_test_case_auth_2079b);
7169 test_zuc_hash_generate_test_case_5(void)
7171 return test_zuc_authentication(&zuc_test_auth_5670b);
7175 test_zuc_hash_generate_test_case_6(void)
7177 return test_zuc_authentication(&zuc_test_case_auth_128b);
7181 test_zuc_hash_generate_test_case_7(void)
7183 return test_zuc_authentication(&zuc_test_case_auth_2080b);
7187 test_zuc_hash_generate_test_case_8(void)
7189 return test_zuc_authentication(&zuc_test_case_auth_584b);
7193 test_zuc_hash_generate_test_case_9(void)
7195 return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_32b);
7199 test_zuc_hash_generate_test_case_10(void)
7201 return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_64b);
7205 test_zuc_hash_generate_test_case_11(void)
7207 return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_128b);
7211 test_zuc_cipher_auth_test_case_1(void)
7213 return test_zuc_cipher_auth(&zuc_test_case_cipher_200b_auth_200b);
7217 test_zuc_cipher_auth_test_case_2(void)
7219 return test_zuc_cipher_auth(&zuc_test_case_cipher_800b_auth_120b);
7223 test_zuc_auth_cipher_test_case_1(void)
7225 return test_zuc_auth_cipher(
7226 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
7230 test_zuc_auth_cipher_test_case_1_oop(void)
7232 return test_zuc_auth_cipher(
7233 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
7237 test_zuc_auth_cipher_test_case_1_sgl(void)
7239 return test_zuc_auth_cipher_sgl(
7240 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
7244 test_zuc_auth_cipher_test_case_1_oop_sgl(void)
7246 return test_zuc_auth_cipher_sgl(
7247 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
7251 test_zuc_auth_cipher_verify_test_case_1(void)
7253 return test_zuc_auth_cipher(
7254 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
7258 test_zuc_auth_cipher_verify_test_case_1_oop(void)
7260 return test_zuc_auth_cipher(
7261 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
7265 test_zuc_auth_cipher_verify_test_case_1_sgl(void)
7267 return test_zuc_auth_cipher_sgl(
7268 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
7272 test_zuc_auth_cipher_verify_test_case_1_oop_sgl(void)
7274 return test_zuc_auth_cipher_sgl(
7275 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
7279 test_zuc256_encryption_test_case_1(void)
7281 return test_zuc_encryption(&zuc256_test_case_cipher_1);
7285 test_zuc256_encryption_test_case_2(void)
7287 return test_zuc_encryption(&zuc256_test_case_cipher_2);
7291 test_zuc256_authentication_test_case_1(void)
7293 return test_zuc_authentication(&zuc256_test_case_auth_1);
7297 test_zuc256_authentication_test_case_2(void)
7299 return test_zuc_authentication(&zuc256_test_case_auth_2);
7303 test_mixed_check_if_unsupported(const struct mixed_cipher_auth_test_data *tdata)
7305 uint8_t dev_id = testsuite_params.valid_devs[0];
7307 struct rte_cryptodev_sym_capability_idx cap_idx;
7309 /* Check if device supports particular cipher algorithm */
7310 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
7311 cap_idx.algo.cipher = tdata->cipher_algo;
7312 if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
7313 return TEST_SKIPPED;
7315 /* Check if device supports particular hash algorithm */
7316 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
7317 cap_idx.algo.auth = tdata->auth_algo;
7318 if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
7319 return TEST_SKIPPED;
7325 test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata,
7326 uint8_t op_mode, uint8_t verify)
7328 struct crypto_testsuite_params *ts_params = &testsuite_params;
7329 struct crypto_unittest_params *ut_params = &unittest_params;
7333 uint8_t *plaintext = NULL, *ciphertext = NULL;
7334 unsigned int plaintext_pad_len;
7335 unsigned int plaintext_len;
7336 unsigned int ciphertext_pad_len;
7337 unsigned int ciphertext_len;
7339 struct rte_cryptodev_info dev_info;
7340 struct rte_crypto_op *op;
7342 /* Check if device supports particular algorithms separately */
7343 if (test_mixed_check_if_unsupported(tdata))
7344 return TEST_SKIPPED;
7345 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
7346 return TEST_SKIPPED;
7348 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
7350 uint64_t feat_flags = dev_info.feature_flags;
7352 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
7353 printf("Device doesn't support digest encrypted.\n");
7354 return TEST_SKIPPED;
7357 /* Create the session */
7359 retval = create_wireless_algo_cipher_auth_session(
7360 ts_params->valid_devs[0],
7361 RTE_CRYPTO_CIPHER_OP_DECRYPT,
7362 RTE_CRYPTO_AUTH_OP_VERIFY,
7365 tdata->auth_key.data, tdata->auth_key.len,
7366 tdata->auth_iv.len, tdata->digest_enc.len,
7367 tdata->cipher_iv.len);
7369 retval = create_wireless_algo_auth_cipher_session(
7370 ts_params->valid_devs[0],
7371 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7372 RTE_CRYPTO_AUTH_OP_GENERATE,
7375 tdata->auth_key.data, tdata->auth_key.len,
7376 tdata->auth_iv.len, tdata->digest_enc.len,
7377 tdata->cipher_iv.len);
7381 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7382 if (op_mode == OUT_OF_PLACE)
7383 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7385 /* clear mbuf payload */
7386 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7387 rte_pktmbuf_tailroom(ut_params->ibuf));
7388 if (op_mode == OUT_OF_PLACE) {
7390 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
7391 rte_pktmbuf_tailroom(ut_params->obuf));
7394 ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
7395 plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
7396 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
7397 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
7400 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7401 ciphertext_pad_len);
7402 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
7403 if (op_mode == OUT_OF_PLACE)
7404 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
7405 debug_hexdump(stdout, "ciphertext:", ciphertext,
7408 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7410 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
7411 if (op_mode == OUT_OF_PLACE)
7412 rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
7413 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
7416 /* Create the operation */
7417 retval = create_wireless_algo_auth_cipher_operation(
7418 tdata->digest_enc.data, tdata->digest_enc.len,
7419 tdata->cipher_iv.data, tdata->cipher_iv.len,
7420 tdata->auth_iv.data, tdata->auth_iv.len,
7421 (tdata->digest_enc.offset == 0 ?
7423 : tdata->digest_enc.offset),
7424 tdata->validCipherLen.len_bits,
7425 tdata->cipher.offset_bits,
7426 tdata->validAuthLen.len_bits,
7427 tdata->auth.offset_bits,
7428 op_mode, 0, verify);
7433 op = process_crypto_request(ts_params->valid_devs[0], ut_params->op);
7435 /* Check if the op failed because the device doesn't */
7436 /* support this particular combination of algorithms */
7437 if (op == NULL && ut_params->op->status ==
7438 RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
7439 printf("Device doesn't support this mixed combination. "
7441 return TEST_SKIPPED;
7445 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
7447 ut_params->obuf = (op_mode == IN_PLACE ?
7448 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
7451 if (ut_params->obuf)
7452 plaintext = rte_pktmbuf_mtod(ut_params->obuf,
7455 plaintext = ciphertext +
7456 (tdata->cipher.offset_bits >> 3);
7458 debug_hexdump(stdout, "plaintext:", plaintext,
7459 tdata->plaintext.len_bits >> 3);
7460 debug_hexdump(stdout, "plaintext expected:",
7461 tdata->plaintext.data,
7462 tdata->plaintext.len_bits >> 3);
7464 if (ut_params->obuf)
7465 ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
7468 ciphertext = plaintext;
7470 debug_hexdump(stdout, "ciphertext:", ciphertext,
7472 debug_hexdump(stdout, "ciphertext expected:",
7473 tdata->ciphertext.data,
7474 tdata->ciphertext.len_bits >> 3);
7476 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
7477 + (tdata->digest_enc.offset == 0 ?
7478 plaintext_pad_len : tdata->digest_enc.offset);
7480 debug_hexdump(stdout, "digest:", ut_params->digest,
7481 tdata->digest_enc.len);
7482 debug_hexdump(stdout, "digest expected:",
7483 tdata->digest_enc.data,
7484 tdata->digest_enc.len);
7489 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7491 tdata->plaintext.data,
7492 tdata->plaintext.len_bits >> 3,
7493 "Plaintext data not as expected");
7495 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7497 tdata->ciphertext.data,
7498 tdata->validDataLen.len_bits,
7499 "Ciphertext data not as expected");
7501 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7503 tdata->digest_enc.data,
7504 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
7505 "Generated auth tag not as expected");
7508 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7509 "crypto op processing failed");
7515 test_mixed_auth_cipher_sgl(const struct mixed_cipher_auth_test_data *tdata,
7516 uint8_t op_mode, uint8_t verify)
7518 struct crypto_testsuite_params *ts_params = &testsuite_params;
7519 struct crypto_unittest_params *ut_params = &unittest_params;
7523 const uint8_t *plaintext = NULL;
7524 const uint8_t *ciphertext = NULL;
7525 const uint8_t *digest = NULL;
7526 unsigned int plaintext_pad_len;
7527 unsigned int plaintext_len;
7528 unsigned int ciphertext_pad_len;
7529 unsigned int ciphertext_len;
7530 uint8_t buffer[10000];
7531 uint8_t digest_buffer[10000];
7533 struct rte_cryptodev_info dev_info;
7534 struct rte_crypto_op *op;
7536 /* Check if device supports particular algorithms */
7537 if (test_mixed_check_if_unsupported(tdata))
7538 return TEST_SKIPPED;
7539 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
7540 return TEST_SKIPPED;
7542 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
7544 uint64_t feat_flags = dev_info.feature_flags;
7546 if (op_mode == IN_PLACE) {
7547 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
7548 printf("Device doesn't support in-place scatter-gather "
7549 "in both input and output mbufs.\n");
7550 return TEST_SKIPPED;
7553 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
7554 printf("Device doesn't support out-of-place scatter-gather "
7555 "in both input and output mbufs.\n");
7556 return TEST_SKIPPED;
7558 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
7559 printf("Device doesn't support digest encrypted.\n");
7560 return TEST_SKIPPED;
7564 /* Create the session */
7566 retval = create_wireless_algo_cipher_auth_session(
7567 ts_params->valid_devs[0],
7568 RTE_CRYPTO_CIPHER_OP_DECRYPT,
7569 RTE_CRYPTO_AUTH_OP_VERIFY,
7572 tdata->auth_key.data, tdata->auth_key.len,
7573 tdata->auth_iv.len, tdata->digest_enc.len,
7574 tdata->cipher_iv.len);
7576 retval = create_wireless_algo_auth_cipher_session(
7577 ts_params->valid_devs[0],
7578 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7579 RTE_CRYPTO_AUTH_OP_GENERATE,
7582 tdata->auth_key.data, tdata->auth_key.len,
7583 tdata->auth_iv.len, tdata->digest_enc.len,
7584 tdata->cipher_iv.len);
7588 ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
7589 plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
7590 ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
7591 plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
7593 ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
7594 ciphertext_pad_len, 15, 0);
7595 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
7596 "Failed to allocate input buffer in mempool");
7598 if (op_mode == OUT_OF_PLACE) {
7599 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
7600 plaintext_pad_len, 15, 0);
7601 TEST_ASSERT_NOT_NULL(ut_params->obuf,
7602 "Failed to allocate output buffer in mempool");
7606 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
7607 tdata->ciphertext.data);
7608 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
7609 ciphertext_len, buffer);
7610 debug_hexdump(stdout, "ciphertext:", ciphertext,
7613 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
7614 tdata->plaintext.data);
7615 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
7616 plaintext_len, buffer);
7617 debug_hexdump(stdout, "plaintext:", plaintext,
7620 memset(buffer, 0, sizeof(buffer));
7622 /* Create the operation */
7623 retval = create_wireless_algo_auth_cipher_operation(
7624 tdata->digest_enc.data, tdata->digest_enc.len,
7625 tdata->cipher_iv.data, tdata->cipher_iv.len,
7626 tdata->auth_iv.data, tdata->auth_iv.len,
7627 (tdata->digest_enc.offset == 0 ?
7629 : tdata->digest_enc.offset),
7630 tdata->validCipherLen.len_bits,
7631 tdata->cipher.offset_bits,
7632 tdata->validAuthLen.len_bits,
7633 tdata->auth.offset_bits,
7634 op_mode, 1, verify);
7639 op = process_crypto_request(ts_params->valid_devs[0], ut_params->op);
7641 /* Check if the op failed because the device doesn't */
7642 /* support this particular combination of algorithms */
7643 if (op == NULL && ut_params->op->status ==
7644 RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
7645 printf("Device doesn't support this mixed combination. "
7647 return TEST_SKIPPED;
7651 TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
7653 ut_params->obuf = (op_mode == IN_PLACE ?
7654 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
7657 if (ut_params->obuf)
7658 plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
7659 plaintext_len, buffer);
7661 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
7662 plaintext_len, buffer);
7664 debug_hexdump(stdout, "plaintext:", plaintext,
7665 (tdata->plaintext.len_bits >> 3) -
7666 tdata->digest_enc.len);
7667 debug_hexdump(stdout, "plaintext expected:",
7668 tdata->plaintext.data,
7669 (tdata->plaintext.len_bits >> 3) -
7670 tdata->digest_enc.len);
7672 if (ut_params->obuf)
7673 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
7674 ciphertext_len, buffer);
7676 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
7677 ciphertext_len, buffer);
7679 debug_hexdump(stdout, "ciphertext:", ciphertext,
7681 debug_hexdump(stdout, "ciphertext expected:",
7682 tdata->ciphertext.data,
7683 tdata->ciphertext.len_bits >> 3);
7685 if (ut_params->obuf)
7686 digest = rte_pktmbuf_read(ut_params->obuf,
7687 (tdata->digest_enc.offset == 0 ?
7689 tdata->digest_enc.offset),
7690 tdata->digest_enc.len, digest_buffer);
7692 digest = rte_pktmbuf_read(ut_params->ibuf,
7693 (tdata->digest_enc.offset == 0 ?
7695 tdata->digest_enc.offset),
7696 tdata->digest_enc.len, digest_buffer);
7698 debug_hexdump(stdout, "digest:", digest,
7699 tdata->digest_enc.len);
7700 debug_hexdump(stdout, "digest expected:",
7701 tdata->digest_enc.data, tdata->digest_enc.len);
7706 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7708 tdata->plaintext.data,
7709 tdata->plaintext.len_bits >> 3,
7710 "Plaintext data not as expected");
7712 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7714 tdata->ciphertext.data,
7715 tdata->validDataLen.len_bits,
7716 "Ciphertext data not as expected");
7717 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7719 tdata->digest_enc.data,
7720 tdata->digest_enc.len,
7721 "Generated auth tag not as expected");
7724 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7725 "crypto op processing failed");
7730 /** AUTH AES CMAC + CIPHER AES CTR */
7733 test_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7735 return test_mixed_auth_cipher(
7736 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7740 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7742 return test_mixed_auth_cipher(
7743 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7747 test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7749 return test_mixed_auth_cipher_sgl(
7750 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7754 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7756 return test_mixed_auth_cipher_sgl(
7757 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7761 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7763 return test_mixed_auth_cipher(
7764 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7768 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7770 return test_mixed_auth_cipher(
7771 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7775 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7777 return test_mixed_auth_cipher_sgl(
7778 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7782 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7784 return test_mixed_auth_cipher_sgl(
7785 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7788 /** MIXED AUTH + CIPHER */
7791 test_auth_zuc_cipher_snow_test_case_1(void)
7793 return test_mixed_auth_cipher(
7794 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7798 test_verify_auth_zuc_cipher_snow_test_case_1(void)
7800 return test_mixed_auth_cipher(
7801 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7805 test_auth_aes_cmac_cipher_snow_test_case_1(void)
7807 return test_mixed_auth_cipher(
7808 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7812 test_verify_auth_aes_cmac_cipher_snow_test_case_1(void)
7814 return test_mixed_auth_cipher(
7815 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7819 test_auth_zuc_cipher_aes_ctr_test_case_1(void)
7821 return test_mixed_auth_cipher(
7822 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7826 test_verify_auth_zuc_cipher_aes_ctr_test_case_1(void)
7828 return test_mixed_auth_cipher(
7829 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7833 test_auth_snow_cipher_aes_ctr_test_case_1(void)
7835 return test_mixed_auth_cipher(
7836 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7840 test_verify_auth_snow_cipher_aes_ctr_test_case_1(void)
7842 return test_mixed_auth_cipher(
7843 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7847 test_auth_snow_cipher_zuc_test_case_1(void)
7849 return test_mixed_auth_cipher(
7850 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7854 test_verify_auth_snow_cipher_zuc_test_case_1(void)
7856 return test_mixed_auth_cipher(
7857 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7861 test_auth_aes_cmac_cipher_zuc_test_case_1(void)
7863 return test_mixed_auth_cipher(
7864 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7868 test_verify_auth_aes_cmac_cipher_zuc_test_case_1(void)
7870 return test_mixed_auth_cipher(
7871 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7875 test_auth_null_cipher_snow_test_case_1(void)
7877 return test_mixed_auth_cipher(
7878 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7882 test_verify_auth_null_cipher_snow_test_case_1(void)
7884 return test_mixed_auth_cipher(
7885 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7889 test_auth_null_cipher_zuc_test_case_1(void)
7891 return test_mixed_auth_cipher(
7892 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7896 test_verify_auth_null_cipher_zuc_test_case_1(void)
7898 return test_mixed_auth_cipher(
7899 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7903 test_auth_snow_cipher_null_test_case_1(void)
7905 return test_mixed_auth_cipher(
7906 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7910 test_verify_auth_snow_cipher_null_test_case_1(void)
7912 return test_mixed_auth_cipher(
7913 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7917 test_auth_zuc_cipher_null_test_case_1(void)
7919 return test_mixed_auth_cipher(
7920 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7924 test_verify_auth_zuc_cipher_null_test_case_1(void)
7926 return test_mixed_auth_cipher(
7927 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7931 test_auth_null_cipher_aes_ctr_test_case_1(void)
7933 return test_mixed_auth_cipher(
7934 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7938 test_verify_auth_null_cipher_aes_ctr_test_case_1(void)
7940 return test_mixed_auth_cipher(
7941 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7945 test_auth_aes_cmac_cipher_null_test_case_1(void)
7947 return test_mixed_auth_cipher(
7948 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7952 test_verify_auth_aes_cmac_cipher_null_test_case_1(void)
7954 return test_mixed_auth_cipher(
7955 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7958 /* ***** AEAD algorithm Tests ***** */
7961 create_aead_session(uint8_t dev_id, enum rte_crypto_aead_algorithm algo,
7962 enum rte_crypto_aead_operation op,
7963 const uint8_t *key, const uint8_t key_len,
7964 const uint16_t aad_len, const uint8_t auth_len,
7967 uint8_t aead_key[key_len];
7969 struct crypto_testsuite_params *ts_params = &testsuite_params;
7970 struct crypto_unittest_params *ut_params = &unittest_params;
7972 memcpy(aead_key, key, key_len);
7974 /* Setup AEAD Parameters */
7975 ut_params->aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD;
7976 ut_params->aead_xform.next = NULL;
7977 ut_params->aead_xform.aead.algo = algo;
7978 ut_params->aead_xform.aead.op = op;
7979 ut_params->aead_xform.aead.key.data = aead_key;
7980 ut_params->aead_xform.aead.key.length = key_len;
7981 ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
7982 ut_params->aead_xform.aead.iv.length = iv_len;
7983 ut_params->aead_xform.aead.digest_length = auth_len;
7984 ut_params->aead_xform.aead.aad_length = aad_len;
7986 debug_hexdump(stdout, "key:", key, key_len);
7988 /* Create Crypto session*/
7989 ut_params->sess = rte_cryptodev_sym_session_create(
7990 ts_params->session_mpool);
7992 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
7993 &ut_params->aead_xform,
7994 ts_params->session_priv_mpool);
7996 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
8002 create_aead_xform(struct rte_crypto_op *op,
8003 enum rte_crypto_aead_algorithm algo,
8004 enum rte_crypto_aead_operation aead_op,
8005 uint8_t *key, const uint8_t key_len,
8006 const uint8_t aad_len, const uint8_t auth_len,
8009 TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 1),
8010 "failed to allocate space for crypto transform");
8012 struct rte_crypto_sym_op *sym_op = op->sym;
8014 /* Setup AEAD Parameters */
8015 sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_AEAD;
8016 sym_op->xform->next = NULL;
8017 sym_op->xform->aead.algo = algo;
8018 sym_op->xform->aead.op = aead_op;
8019 sym_op->xform->aead.key.data = key;
8020 sym_op->xform->aead.key.length = key_len;
8021 sym_op->xform->aead.iv.offset = IV_OFFSET;
8022 sym_op->xform->aead.iv.length = iv_len;
8023 sym_op->xform->aead.digest_length = auth_len;
8024 sym_op->xform->aead.aad_length = aad_len;
8026 debug_hexdump(stdout, "key:", key, key_len);
8032 create_aead_operation(enum rte_crypto_aead_operation op,
8033 const struct aead_test_data *tdata)
8035 struct crypto_testsuite_params *ts_params = &testsuite_params;
8036 struct crypto_unittest_params *ut_params = &unittest_params;
8038 uint8_t *plaintext, *ciphertext;
8039 unsigned int aad_pad_len, plaintext_pad_len;
8041 /* Generate Crypto op data structure */
8042 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8043 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8044 TEST_ASSERT_NOT_NULL(ut_params->op,
8045 "Failed to allocate symmetric crypto operation struct");
8047 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
8049 /* Append aad data */
8050 if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
8051 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len + 18, 16);
8052 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8054 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
8055 "no room to append aad");
8057 sym_op->aead.aad.phys_addr =
8058 rte_pktmbuf_iova(ut_params->ibuf);
8059 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
8060 memcpy(sym_op->aead.aad.data + 18, tdata->aad.data, tdata->aad.len);
8061 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
8064 /* Append IV at the end of the crypto operation*/
8065 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
8066 uint8_t *, IV_OFFSET);
8068 /* Copy IV 1 byte after the IV pointer, according to the API */
8069 rte_memcpy(iv_ptr + 1, tdata->iv.data, tdata->iv.len);
8070 debug_hexdump(stdout, "iv:", iv_ptr,
8073 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
8074 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8076 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
8077 "no room to append aad");
8079 sym_op->aead.aad.phys_addr =
8080 rte_pktmbuf_iova(ut_params->ibuf);
8081 memcpy(sym_op->aead.aad.data, tdata->aad.data, tdata->aad.len);
8082 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
8085 /* Append IV at the end of the crypto operation*/
8086 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
8087 uint8_t *, IV_OFFSET);
8089 if (tdata->iv.len == 0) {
8090 rte_memcpy(iv_ptr, tdata->iv.data, AES_GCM_J0_LENGTH);
8091 debug_hexdump(stdout, "iv:", iv_ptr,
8094 rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
8095 debug_hexdump(stdout, "iv:", iv_ptr,
8100 /* Append plaintext/ciphertext */
8101 if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
8102 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
8103 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8105 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
8107 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
8108 debug_hexdump(stdout, "plaintext:", plaintext,
8109 tdata->plaintext.len);
8111 if (ut_params->obuf) {
8112 ciphertext = (uint8_t *)rte_pktmbuf_append(
8114 plaintext_pad_len + aad_pad_len);
8115 TEST_ASSERT_NOT_NULL(ciphertext,
8116 "no room to append ciphertext");
8118 memset(ciphertext + aad_pad_len, 0,
8119 tdata->ciphertext.len);
8122 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16);
8123 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8125 TEST_ASSERT_NOT_NULL(ciphertext,
8126 "no room to append ciphertext");
8128 memcpy(ciphertext, tdata->ciphertext.data,
8129 tdata->ciphertext.len);
8130 debug_hexdump(stdout, "ciphertext:", ciphertext,
8131 tdata->ciphertext.len);
8133 if (ut_params->obuf) {
8134 plaintext = (uint8_t *)rte_pktmbuf_append(
8136 plaintext_pad_len + aad_pad_len);
8137 TEST_ASSERT_NOT_NULL(plaintext,
8138 "no room to append plaintext");
8140 memset(plaintext + aad_pad_len, 0,
8141 tdata->plaintext.len);
8145 /* Append digest data */
8146 if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
8147 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
8148 ut_params->obuf ? ut_params->obuf :
8150 tdata->auth_tag.len);
8151 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
8152 "no room to append digest");
8153 memset(sym_op->aead.digest.data, 0, tdata->auth_tag.len);
8154 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
8155 ut_params->obuf ? ut_params->obuf :
8160 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
8161 ut_params->ibuf, tdata->auth_tag.len);
8162 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
8163 "no room to append digest");
8164 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
8166 plaintext_pad_len + aad_pad_len);
8168 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
8169 tdata->auth_tag.len);
8170 debug_hexdump(stdout, "digest:",
8171 sym_op->aead.digest.data,
8172 tdata->auth_tag.len);
8175 sym_op->aead.data.length = tdata->plaintext.len;
8176 sym_op->aead.data.offset = aad_pad_len;
8182 test_authenticated_encryption(const struct aead_test_data *tdata)
8184 struct crypto_testsuite_params *ts_params = &testsuite_params;
8185 struct crypto_unittest_params *ut_params = &unittest_params;
8188 uint8_t *ciphertext, *auth_tag;
8189 uint16_t plaintext_pad_len;
8191 struct rte_cryptodev_info dev_info;
8193 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8194 uint64_t feat_flags = dev_info.feature_flags;
8196 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
8197 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
8198 printf("Device doesn't support RAW data-path APIs.\n");
8199 return TEST_SKIPPED;
8202 /* Verify the capabilities */
8203 struct rte_cryptodev_sym_capability_idx cap_idx;
8204 const struct rte_cryptodev_symmetric_capability *capability;
8205 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
8206 cap_idx.algo.aead = tdata->algo;
8207 capability = rte_cryptodev_sym_capability_get(
8208 ts_params->valid_devs[0], &cap_idx);
8209 if (capability == NULL)
8210 return TEST_SKIPPED;
8211 if (rte_cryptodev_sym_capability_check_aead(
8212 capability, tdata->key.len, tdata->auth_tag.len,
8213 tdata->aad.len, tdata->iv.len))
8214 return TEST_SKIPPED;
8216 /* Create AEAD session */
8217 retval = create_aead_session(ts_params->valid_devs[0],
8219 RTE_CRYPTO_AEAD_OP_ENCRYPT,
8220 tdata->key.data, tdata->key.len,
8221 tdata->aad.len, tdata->auth_tag.len,
8226 if (tdata->aad.len > MBUF_SIZE) {
8227 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
8228 /* Populate full size of add data */
8229 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
8230 memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
8232 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8234 /* clear mbuf payload */
8235 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8236 rte_pktmbuf_tailroom(ut_params->ibuf));
8238 /* Create AEAD operation */
8239 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
8243 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
8245 ut_params->op->sym->m_src = ut_params->ibuf;
8247 /* Process crypto operation */
8248 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
8249 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
8250 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
8251 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
8252 ut_params->op, 0, 0, 0, 0);
8254 TEST_ASSERT_NOT_NULL(
8255 process_crypto_request(ts_params->valid_devs[0],
8256 ut_params->op), "failed to process sym crypto op");
8258 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8259 "crypto op processing failed");
8261 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
8263 if (ut_params->op->sym->m_dst) {
8264 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8266 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
8267 uint8_t *, plaintext_pad_len);
8269 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
8271 ut_params->op->sym->cipher.data.offset);
8272 auth_tag = ciphertext + plaintext_pad_len;
8275 debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
8276 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
8279 TEST_ASSERT_BUFFERS_ARE_EQUAL(
8281 tdata->ciphertext.data,
8282 tdata->ciphertext.len,
8283 "Ciphertext data not as expected");
8285 TEST_ASSERT_BUFFERS_ARE_EQUAL(
8287 tdata->auth_tag.data,
8288 tdata->auth_tag.len,
8289 "Generated auth tag not as expected");
8295 #ifdef RTE_LIB_SECURITY
8297 security_proto_supported(enum rte_security_session_action_type action,
8298 enum rte_security_session_protocol proto)
8300 struct crypto_testsuite_params *ts_params = &testsuite_params;
8302 const struct rte_security_capability *capabilities;
8303 const struct rte_security_capability *capability;
8306 struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8307 rte_cryptodev_get_sec_ctx(
8308 ts_params->valid_devs[0]);
8311 capabilities = rte_security_capabilities_get(ctx);
8313 if (capabilities == NULL)
8316 while ((capability = &capabilities[i++])->action !=
8317 RTE_SECURITY_ACTION_TYPE_NONE) {
8318 if (capability->action == action &&
8319 capability->protocol == proto)
8326 /* Basic algorithm run function for async inplace mode.
8327 * Creates a session from input parameters and runs one operation
8328 * on input_vec. Checks the output of the crypto operation against
8331 static int test_pdcp_proto(int i, int oop, enum rte_crypto_cipher_operation opc,
8332 enum rte_crypto_auth_operation opa,
8333 const uint8_t *input_vec, unsigned int input_vec_len,
8334 const uint8_t *output_vec,
8335 unsigned int output_vec_len,
8336 enum rte_crypto_cipher_algorithm cipher_alg,
8337 const uint8_t *cipher_key, uint32_t cipher_key_len,
8338 enum rte_crypto_auth_algorithm auth_alg,
8339 const uint8_t *auth_key, uint32_t auth_key_len,
8340 uint8_t bearer, enum rte_security_pdcp_domain domain,
8341 uint8_t packet_direction, uint8_t sn_size,
8342 uint32_t hfn, uint32_t hfn_threshold, uint8_t sdap)
8344 struct crypto_testsuite_params *ts_params = &testsuite_params;
8345 struct crypto_unittest_params *ut_params = &unittest_params;
8347 int ret = TEST_SUCCESS;
8348 struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8349 rte_cryptodev_get_sec_ctx(
8350 ts_params->valid_devs[0]);
8352 /* Verify the capabilities */
8353 struct rte_security_capability_idx sec_cap_idx;
8355 sec_cap_idx.action = ut_params->type;
8356 sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
8357 sec_cap_idx.pdcp.domain = domain;
8358 if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
8359 return TEST_SKIPPED;
8361 /* Generate test mbuf data */
8362 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8364 /* clear mbuf payload */
8365 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8366 rte_pktmbuf_tailroom(ut_params->ibuf));
8368 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8370 memcpy(plaintext, input_vec, input_vec_len);
8372 /* Out of place support */
8375 * For out-op-place we need to alloc another mbuf
8377 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8378 rte_pktmbuf_append(ut_params->obuf, output_vec_len);
8381 /* Setup Cipher Parameters */
8382 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8383 ut_params->cipher_xform.cipher.algo = cipher_alg;
8384 ut_params->cipher_xform.cipher.op = opc;
8385 ut_params->cipher_xform.cipher.key.data = cipher_key;
8386 ut_params->cipher_xform.cipher.key.length = cipher_key_len;
8387 ut_params->cipher_xform.cipher.iv.length =
8388 packet_direction ? 4 : 0;
8389 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
8391 /* Setup HMAC Parameters if ICV header is required */
8392 if (auth_alg != 0) {
8393 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8394 ut_params->auth_xform.next = NULL;
8395 ut_params->auth_xform.auth.algo = auth_alg;
8396 ut_params->auth_xform.auth.op = opa;
8397 ut_params->auth_xform.auth.key.data = auth_key;
8398 ut_params->auth_xform.auth.key.length = auth_key_len;
8400 ut_params->cipher_xform.next = &ut_params->auth_xform;
8402 ut_params->cipher_xform.next = NULL;
8405 struct rte_security_session_conf sess_conf = {
8406 .action_type = ut_params->type,
8407 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
8411 .pkt_dir = packet_direction,
8413 .hfn = packet_direction ? 0 : hfn,
8415 * hfn can be set as pdcp_test_hfn[i]
8416 * if hfn_ovrd is not set. Here, PDCP
8417 * packet direction is just used to
8418 * run half of the cases with session
8419 * HFN and other half with per packet
8422 .hfn_threshold = hfn_threshold,
8423 .hfn_ovrd = packet_direction ? 1 : 0,
8424 .sdap_enabled = sdap,
8426 .crypto_xform = &ut_params->cipher_xform
8429 /* Create security session */
8430 ut_params->sec_session = rte_security_session_create(ctx,
8431 &sess_conf, ts_params->session_mpool,
8432 ts_params->session_priv_mpool);
8434 if (!ut_params->sec_session) {
8435 printf("TestCase %s()-%d line %d failed %s: ",
8436 __func__, i, __LINE__, "Failed to allocate session");
8441 /* Generate crypto op data structure */
8442 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8443 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8444 if (!ut_params->op) {
8445 printf("TestCase %s()-%d line %d failed %s: ",
8446 __func__, i, __LINE__,
8447 "Failed to allocate symmetric crypto operation struct");
8452 uint32_t *per_pkt_hfn = rte_crypto_op_ctod_offset(ut_params->op,
8453 uint32_t *, IV_OFFSET);
8454 *per_pkt_hfn = packet_direction ? hfn : 0;
8456 rte_security_attach_session(ut_params->op, ut_params->sec_session);
8458 /* set crypto operation source mbuf */
8459 ut_params->op->sym->m_src = ut_params->ibuf;
8461 ut_params->op->sym->m_dst = ut_params->obuf;
8463 /* Process crypto operation */
8464 if (process_crypto_request(ts_params->valid_devs[0], ut_params->op)
8466 printf("TestCase %s()-%d line %d failed %s: ",
8467 __func__, i, __LINE__,
8468 "failed to process sym crypto op");
8473 if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8474 printf("TestCase %s()-%d line %d failed %s: ",
8475 __func__, i, __LINE__, "crypto op processing failed");
8481 uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
8484 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8488 if (memcmp(ciphertext, output_vec, output_vec_len)) {
8489 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8490 rte_hexdump(stdout, "encrypted", ciphertext, output_vec_len);
8491 rte_hexdump(stdout, "reference", output_vec, output_vec_len);
8497 rte_crypto_op_free(ut_params->op);
8498 ut_params->op = NULL;
8500 if (ut_params->sec_session)
8501 rte_security_session_destroy(ctx, ut_params->sec_session);
8502 ut_params->sec_session = NULL;
8504 rte_pktmbuf_free(ut_params->ibuf);
8505 ut_params->ibuf = NULL;
8507 rte_pktmbuf_free(ut_params->obuf);
8508 ut_params->obuf = NULL;
8515 test_pdcp_proto_SGL(int i, int oop,
8516 enum rte_crypto_cipher_operation opc,
8517 enum rte_crypto_auth_operation opa,
8519 unsigned int input_vec_len,
8520 uint8_t *output_vec,
8521 unsigned int output_vec_len,
8523 uint32_t fragsz_oop)
8525 struct crypto_testsuite_params *ts_params = &testsuite_params;
8526 struct crypto_unittest_params *ut_params = &unittest_params;
8528 struct rte_mbuf *buf, *buf_oop = NULL;
8529 int ret = TEST_SUCCESS;
8533 unsigned int trn_data = 0;
8534 struct rte_cryptodev_info dev_info;
8535 uint64_t feat_flags;
8536 struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8537 rte_cryptodev_get_sec_ctx(
8538 ts_params->valid_devs[0]);
8539 struct rte_mbuf *temp_mbuf;
8541 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8542 feat_flags = dev_info.feature_flags;
8544 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
8545 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
8546 printf("Device does not support RAW data-path APIs.\n");
8549 /* Verify the capabilities */
8550 struct rte_security_capability_idx sec_cap_idx;
8552 sec_cap_idx.action = ut_params->type;
8553 sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
8554 sec_cap_idx.pdcp.domain = pdcp_test_params[i].domain;
8555 if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
8556 return TEST_SKIPPED;
8558 if (fragsz > input_vec_len)
8559 fragsz = input_vec_len;
8561 uint16_t plaintext_len = fragsz;
8562 uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
8564 if (fragsz_oop > output_vec_len)
8565 frag_size_oop = output_vec_len;
8568 if (input_vec_len % fragsz != 0) {
8569 if (input_vec_len / fragsz + 1 > 16)
8571 } else if (input_vec_len / fragsz > 16)
8574 /* Out of place support */
8577 * For out-op-place we need to alloc another mbuf
8579 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8580 rte_pktmbuf_append(ut_params->obuf, frag_size_oop);
8581 buf_oop = ut_params->obuf;
8584 /* Generate test mbuf data */
8585 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8587 /* clear mbuf payload */
8588 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8589 rte_pktmbuf_tailroom(ut_params->ibuf));
8591 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8593 memcpy(plaintext, input_vec, plaintext_len);
8594 trn_data += plaintext_len;
8596 buf = ut_params->ibuf;
8599 * Loop until no more fragments
8602 while (trn_data < input_vec_len) {
8604 to_trn = (input_vec_len - trn_data < fragsz) ?
8605 (input_vec_len - trn_data) : fragsz;
8607 to_trn_tbl[ecx++] = to_trn;
8609 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8612 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
8613 rte_pktmbuf_tailroom(buf));
8616 if (oop && !fragsz_oop) {
8618 rte_pktmbuf_alloc(ts_params->mbuf_pool);
8619 buf_oop = buf_oop->next;
8620 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8621 0, rte_pktmbuf_tailroom(buf_oop));
8622 rte_pktmbuf_append(buf_oop, to_trn);
8625 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
8628 memcpy(plaintext, input_vec + trn_data, to_trn);
8632 ut_params->ibuf->nb_segs = segs;
8635 if (fragsz_oop && oop) {
8639 trn_data = frag_size_oop;
8640 while (trn_data < output_vec_len) {
8643 (output_vec_len - trn_data <
8645 (output_vec_len - trn_data) :
8648 to_trn_tbl[ecx++] = to_trn;
8651 rte_pktmbuf_alloc(ts_params->mbuf_pool);
8652 buf_oop = buf_oop->next;
8653 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8654 0, rte_pktmbuf_tailroom(buf_oop));
8655 rte_pktmbuf_append(buf_oop, to_trn);
8659 ut_params->obuf->nb_segs = segs;
8662 /* Setup Cipher Parameters */
8663 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8664 ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg;
8665 ut_params->cipher_xform.cipher.op = opc;
8666 ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i];
8667 ut_params->cipher_xform.cipher.key.length =
8668 pdcp_test_params[i].cipher_key_len;
8669 ut_params->cipher_xform.cipher.iv.length = 0;
8671 /* Setup HMAC Parameters if ICV header is required */
8672 if (pdcp_test_params[i].auth_alg != 0) {
8673 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8674 ut_params->auth_xform.next = NULL;
8675 ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg;
8676 ut_params->auth_xform.auth.op = opa;
8677 ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i];
8678 ut_params->auth_xform.auth.key.length =
8679 pdcp_test_params[i].auth_key_len;
8681 ut_params->cipher_xform.next = &ut_params->auth_xform;
8683 ut_params->cipher_xform.next = NULL;
8686 struct rte_security_session_conf sess_conf = {
8687 .action_type = ut_params->type,
8688 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
8690 .bearer = pdcp_test_bearer[i],
8691 .domain = pdcp_test_params[i].domain,
8692 .pkt_dir = pdcp_test_packet_direction[i],
8693 .sn_size = pdcp_test_data_sn_size[i],
8694 .hfn = pdcp_test_hfn[i],
8695 .hfn_threshold = pdcp_test_hfn_threshold[i],
8698 .crypto_xform = &ut_params->cipher_xform
8701 /* Create security session */
8702 ut_params->sec_session = rte_security_session_create(ctx,
8703 &sess_conf, ts_params->session_mpool,
8704 ts_params->session_priv_mpool);
8706 if (!ut_params->sec_session) {
8707 printf("TestCase %s()-%d line %d failed %s: ",
8708 __func__, i, __LINE__, "Failed to allocate session");
8713 /* Generate crypto op data structure */
8714 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8715 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8716 if (!ut_params->op) {
8717 printf("TestCase %s()-%d line %d failed %s: ",
8718 __func__, i, __LINE__,
8719 "Failed to allocate symmetric crypto operation struct");
8724 rte_security_attach_session(ut_params->op, ut_params->sec_session);
8726 /* set crypto operation source mbuf */
8727 ut_params->op->sym->m_src = ut_params->ibuf;
8729 ut_params->op->sym->m_dst = ut_params->obuf;
8731 /* Process crypto operation */
8732 temp_mbuf = ut_params->op->sym->m_src;
8733 if (global_api_test_type == CRYPTODEV_RAW_API_TEST) {
8734 /* filling lengths */
8736 ut_params->op->sym->cipher.data.length
8737 += temp_mbuf->pkt_len;
8738 ut_params->op->sym->auth.data.length
8739 += temp_mbuf->pkt_len;
8740 temp_mbuf = temp_mbuf->next;
8742 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
8743 ut_params->op, 1, 1, 0, 0);
8745 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
8748 if (ut_params->op == NULL) {
8749 printf("TestCase %s()-%d line %d failed %s: ",
8750 __func__, i, __LINE__,
8751 "failed to process sym crypto op");
8756 if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8757 printf("TestCase %s()-%d line %d failed %s: ",
8758 __func__, i, __LINE__, "crypto op processing failed");
8764 uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
8767 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8771 fragsz = frag_size_oop;
8772 if (memcmp(ciphertext, output_vec, fragsz)) {
8773 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8774 rte_hexdump(stdout, "encrypted", ciphertext, fragsz);
8775 rte_hexdump(stdout, "reference", output_vec, fragsz);
8780 buf = ut_params->op->sym->m_src->next;
8782 buf = ut_params->op->sym->m_dst->next;
8784 unsigned int off = fragsz;
8788 ciphertext = rte_pktmbuf_mtod(buf,
8790 if (memcmp(ciphertext, output_vec + off, to_trn_tbl[ecx])) {
8791 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8792 rte_hexdump(stdout, "encrypted", ciphertext, to_trn_tbl[ecx]);
8793 rte_hexdump(stdout, "reference", output_vec + off,
8798 off += to_trn_tbl[ecx++];
8802 rte_crypto_op_free(ut_params->op);
8803 ut_params->op = NULL;
8805 if (ut_params->sec_session)
8806 rte_security_session_destroy(ctx, ut_params->sec_session);
8807 ut_params->sec_session = NULL;
8809 rte_pktmbuf_free(ut_params->ibuf);
8810 ut_params->ibuf = NULL;
8812 rte_pktmbuf_free(ut_params->obuf);
8813 ut_params->obuf = NULL;
8820 test_pdcp_proto_cplane_encap(int i)
8822 return test_pdcp_proto(
8823 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8824 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8825 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8826 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8827 pdcp_test_params[i].cipher_key_len,
8828 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8829 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8830 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8831 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8832 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8836 test_pdcp_proto_uplane_encap(int i)
8838 return test_pdcp_proto(
8839 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8840 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8841 pdcp_test_data_out[i], pdcp_test_data_in_len[i],
8842 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8843 pdcp_test_params[i].cipher_key_len,
8844 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8845 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8846 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8847 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8848 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8852 test_pdcp_proto_uplane_encap_with_int(int i)
8854 return test_pdcp_proto(
8855 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8856 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8857 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8858 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8859 pdcp_test_params[i].cipher_key_len,
8860 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8861 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8862 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8863 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8864 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8868 test_pdcp_proto_cplane_decap(int i)
8870 return test_pdcp_proto(
8871 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8872 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8873 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8874 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8875 pdcp_test_params[i].cipher_key_len,
8876 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8877 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8878 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8879 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8880 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8884 test_pdcp_proto_uplane_decap(int i)
8886 return test_pdcp_proto(
8887 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8888 pdcp_test_data_out[i], pdcp_test_data_in_len[i],
8889 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8890 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8891 pdcp_test_params[i].cipher_key_len,
8892 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8893 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8894 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8895 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8896 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8900 test_pdcp_proto_uplane_decap_with_int(int i)
8902 return test_pdcp_proto(
8903 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8904 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8905 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8906 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8907 pdcp_test_params[i].cipher_key_len,
8908 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8909 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8910 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8911 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8912 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8916 test_PDCP_PROTO_SGL_in_place_32B(void)
8918 /* i can be used for running any PDCP case
8919 * In this case it is uplane 12-bit AES-SNOW DL encap
8921 int i = PDCP_UPLANE_12BIT_OFFSET + AES_ENC + SNOW_AUTH + DOWNLINK;
8922 return test_pdcp_proto_SGL(i, IN_PLACE,
8923 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8924 RTE_CRYPTO_AUTH_OP_GENERATE,
8925 pdcp_test_data_in[i],
8926 pdcp_test_data_in_len[i],
8927 pdcp_test_data_out[i],
8928 pdcp_test_data_in_len[i]+4,
8932 test_PDCP_PROTO_SGL_oop_32B_128B(void)
8934 /* i can be used for running any PDCP case
8935 * In this case it is uplane 18-bit NULL-NULL DL encap
8937 int i = PDCP_UPLANE_18BIT_OFFSET + NULL_ENC + NULL_AUTH + DOWNLINK;
8938 return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8939 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8940 RTE_CRYPTO_AUTH_OP_GENERATE,
8941 pdcp_test_data_in[i],
8942 pdcp_test_data_in_len[i],
8943 pdcp_test_data_out[i],
8944 pdcp_test_data_in_len[i]+4,
8948 test_PDCP_PROTO_SGL_oop_32B_40B(void)
8950 /* i can be used for running any PDCP case
8951 * In this case it is uplane 18-bit AES DL encap
8953 int i = PDCP_UPLANE_OFFSET + AES_ENC + EIGHTEEN_BIT_SEQ_NUM_OFFSET
8955 return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8956 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8957 RTE_CRYPTO_AUTH_OP_GENERATE,
8958 pdcp_test_data_in[i],
8959 pdcp_test_data_in_len[i],
8960 pdcp_test_data_out[i],
8961 pdcp_test_data_in_len[i],
8965 test_PDCP_PROTO_SGL_oop_128B_32B(void)
8967 /* i can be used for running any PDCP case
8968 * In this case it is cplane 12-bit AES-ZUC DL encap
8970 int i = PDCP_CPLANE_LONG_SN_OFFSET + AES_ENC + ZUC_AUTH + DOWNLINK;
8971 return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8972 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8973 RTE_CRYPTO_AUTH_OP_GENERATE,
8974 pdcp_test_data_in[i],
8975 pdcp_test_data_in_len[i],
8976 pdcp_test_data_out[i],
8977 pdcp_test_data_in_len[i]+4,
8982 test_PDCP_SDAP_PROTO_encap_all(void)
8984 int i = 0, size = 0;
8985 int err, all_err = TEST_SUCCESS;
8986 const struct pdcp_sdap_test *cur_test;
8988 size = RTE_DIM(list_pdcp_sdap_tests);
8990 for (i = 0; i < size; i++) {
8991 cur_test = &list_pdcp_sdap_tests[i];
8992 err = test_pdcp_proto(
8993 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8994 RTE_CRYPTO_AUTH_OP_GENERATE, cur_test->data_in,
8995 cur_test->in_len, cur_test->data_out,
8996 cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
8997 cur_test->param.cipher_alg, cur_test->cipher_key,
8998 cur_test->param.cipher_key_len,
8999 cur_test->param.auth_alg,
9000 cur_test->auth_key, cur_test->param.auth_key_len,
9001 cur_test->bearer, cur_test->param.domain,
9002 cur_test->packet_direction, cur_test->sn_size,
9004 cur_test->hfn_threshold, SDAP_ENABLED);
9006 printf("\t%d) %s: Encapsulation failed\n",
9008 cur_test->param.name);
9011 printf("\t%d) %s: Encap PASS\n", cur_test->test_idx,
9012 cur_test->param.name);
9018 printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
9020 return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
9024 test_PDCP_PROTO_short_mac(void)
9026 int i = 0, size = 0;
9027 int err, all_err = TEST_SUCCESS;
9028 const struct pdcp_short_mac_test *cur_test;
9030 size = RTE_DIM(list_pdcp_smac_tests);
9032 for (i = 0; i < size; i++) {
9033 cur_test = &list_pdcp_smac_tests[i];
9034 err = test_pdcp_proto(
9035 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT,
9036 RTE_CRYPTO_AUTH_OP_GENERATE, cur_test->data_in,
9037 cur_test->in_len, cur_test->data_out,
9038 cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
9039 RTE_CRYPTO_CIPHER_NULL, NULL,
9040 0, cur_test->param.auth_alg,
9041 cur_test->auth_key, cur_test->param.auth_key_len,
9042 0, cur_test->param.domain, 0, 0,
9045 printf("\t%d) %s: Short MAC test failed\n",
9047 cur_test->param.name);
9050 printf("\t%d) %s: Short MAC test PASS\n",
9052 cur_test->param.name);
9053 rte_hexdump(stdout, "MAC I",
9054 cur_test->data_out + cur_test->in_len + 2,
9061 printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
9063 return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
9068 test_PDCP_SDAP_PROTO_decap_all(void)
9070 int i = 0, size = 0;
9071 int err, all_err = TEST_SUCCESS;
9072 const struct pdcp_sdap_test *cur_test;
9074 size = RTE_DIM(list_pdcp_sdap_tests);
9076 for (i = 0; i < size; i++) {
9077 cur_test = &list_pdcp_sdap_tests[i];
9078 err = test_pdcp_proto(
9079 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT,
9080 RTE_CRYPTO_AUTH_OP_VERIFY,
9082 cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
9083 cur_test->data_in, cur_test->in_len,
9084 cur_test->param.cipher_alg,
9085 cur_test->cipher_key, cur_test->param.cipher_key_len,
9086 cur_test->param.auth_alg, cur_test->auth_key,
9087 cur_test->param.auth_key_len, cur_test->bearer,
9088 cur_test->param.domain, cur_test->packet_direction,
9089 cur_test->sn_size, cur_test->hfn,
9090 cur_test->hfn_threshold, SDAP_ENABLED);
9092 printf("\t%d) %s: Decapsulation failed\n",
9094 cur_test->param.name);
9097 printf("\t%d) %s: Decap PASS\n", cur_test->test_idx,
9098 cur_test->param.name);
9104 printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
9106 return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
9110 test_ipsec_proto_process(const struct ipsec_test_data td[],
9111 struct ipsec_test_data res_d[],
9114 const struct ipsec_test_flags *flags)
9116 struct crypto_testsuite_params *ts_params = &testsuite_params;
9117 struct crypto_unittest_params *ut_params = &unittest_params;
9118 struct rte_security_capability_idx sec_cap_idx;
9119 const struct rte_security_capability *sec_cap;
9120 struct rte_security_ipsec_xform ipsec_xform;
9121 uint8_t dev_id = ts_params->valid_devs[0];
9122 enum rte_security_ipsec_sa_direction dir;
9123 struct ipsec_test_data *res_d_tmp = NULL;
9124 uint32_t src = RTE_IPV4(192, 168, 1, 0);
9125 uint32_t dst = RTE_IPV4(192, 168, 1, 1);
9126 int salt_len, i, ret = TEST_SUCCESS;
9127 struct rte_security_ctx *ctx;
9128 uint8_t *input_text;
9131 ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
9132 gbl_action_type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
9134 /* Use first test data to create session */
9136 /* Copy IPsec xform */
9137 memcpy(&ipsec_xform, &td[0].ipsec_xform, sizeof(ipsec_xform));
9139 dir = ipsec_xform.direction;
9140 verify = flags->tunnel_hdr_verify;
9142 if ((dir == RTE_SECURITY_IPSEC_SA_DIR_INGRESS) && verify) {
9143 if (verify == RTE_SECURITY_IPSEC_TUNNEL_VERIFY_SRC_DST_ADDR)
9145 else if (verify == RTE_SECURITY_IPSEC_TUNNEL_VERIFY_DST_ADDR)
9149 memcpy(&ipsec_xform.tunnel.ipv4.src_ip, &src, sizeof(src));
9150 memcpy(&ipsec_xform.tunnel.ipv4.dst_ip, &dst, sizeof(dst));
9152 ctx = rte_cryptodev_get_sec_ctx(dev_id);
9154 sec_cap_idx.action = ut_params->type;
9155 sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_IPSEC;
9156 sec_cap_idx.ipsec.proto = ipsec_xform.proto;
9157 sec_cap_idx.ipsec.mode = ipsec_xform.mode;
9158 sec_cap_idx.ipsec.direction = ipsec_xform.direction;
9160 if (flags->udp_encap)
9161 ipsec_xform.options.udp_encap = 1;
9163 sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
9164 if (sec_cap == NULL)
9165 return TEST_SKIPPED;
9167 /* Copy cipher session parameters */
9169 memcpy(&ut_params->aead_xform, &td[0].xform.aead,
9170 sizeof(ut_params->aead_xform));
9171 ut_params->aead_xform.aead.key.data = td[0].key.data;
9172 ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
9174 /* Verify crypto capabilities */
9175 if (test_ipsec_crypto_caps_aead_verify(
9177 &ut_params->aead_xform) != 0) {
9179 RTE_LOG(INFO, USER1,
9180 "Crypto capabilities not supported\n");
9181 return TEST_SKIPPED;
9184 /* Only AEAD supported now */
9185 return TEST_SKIPPED;
9188 if (test_ipsec_sec_caps_verify(&ipsec_xform, sec_cap, silent) != 0)
9189 return TEST_SKIPPED;
9191 salt_len = RTE_MIN(sizeof(ipsec_xform.salt), td[0].salt.len);
9192 memcpy(&ipsec_xform.salt, td[0].salt.data, salt_len);
9194 struct rte_security_session_conf sess_conf = {
9195 .action_type = ut_params->type,
9196 .protocol = RTE_SECURITY_PROTOCOL_IPSEC,
9197 .ipsec = ipsec_xform,
9198 .crypto_xform = &ut_params->aead_xform,
9201 /* Create security session */
9202 ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
9203 ts_params->session_mpool,
9204 ts_params->session_priv_mpool);
9206 if (ut_params->sec_session == NULL)
9207 return TEST_SKIPPED;
9209 for (i = 0; i < nb_td; i++) {
9210 /* Setup source mbuf payload */
9211 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9212 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9213 rte_pktmbuf_tailroom(ut_params->ibuf));
9215 input_text = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9216 td[i].input_text.len);
9218 memcpy(input_text, td[i].input_text.data,
9219 td[i].input_text.len);
9221 /* Generate crypto op data structure */
9222 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9223 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9224 if (!ut_params->op) {
9225 printf("TestCase %s line %d: %s\n",
9227 "failed to allocate crypto op");
9229 goto crypto_op_free;
9232 /* Attach session to operation */
9233 rte_security_attach_session(ut_params->op,
9234 ut_params->sec_session);
9236 /* Set crypto operation mbufs */
9237 ut_params->op->sym->m_src = ut_params->ibuf;
9238 ut_params->op->sym->m_dst = NULL;
9240 /* Copy IV in crypto operation when IV generation is disabled */
9241 if (dir == RTE_SECURITY_IPSEC_SA_DIR_EGRESS &&
9242 ipsec_xform.options.iv_gen_disable == 1) {
9243 uint8_t *iv = rte_crypto_op_ctod_offset(ut_params->op,
9249 len = td[i].xform.aead.aead.iv.length;
9251 len = td[i].xform.chain.cipher.cipher.iv.length;
9253 memcpy(iv, td[i].iv.data, len);
9256 /* Process crypto operation */
9257 process_crypto_request(dev_id, ut_params->op);
9259 ret = test_ipsec_status_check(ut_params->op, flags, dir, i + 1);
9260 if (ret != TEST_SUCCESS)
9261 goto crypto_op_free;
9264 res_d_tmp = &res_d[i];
9266 ret = test_ipsec_post_process(ut_params->ibuf, &td[i],
9267 res_d_tmp, silent, flags);
9268 if (ret != TEST_SUCCESS)
9269 goto crypto_op_free;
9271 rte_crypto_op_free(ut_params->op);
9272 ut_params->op = NULL;
9274 rte_pktmbuf_free(ut_params->ibuf);
9275 ut_params->ibuf = NULL;
9279 rte_crypto_op_free(ut_params->op);
9280 ut_params->op = NULL;
9282 rte_pktmbuf_free(ut_params->ibuf);
9283 ut_params->ibuf = NULL;
9285 if (ut_params->sec_session)
9286 rte_security_session_destroy(ctx, ut_params->sec_session);
9287 ut_params->sec_session = NULL;
9293 test_ipsec_proto_known_vec(const void *test_data)
9295 struct ipsec_test_data td_outb;
9296 struct ipsec_test_flags flags;
9298 memset(&flags, 0, sizeof(flags));
9300 memcpy(&td_outb, test_data, sizeof(td_outb));
9302 /* Disable IV gen to be able to test with known vectors */
9303 td_outb.ipsec_xform.options.iv_gen_disable = 1;
9305 return test_ipsec_proto_process(&td_outb, NULL, 1, false, &flags);
9309 test_ipsec_proto_known_vec_inb(const void *td_outb)
9311 struct ipsec_test_flags flags;
9312 struct ipsec_test_data td_inb;
9314 memset(&flags, 0, sizeof(flags));
9316 test_ipsec_td_in_from_out(td_outb, &td_inb);
9318 return test_ipsec_proto_process(&td_inb, NULL, 1, false, &flags);
9322 test_ipsec_proto_all(const struct ipsec_test_flags *flags)
9324 struct ipsec_test_data td_outb[IPSEC_TEST_PACKETS_MAX];
9325 struct ipsec_test_data td_inb[IPSEC_TEST_PACKETS_MAX];
9326 unsigned int i, nb_pkts = 1, pass_cnt = 0;
9329 if (flags->iv_gen ||
9330 flags->sa_expiry_pkts_soft ||
9331 flags->sa_expiry_pkts_hard)
9332 nb_pkts = IPSEC_TEST_PACKETS_MAX;
9334 for (i = 0; i < RTE_DIM(aead_list); i++) {
9335 test_ipsec_td_prepare(&aead_list[i],
9341 ret = test_ipsec_proto_process(td_outb, td_inb, nb_pkts, true,
9343 if (ret == TEST_SKIPPED)
9346 if (ret == TEST_FAILED)
9349 test_ipsec_td_update(td_inb, td_outb, nb_pkts, flags);
9351 ret = test_ipsec_proto_process(td_inb, NULL, nb_pkts, true,
9353 if (ret == TEST_SKIPPED)
9356 if (ret == TEST_FAILED)
9359 if (flags->display_alg)
9360 test_ipsec_display_alg(&aead_list[i], NULL);
9366 return TEST_SUCCESS;
9368 return TEST_SKIPPED;
9372 test_ipsec_proto_display_list(const void *data __rte_unused)
9374 struct ipsec_test_flags flags;
9376 memset(&flags, 0, sizeof(flags));
9378 flags.display_alg = true;
9380 return test_ipsec_proto_all(&flags);
9384 test_ipsec_proto_iv_gen(const void *data __rte_unused)
9386 struct ipsec_test_flags flags;
9388 memset(&flags, 0, sizeof(flags));
9390 flags.iv_gen = true;
9392 return test_ipsec_proto_all(&flags);
9396 test_ipsec_proto_sa_exp_pkts_soft(const void *data __rte_unused)
9398 struct ipsec_test_flags flags;
9400 memset(&flags, 0, sizeof(flags));
9402 flags.sa_expiry_pkts_soft = true;
9404 return test_ipsec_proto_all(&flags);
9408 test_ipsec_proto_sa_exp_pkts_hard(const void *data __rte_unused)
9410 struct ipsec_test_flags flags;
9412 memset(&flags, 0, sizeof(flags));
9414 flags.sa_expiry_pkts_hard = true;
9416 return test_ipsec_proto_all(&flags);
9420 test_ipsec_proto_err_icv_corrupt(const void *data __rte_unused)
9422 struct ipsec_test_flags flags;
9424 memset(&flags, 0, sizeof(flags));
9426 flags.icv_corrupt = true;
9428 return test_ipsec_proto_all(&flags);
9432 test_ipsec_proto_udp_encap(const void *data __rte_unused)
9434 struct ipsec_test_flags flags;
9436 memset(&flags, 0, sizeof(flags));
9438 flags.udp_encap = true;
9440 return test_ipsec_proto_all(&flags);
9444 test_ipsec_proto_tunnel_src_dst_addr_verify(const void *data __rte_unused)
9446 struct ipsec_test_flags flags;
9448 memset(&flags, 0, sizeof(flags));
9450 flags.tunnel_hdr_verify = RTE_SECURITY_IPSEC_TUNNEL_VERIFY_SRC_DST_ADDR;
9452 return test_ipsec_proto_all(&flags);
9456 test_ipsec_proto_tunnel_dst_addr_verify(const void *data __rte_unused)
9458 struct ipsec_test_flags flags;
9460 memset(&flags, 0, sizeof(flags));
9462 flags.tunnel_hdr_verify = RTE_SECURITY_IPSEC_TUNNEL_VERIFY_DST_ADDR;
9464 return test_ipsec_proto_all(&flags);
9468 test_ipsec_proto_udp_ports_verify(const void *data __rte_unused)
9470 struct ipsec_test_flags flags;
9472 memset(&flags, 0, sizeof(flags));
9474 flags.udp_encap = true;
9475 flags.udp_ports_verify = true;
9477 return test_ipsec_proto_all(&flags);
9481 test_ipsec_proto_inner_ip_csum(const void *data __rte_unused)
9483 struct ipsec_test_flags flags;
9485 memset(&flags, 0, sizeof(flags));
9487 flags.ip_csum = true;
9489 return test_ipsec_proto_all(&flags);
9493 test_ipsec_proto_inner_l4_csum(const void *data __rte_unused)
9495 struct ipsec_test_flags flags;
9497 memset(&flags, 0, sizeof(flags));
9499 flags.l4_csum = true;
9501 return test_ipsec_proto_all(&flags);
9505 test_PDCP_PROTO_all(void)
9507 struct crypto_testsuite_params *ts_params = &testsuite_params;
9508 struct crypto_unittest_params *ut_params = &unittest_params;
9509 struct rte_cryptodev_info dev_info;
9512 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
9513 uint64_t feat_flags = dev_info.feature_flags;
9515 if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY))
9516 return TEST_SKIPPED;
9518 /* Set action type */
9519 ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
9520 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
9523 if (security_proto_supported(ut_params->type,
9524 RTE_SECURITY_PROTOCOL_PDCP) < 0)
9525 return TEST_SKIPPED;
9527 status = test_PDCP_PROTO_cplane_encap_all();
9528 status += test_PDCP_PROTO_cplane_decap_all();
9529 status += test_PDCP_PROTO_uplane_encap_all();
9530 status += test_PDCP_PROTO_uplane_decap_all();
9531 status += test_PDCP_PROTO_SGL_in_place_32B();
9532 status += test_PDCP_PROTO_SGL_oop_32B_128B();
9533 status += test_PDCP_PROTO_SGL_oop_32B_40B();
9534 status += test_PDCP_PROTO_SGL_oop_128B_32B();
9535 status += test_PDCP_SDAP_PROTO_encap_all();
9536 status += test_PDCP_SDAP_PROTO_decap_all();
9537 status += test_PDCP_PROTO_short_mac();
9542 return TEST_SUCCESS;
9546 test_docsis_proto_uplink(const void *data)
9548 const struct docsis_test_data *d_td = data;
9549 struct crypto_testsuite_params *ts_params = &testsuite_params;
9550 struct crypto_unittest_params *ut_params = &unittest_params;
9551 uint8_t *plaintext = NULL;
9552 uint8_t *ciphertext = NULL;
9554 int32_t cipher_len, crc_len;
9555 uint32_t crc_data_len;
9556 int ret = TEST_SUCCESS;
9558 struct rte_security_ctx *ctx = (struct rte_security_ctx *)
9559 rte_cryptodev_get_sec_ctx(
9560 ts_params->valid_devs[0]);
9562 /* Verify the capabilities */
9563 struct rte_security_capability_idx sec_cap_idx;
9564 const struct rte_security_capability *sec_cap;
9565 const struct rte_cryptodev_capabilities *crypto_cap;
9566 const struct rte_cryptodev_symmetric_capability *sym_cap;
9569 /* Set action type */
9570 ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
9571 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
9574 if (security_proto_supported(ut_params->type,
9575 RTE_SECURITY_PROTOCOL_DOCSIS) < 0)
9576 return TEST_SKIPPED;
9578 sec_cap_idx.action = ut_params->type;
9579 sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
9580 sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_UPLINK;
9582 sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
9583 if (sec_cap == NULL)
9584 return TEST_SKIPPED;
9586 while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
9587 RTE_CRYPTO_OP_TYPE_UNDEFINED) {
9588 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
9589 crypto_cap->sym.xform_type ==
9590 RTE_CRYPTO_SYM_XFORM_CIPHER &&
9591 crypto_cap->sym.cipher.algo ==
9592 RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
9593 sym_cap = &crypto_cap->sym;
9594 if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
9601 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
9602 return TEST_SKIPPED;
9604 /* Setup source mbuf payload */
9605 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9606 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9607 rte_pktmbuf_tailroom(ut_params->ibuf));
9609 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9610 d_td->ciphertext.len);
9612 memcpy(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len);
9614 /* Setup cipher session parameters */
9615 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
9616 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
9617 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
9618 ut_params->cipher_xform.cipher.key.data = d_td->key.data;
9619 ut_params->cipher_xform.cipher.key.length = d_td->key.len;
9620 ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
9621 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
9622 ut_params->cipher_xform.next = NULL;
9624 /* Setup DOCSIS session parameters */
9625 ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_UPLINK;
9627 struct rte_security_session_conf sess_conf = {
9628 .action_type = ut_params->type,
9629 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
9630 .docsis = ut_params->docsis_xform,
9631 .crypto_xform = &ut_params->cipher_xform,
9634 /* Create security session */
9635 ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
9636 ts_params->session_mpool,
9637 ts_params->session_priv_mpool);
9639 if (!ut_params->sec_session) {
9640 printf("Test function %s line %u: failed to allocate session\n",
9641 __func__, __LINE__);
9646 /* Generate crypto op data structure */
9647 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9648 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9649 if (!ut_params->op) {
9650 printf("Test function %s line %u: failed to allocate symmetric "
9651 "crypto operation\n", __func__, __LINE__);
9656 /* Setup CRC operation parameters */
9657 crc_len = d_td->ciphertext.no_crc == false ?
9658 (d_td->ciphertext.len -
9659 d_td->ciphertext.crc_offset -
9660 RTE_ETHER_CRC_LEN) :
9662 crc_len = crc_len > 0 ? crc_len : 0;
9663 crc_data_len = crc_len == 0 ? 0 : RTE_ETHER_CRC_LEN;
9664 ut_params->op->sym->auth.data.length = crc_len;
9665 ut_params->op->sym->auth.data.offset = d_td->ciphertext.crc_offset;
9667 /* Setup cipher operation parameters */
9668 cipher_len = d_td->ciphertext.no_cipher == false ?
9669 (d_td->ciphertext.len -
9670 d_td->ciphertext.cipher_offset) :
9672 cipher_len = cipher_len > 0 ? cipher_len : 0;
9673 ut_params->op->sym->cipher.data.length = cipher_len;
9674 ut_params->op->sym->cipher.data.offset = d_td->ciphertext.cipher_offset;
9676 /* Setup cipher IV */
9677 iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
9678 rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
9680 /* Attach session to operation */
9681 rte_security_attach_session(ut_params->op, ut_params->sec_session);
9683 /* Set crypto operation mbufs */
9684 ut_params->op->sym->m_src = ut_params->ibuf;
9685 ut_params->op->sym->m_dst = NULL;
9687 /* Process crypto operation */
9688 if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
9690 printf("Test function %s line %u: failed to process security "
9691 "crypto op\n", __func__, __LINE__);
9696 if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
9697 printf("Test function %s line %u: failed to process crypto op\n",
9698 __func__, __LINE__);
9703 /* Validate plaintext */
9704 plaintext = ciphertext;
9706 if (memcmp(plaintext, d_td->plaintext.data,
9707 d_td->plaintext.len - crc_data_len)) {
9708 printf("Test function %s line %u: plaintext not as expected\n",
9709 __func__, __LINE__);
9710 rte_hexdump(stdout, "expected", d_td->plaintext.data,
9711 d_td->plaintext.len);
9712 rte_hexdump(stdout, "actual", plaintext, d_td->plaintext.len);
9718 rte_crypto_op_free(ut_params->op);
9719 ut_params->op = NULL;
9721 if (ut_params->sec_session)
9722 rte_security_session_destroy(ctx, ut_params->sec_session);
9723 ut_params->sec_session = NULL;
9725 rte_pktmbuf_free(ut_params->ibuf);
9726 ut_params->ibuf = NULL;
9732 test_docsis_proto_downlink(const void *data)
9734 const struct docsis_test_data *d_td = data;
9735 struct crypto_testsuite_params *ts_params = &testsuite_params;
9736 struct crypto_unittest_params *ut_params = &unittest_params;
9737 uint8_t *plaintext = NULL;
9738 uint8_t *ciphertext = NULL;
9740 int32_t cipher_len, crc_len;
9741 int ret = TEST_SUCCESS;
9743 struct rte_security_ctx *ctx = (struct rte_security_ctx *)
9744 rte_cryptodev_get_sec_ctx(
9745 ts_params->valid_devs[0]);
9747 /* Verify the capabilities */
9748 struct rte_security_capability_idx sec_cap_idx;
9749 const struct rte_security_capability *sec_cap;
9750 const struct rte_cryptodev_capabilities *crypto_cap;
9751 const struct rte_cryptodev_symmetric_capability *sym_cap;
9754 /* Set action type */
9755 ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
9756 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
9759 if (security_proto_supported(ut_params->type,
9760 RTE_SECURITY_PROTOCOL_DOCSIS) < 0)
9761 return TEST_SKIPPED;
9763 sec_cap_idx.action = ut_params->type;
9764 sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
9765 sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
9767 sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
9768 if (sec_cap == NULL)
9769 return TEST_SKIPPED;
9771 while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
9772 RTE_CRYPTO_OP_TYPE_UNDEFINED) {
9773 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
9774 crypto_cap->sym.xform_type ==
9775 RTE_CRYPTO_SYM_XFORM_CIPHER &&
9776 crypto_cap->sym.cipher.algo ==
9777 RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
9778 sym_cap = &crypto_cap->sym;
9779 if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
9786 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
9787 return TEST_SKIPPED;
9789 /* Setup source mbuf payload */
9790 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9791 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9792 rte_pktmbuf_tailroom(ut_params->ibuf));
9794 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9795 d_td->plaintext.len);
9797 memcpy(plaintext, d_td->plaintext.data, d_td->plaintext.len);
9799 /* Setup cipher session parameters */
9800 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
9801 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
9802 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
9803 ut_params->cipher_xform.cipher.key.data = d_td->key.data;
9804 ut_params->cipher_xform.cipher.key.length = d_td->key.len;
9805 ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
9806 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
9807 ut_params->cipher_xform.next = NULL;
9809 /* Setup DOCSIS session parameters */
9810 ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
9812 struct rte_security_session_conf sess_conf = {
9813 .action_type = ut_params->type,
9814 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
9815 .docsis = ut_params->docsis_xform,
9816 .crypto_xform = &ut_params->cipher_xform,
9819 /* Create security session */
9820 ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
9821 ts_params->session_mpool,
9822 ts_params->session_priv_mpool);
9824 if (!ut_params->sec_session) {
9825 printf("Test function %s line %u: failed to allocate session\n",
9826 __func__, __LINE__);
9831 /* Generate crypto op data structure */
9832 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9833 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9834 if (!ut_params->op) {
9835 printf("Test function %s line %u: failed to allocate symmetric "
9836 "crypto operation\n", __func__, __LINE__);
9841 /* Setup CRC operation parameters */
9842 crc_len = d_td->plaintext.no_crc == false ?
9843 (d_td->plaintext.len -
9844 d_td->plaintext.crc_offset -
9845 RTE_ETHER_CRC_LEN) :
9847 crc_len = crc_len > 0 ? crc_len : 0;
9848 ut_params->op->sym->auth.data.length = crc_len;
9849 ut_params->op->sym->auth.data.offset = d_td->plaintext.crc_offset;
9851 /* Setup cipher operation parameters */
9852 cipher_len = d_td->plaintext.no_cipher == false ?
9853 (d_td->plaintext.len -
9854 d_td->plaintext.cipher_offset) :
9856 cipher_len = cipher_len > 0 ? cipher_len : 0;
9857 ut_params->op->sym->cipher.data.length = cipher_len;
9858 ut_params->op->sym->cipher.data.offset = d_td->plaintext.cipher_offset;
9860 /* Setup cipher IV */
9861 iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
9862 rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
9864 /* Attach session to operation */
9865 rte_security_attach_session(ut_params->op, ut_params->sec_session);
9867 /* Set crypto operation mbufs */
9868 ut_params->op->sym->m_src = ut_params->ibuf;
9869 ut_params->op->sym->m_dst = NULL;
9871 /* Process crypto operation */
9872 if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
9874 printf("Test function %s line %u: failed to process crypto op\n",
9875 __func__, __LINE__);
9880 if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
9881 printf("Test function %s line %u: crypto op processing failed\n",
9882 __func__, __LINE__);
9887 /* Validate ciphertext */
9888 ciphertext = plaintext;
9890 if (memcmp(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len)) {
9891 printf("Test function %s line %u: plaintext not as expected\n",
9892 __func__, __LINE__);
9893 rte_hexdump(stdout, "expected", d_td->ciphertext.data,
9894 d_td->ciphertext.len);
9895 rte_hexdump(stdout, "actual", ciphertext, d_td->ciphertext.len);
9901 rte_crypto_op_free(ut_params->op);
9902 ut_params->op = NULL;
9904 if (ut_params->sec_session)
9905 rte_security_session_destroy(ctx, ut_params->sec_session);
9906 ut_params->sec_session = NULL;
9908 rte_pktmbuf_free(ut_params->ibuf);
9909 ut_params->ibuf = NULL;
9916 test_AES_GCM_authenticated_encryption_test_case_1(void)
9918 return test_authenticated_encryption(&gcm_test_case_1);
9922 test_AES_GCM_authenticated_encryption_test_case_2(void)
9924 return test_authenticated_encryption(&gcm_test_case_2);
9928 test_AES_GCM_authenticated_encryption_test_case_3(void)
9930 return test_authenticated_encryption(&gcm_test_case_3);
9934 test_AES_GCM_authenticated_encryption_test_case_4(void)
9936 return test_authenticated_encryption(&gcm_test_case_4);
9940 test_AES_GCM_authenticated_encryption_test_case_5(void)
9942 return test_authenticated_encryption(&gcm_test_case_5);
9946 test_AES_GCM_authenticated_encryption_test_case_6(void)
9948 return test_authenticated_encryption(&gcm_test_case_6);
9952 test_AES_GCM_authenticated_encryption_test_case_7(void)
9954 return test_authenticated_encryption(&gcm_test_case_7);
9958 test_AES_GCM_authenticated_encryption_test_case_8(void)
9960 return test_authenticated_encryption(&gcm_test_case_8);
9964 test_AES_GCM_J0_authenticated_encryption_test_case_1(void)
9966 return test_authenticated_encryption(&gcm_J0_test_case_1);
9970 test_AES_GCM_auth_encryption_test_case_192_1(void)
9972 return test_authenticated_encryption(&gcm_test_case_192_1);
9976 test_AES_GCM_auth_encryption_test_case_192_2(void)
9978 return test_authenticated_encryption(&gcm_test_case_192_2);
9982 test_AES_GCM_auth_encryption_test_case_192_3(void)
9984 return test_authenticated_encryption(&gcm_test_case_192_3);
9988 test_AES_GCM_auth_encryption_test_case_192_4(void)
9990 return test_authenticated_encryption(&gcm_test_case_192_4);
9994 test_AES_GCM_auth_encryption_test_case_192_5(void)
9996 return test_authenticated_encryption(&gcm_test_case_192_5);
10000 test_AES_GCM_auth_encryption_test_case_192_6(void)
10002 return test_authenticated_encryption(&gcm_test_case_192_6);
10006 test_AES_GCM_auth_encryption_test_case_192_7(void)
10008 return test_authenticated_encryption(&gcm_test_case_192_7);
10012 test_AES_GCM_auth_encryption_test_case_256_1(void)
10014 return test_authenticated_encryption(&gcm_test_case_256_1);
10018 test_AES_GCM_auth_encryption_test_case_256_2(void)
10020 return test_authenticated_encryption(&gcm_test_case_256_2);
10024 test_AES_GCM_auth_encryption_test_case_256_3(void)
10026 return test_authenticated_encryption(&gcm_test_case_256_3);
10030 test_AES_GCM_auth_encryption_test_case_256_4(void)
10032 return test_authenticated_encryption(&gcm_test_case_256_4);
10036 test_AES_GCM_auth_encryption_test_case_256_5(void)
10038 return test_authenticated_encryption(&gcm_test_case_256_5);
10042 test_AES_GCM_auth_encryption_test_case_256_6(void)
10044 return test_authenticated_encryption(&gcm_test_case_256_6);
10048 test_AES_GCM_auth_encryption_test_case_256_7(void)
10050 return test_authenticated_encryption(&gcm_test_case_256_7);
10054 test_AES_GCM_auth_encryption_test_case_aad_1(void)
10056 return test_authenticated_encryption(&gcm_test_case_aad_1);
10060 test_AES_GCM_auth_encryption_test_case_aad_2(void)
10062 return test_authenticated_encryption(&gcm_test_case_aad_2);
10066 test_AES_GCM_auth_encryption_fail_iv_corrupt(void)
10068 struct aead_test_data tdata;
10071 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10072 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10073 tdata.iv.data[0] += 1;
10074 res = test_authenticated_encryption(&tdata);
10075 if (res == TEST_SKIPPED)
10077 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10078 return TEST_SUCCESS;
10082 test_AES_GCM_auth_encryption_fail_in_data_corrupt(void)
10084 struct aead_test_data tdata;
10087 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10088 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10089 tdata.plaintext.data[0] += 1;
10090 res = test_authenticated_encryption(&tdata);
10091 if (res == TEST_SKIPPED)
10093 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10094 return TEST_SUCCESS;
10098 test_AES_GCM_auth_encryption_fail_out_data_corrupt(void)
10100 struct aead_test_data tdata;
10103 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10104 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10105 tdata.ciphertext.data[0] += 1;
10106 res = test_authenticated_encryption(&tdata);
10107 if (res == TEST_SKIPPED)
10109 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10110 return TEST_SUCCESS;
10114 test_AES_GCM_auth_encryption_fail_aad_len_corrupt(void)
10116 struct aead_test_data tdata;
10119 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10120 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10121 tdata.aad.len += 1;
10122 res = test_authenticated_encryption(&tdata);
10123 if (res == TEST_SKIPPED)
10125 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10126 return TEST_SUCCESS;
10130 test_AES_GCM_auth_encryption_fail_aad_corrupt(void)
10132 struct aead_test_data tdata;
10133 uint8_t aad[gcm_test_case_7.aad.len];
10136 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10137 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10138 memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
10140 tdata.aad.data = aad;
10141 res = test_authenticated_encryption(&tdata);
10142 if (res == TEST_SKIPPED)
10144 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10145 return TEST_SUCCESS;
10149 test_AES_GCM_auth_encryption_fail_tag_corrupt(void)
10151 struct aead_test_data tdata;
10154 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10155 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10156 tdata.auth_tag.data[0] += 1;
10157 res = test_authenticated_encryption(&tdata);
10158 if (res == TEST_SKIPPED)
10160 TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10161 return TEST_SUCCESS;
10165 test_authenticated_decryption(const struct aead_test_data *tdata)
10167 struct crypto_testsuite_params *ts_params = &testsuite_params;
10168 struct crypto_unittest_params *ut_params = &unittest_params;
10171 uint8_t *plaintext;
10173 struct rte_cryptodev_info dev_info;
10175 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10176 uint64_t feat_flags = dev_info.feature_flags;
10178 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10179 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10180 printf("Device doesn't support RAW data-path APIs.\n");
10181 return TEST_SKIPPED;
10184 /* Verify the capabilities */
10185 struct rte_cryptodev_sym_capability_idx cap_idx;
10186 const struct rte_cryptodev_symmetric_capability *capability;
10187 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10188 cap_idx.algo.aead = tdata->algo;
10189 capability = rte_cryptodev_sym_capability_get(
10190 ts_params->valid_devs[0], &cap_idx);
10191 if (capability == NULL)
10192 return TEST_SKIPPED;
10193 if (rte_cryptodev_sym_capability_check_aead(
10194 capability, tdata->key.len, tdata->auth_tag.len,
10195 tdata->aad.len, tdata->iv.len))
10196 return TEST_SKIPPED;
10198 /* Create AEAD session */
10199 retval = create_aead_session(ts_params->valid_devs[0],
10201 RTE_CRYPTO_AEAD_OP_DECRYPT,
10202 tdata->key.data, tdata->key.len,
10203 tdata->aad.len, tdata->auth_tag.len,
10208 /* alloc mbuf and set payload */
10209 if (tdata->aad.len > MBUF_SIZE) {
10210 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
10211 /* Populate full size of add data */
10212 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
10213 memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
10215 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10217 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10218 rte_pktmbuf_tailroom(ut_params->ibuf));
10220 /* Create AEAD operation */
10221 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
10225 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10227 ut_params->op->sym->m_src = ut_params->ibuf;
10229 /* Process crypto operation */
10230 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10231 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
10232 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10233 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10234 ut_params->op, 0, 0, 0, 0);
10236 TEST_ASSERT_NOT_NULL(
10237 process_crypto_request(ts_params->valid_devs[0],
10238 ut_params->op), "failed to process sym crypto op");
10240 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10241 "crypto op processing failed");
10243 if (ut_params->op->sym->m_dst)
10244 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
10247 plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
10249 ut_params->op->sym->cipher.data.offset);
10251 debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
10253 /* Validate obuf */
10254 TEST_ASSERT_BUFFERS_ARE_EQUAL(
10256 tdata->plaintext.data,
10257 tdata->plaintext.len,
10258 "Plaintext data not as expected");
10260 TEST_ASSERT_EQUAL(ut_params->op->status,
10261 RTE_CRYPTO_OP_STATUS_SUCCESS,
10262 "Authentication failed");
10268 test_AES_GCM_authenticated_decryption_test_case_1(void)
10270 return test_authenticated_decryption(&gcm_test_case_1);
10274 test_AES_GCM_authenticated_decryption_test_case_2(void)
10276 return test_authenticated_decryption(&gcm_test_case_2);
10280 test_AES_GCM_authenticated_decryption_test_case_3(void)
10282 return test_authenticated_decryption(&gcm_test_case_3);
10286 test_AES_GCM_authenticated_decryption_test_case_4(void)
10288 return test_authenticated_decryption(&gcm_test_case_4);
10292 test_AES_GCM_authenticated_decryption_test_case_5(void)
10294 return test_authenticated_decryption(&gcm_test_case_5);
10298 test_AES_GCM_authenticated_decryption_test_case_6(void)
10300 return test_authenticated_decryption(&gcm_test_case_6);
10304 test_AES_GCM_authenticated_decryption_test_case_7(void)
10306 return test_authenticated_decryption(&gcm_test_case_7);
10310 test_AES_GCM_authenticated_decryption_test_case_8(void)
10312 return test_authenticated_decryption(&gcm_test_case_8);
10316 test_AES_GCM_J0_authenticated_decryption_test_case_1(void)
10318 return test_authenticated_decryption(&gcm_J0_test_case_1);
10322 test_AES_GCM_auth_decryption_test_case_192_1(void)
10324 return test_authenticated_decryption(&gcm_test_case_192_1);
10328 test_AES_GCM_auth_decryption_test_case_192_2(void)
10330 return test_authenticated_decryption(&gcm_test_case_192_2);
10334 test_AES_GCM_auth_decryption_test_case_192_3(void)
10336 return test_authenticated_decryption(&gcm_test_case_192_3);
10340 test_AES_GCM_auth_decryption_test_case_192_4(void)
10342 return test_authenticated_decryption(&gcm_test_case_192_4);
10346 test_AES_GCM_auth_decryption_test_case_192_5(void)
10348 return test_authenticated_decryption(&gcm_test_case_192_5);
10352 test_AES_GCM_auth_decryption_test_case_192_6(void)
10354 return test_authenticated_decryption(&gcm_test_case_192_6);
10358 test_AES_GCM_auth_decryption_test_case_192_7(void)
10360 return test_authenticated_decryption(&gcm_test_case_192_7);
10364 test_AES_GCM_auth_decryption_test_case_256_1(void)
10366 return test_authenticated_decryption(&gcm_test_case_256_1);
10370 test_AES_GCM_auth_decryption_test_case_256_2(void)
10372 return test_authenticated_decryption(&gcm_test_case_256_2);
10376 test_AES_GCM_auth_decryption_test_case_256_3(void)
10378 return test_authenticated_decryption(&gcm_test_case_256_3);
10382 test_AES_GCM_auth_decryption_test_case_256_4(void)
10384 return test_authenticated_decryption(&gcm_test_case_256_4);
10388 test_AES_GCM_auth_decryption_test_case_256_5(void)
10390 return test_authenticated_decryption(&gcm_test_case_256_5);
10394 test_AES_GCM_auth_decryption_test_case_256_6(void)
10396 return test_authenticated_decryption(&gcm_test_case_256_6);
10400 test_AES_GCM_auth_decryption_test_case_256_7(void)
10402 return test_authenticated_decryption(&gcm_test_case_256_7);
10406 test_AES_GCM_auth_decryption_test_case_aad_1(void)
10408 return test_authenticated_decryption(&gcm_test_case_aad_1);
10412 test_AES_GCM_auth_decryption_test_case_aad_2(void)
10414 return test_authenticated_decryption(&gcm_test_case_aad_2);
10418 test_AES_GCM_auth_decryption_fail_iv_corrupt(void)
10420 struct aead_test_data tdata;
10423 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10424 tdata.iv.data[0] += 1;
10425 res = test_authenticated_decryption(&tdata);
10426 if (res == TEST_SKIPPED)
10428 TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10429 return TEST_SUCCESS;
10433 test_AES_GCM_auth_decryption_fail_in_data_corrupt(void)
10435 struct aead_test_data tdata;
10438 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10439 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10440 tdata.plaintext.data[0] += 1;
10441 res = test_authenticated_decryption(&tdata);
10442 if (res == TEST_SKIPPED)
10444 TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10445 return TEST_SUCCESS;
10449 test_AES_GCM_auth_decryption_fail_out_data_corrupt(void)
10451 struct aead_test_data tdata;
10454 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10455 tdata.ciphertext.data[0] += 1;
10456 res = test_authenticated_decryption(&tdata);
10457 if (res == TEST_SKIPPED)
10459 TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10460 return TEST_SUCCESS;
10464 test_AES_GCM_auth_decryption_fail_aad_len_corrupt(void)
10466 struct aead_test_data tdata;
10469 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10470 tdata.aad.len += 1;
10471 res = test_authenticated_decryption(&tdata);
10472 if (res == TEST_SKIPPED)
10474 TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10475 return TEST_SUCCESS;
10479 test_AES_GCM_auth_decryption_fail_aad_corrupt(void)
10481 struct aead_test_data tdata;
10482 uint8_t aad[gcm_test_case_7.aad.len];
10485 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10486 memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
10488 tdata.aad.data = aad;
10489 res = test_authenticated_decryption(&tdata);
10490 if (res == TEST_SKIPPED)
10492 TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10493 return TEST_SUCCESS;
10497 test_AES_GCM_auth_decryption_fail_tag_corrupt(void)
10499 struct aead_test_data tdata;
10502 memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10503 tdata.auth_tag.data[0] += 1;
10504 res = test_authenticated_decryption(&tdata);
10505 if (res == TEST_SKIPPED)
10507 TEST_ASSERT_EQUAL(res, TEST_FAILED, "authentication not failed");
10508 return TEST_SUCCESS;
10512 test_authenticated_encryption_oop(const struct aead_test_data *tdata)
10514 struct crypto_testsuite_params *ts_params = &testsuite_params;
10515 struct crypto_unittest_params *ut_params = &unittest_params;
10518 uint8_t *ciphertext, *auth_tag;
10519 uint16_t plaintext_pad_len;
10520 struct rte_cryptodev_info dev_info;
10522 /* Verify the capabilities */
10523 struct rte_cryptodev_sym_capability_idx cap_idx;
10524 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10525 cap_idx.algo.aead = tdata->algo;
10526 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10528 return TEST_SKIPPED;
10530 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10531 uint64_t feat_flags = dev_info.feature_flags;
10533 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10534 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP)))
10535 return TEST_SKIPPED;
10537 /* not supported with CPU crypto */
10538 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10539 return TEST_SKIPPED;
10541 /* Create AEAD session */
10542 retval = create_aead_session(ts_params->valid_devs[0],
10544 RTE_CRYPTO_AEAD_OP_ENCRYPT,
10545 tdata->key.data, tdata->key.len,
10546 tdata->aad.len, tdata->auth_tag.len,
10551 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10552 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10554 /* clear mbuf payload */
10555 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10556 rte_pktmbuf_tailroom(ut_params->ibuf));
10557 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
10558 rte_pktmbuf_tailroom(ut_params->obuf));
10560 /* Create AEAD operation */
10561 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
10565 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10567 ut_params->op->sym->m_src = ut_params->ibuf;
10568 ut_params->op->sym->m_dst = ut_params->obuf;
10570 /* Process crypto operation */
10571 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10572 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10573 ut_params->op, 0, 0, 0, 0);
10575 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
10576 ut_params->op), "failed to process sym crypto op");
10578 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10579 "crypto op processing failed");
10581 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
10583 ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
10584 ut_params->op->sym->cipher.data.offset);
10585 auth_tag = ciphertext + plaintext_pad_len;
10587 debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
10588 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
10590 /* Validate obuf */
10591 TEST_ASSERT_BUFFERS_ARE_EQUAL(
10593 tdata->ciphertext.data,
10594 tdata->ciphertext.len,
10595 "Ciphertext data not as expected");
10597 TEST_ASSERT_BUFFERS_ARE_EQUAL(
10599 tdata->auth_tag.data,
10600 tdata->auth_tag.len,
10601 "Generated auth tag not as expected");
10608 test_AES_GCM_authenticated_encryption_oop_test_case_1(void)
10610 return test_authenticated_encryption_oop(&gcm_test_case_5);
10614 test_authenticated_decryption_oop(const struct aead_test_data *tdata)
10616 struct crypto_testsuite_params *ts_params = &testsuite_params;
10617 struct crypto_unittest_params *ut_params = &unittest_params;
10620 uint8_t *plaintext;
10621 struct rte_cryptodev_info dev_info;
10623 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10624 uint64_t feat_flags = dev_info.feature_flags;
10626 /* Verify the capabilities */
10627 struct rte_cryptodev_sym_capability_idx cap_idx;
10628 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10629 cap_idx.algo.aead = tdata->algo;
10630 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10632 return TEST_SKIPPED;
10634 /* not supported with CPU crypto and raw data-path APIs*/
10635 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO ||
10636 global_api_test_type == CRYPTODEV_RAW_API_TEST)
10637 return TEST_SKIPPED;
10639 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10640 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10641 printf("Device does not support RAW data-path APIs.\n");
10642 return TEST_SKIPPED;
10645 /* Create AEAD session */
10646 retval = create_aead_session(ts_params->valid_devs[0],
10648 RTE_CRYPTO_AEAD_OP_DECRYPT,
10649 tdata->key.data, tdata->key.len,
10650 tdata->aad.len, tdata->auth_tag.len,
10655 /* alloc mbuf and set payload */
10656 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10657 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10659 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10660 rte_pktmbuf_tailroom(ut_params->ibuf));
10661 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
10662 rte_pktmbuf_tailroom(ut_params->obuf));
10664 /* Create AEAD operation */
10665 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
10669 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10671 ut_params->op->sym->m_src = ut_params->ibuf;
10672 ut_params->op->sym->m_dst = ut_params->obuf;
10674 /* Process crypto operation */
10675 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10676 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10677 ut_params->op, 0, 0, 0, 0);
10679 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
10680 ut_params->op), "failed to process sym crypto op");
10682 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10683 "crypto op processing failed");
10685 plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
10686 ut_params->op->sym->cipher.data.offset);
10688 debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
10690 /* Validate obuf */
10691 TEST_ASSERT_BUFFERS_ARE_EQUAL(
10693 tdata->plaintext.data,
10694 tdata->plaintext.len,
10695 "Plaintext data not as expected");
10697 TEST_ASSERT_EQUAL(ut_params->op->status,
10698 RTE_CRYPTO_OP_STATUS_SUCCESS,
10699 "Authentication failed");
10704 test_AES_GCM_authenticated_decryption_oop_test_case_1(void)
10706 return test_authenticated_decryption_oop(&gcm_test_case_5);
10710 test_authenticated_encryption_sessionless(
10711 const struct aead_test_data *tdata)
10713 struct crypto_testsuite_params *ts_params = &testsuite_params;
10714 struct crypto_unittest_params *ut_params = &unittest_params;
10717 uint8_t *ciphertext, *auth_tag;
10718 uint16_t plaintext_pad_len;
10719 uint8_t key[tdata->key.len + 1];
10720 struct rte_cryptodev_info dev_info;
10722 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10723 uint64_t feat_flags = dev_info.feature_flags;
10725 if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
10726 printf("Device doesn't support Sessionless ops.\n");
10727 return TEST_SKIPPED;
10730 /* not supported with CPU crypto */
10731 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10732 return TEST_SKIPPED;
10734 /* Verify the capabilities */
10735 struct rte_cryptodev_sym_capability_idx cap_idx;
10736 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10737 cap_idx.algo.aead = tdata->algo;
10738 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10740 return TEST_SKIPPED;
10742 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10744 /* clear mbuf payload */
10745 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10746 rte_pktmbuf_tailroom(ut_params->ibuf));
10748 /* Create AEAD operation */
10749 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
10753 /* Create GCM xform */
10754 memcpy(key, tdata->key.data, tdata->key.len);
10755 retval = create_aead_xform(ut_params->op,
10757 RTE_CRYPTO_AEAD_OP_ENCRYPT,
10758 key, tdata->key.len,
10759 tdata->aad.len, tdata->auth_tag.len,
10764 ut_params->op->sym->m_src = ut_params->ibuf;
10766 TEST_ASSERT_EQUAL(ut_params->op->sess_type,
10767 RTE_CRYPTO_OP_SESSIONLESS,
10768 "crypto op session type not sessionless");
10770 /* Process crypto operation */
10771 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
10772 ut_params->op), "failed to process sym crypto op");
10774 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
10776 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10777 "crypto op status not success");
10779 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
10781 ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
10782 ut_params->op->sym->cipher.data.offset);
10783 auth_tag = ciphertext + plaintext_pad_len;
10785 debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
10786 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
10788 /* Validate obuf */
10789 TEST_ASSERT_BUFFERS_ARE_EQUAL(
10791 tdata->ciphertext.data,
10792 tdata->ciphertext.len,
10793 "Ciphertext data not as expected");
10795 TEST_ASSERT_BUFFERS_ARE_EQUAL(
10797 tdata->auth_tag.data,
10798 tdata->auth_tag.len,
10799 "Generated auth tag not as expected");
10806 test_AES_GCM_authenticated_encryption_sessionless_test_case_1(void)
10808 return test_authenticated_encryption_sessionless(
10813 test_authenticated_decryption_sessionless(
10814 const struct aead_test_data *tdata)
10816 struct crypto_testsuite_params *ts_params = &testsuite_params;
10817 struct crypto_unittest_params *ut_params = &unittest_params;
10820 uint8_t *plaintext;
10821 uint8_t key[tdata->key.len + 1];
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 if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
10828 printf("Device doesn't support Sessionless ops.\n");
10829 return TEST_SKIPPED;
10832 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10833 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10834 printf("Device doesn't support RAW data-path APIs.\n");
10835 return TEST_SKIPPED;
10838 /* not supported with CPU crypto */
10839 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10840 return TEST_SKIPPED;
10842 /* Verify the capabilities */
10843 struct rte_cryptodev_sym_capability_idx cap_idx;
10844 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10845 cap_idx.algo.aead = tdata->algo;
10846 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10848 return TEST_SKIPPED;
10850 /* alloc mbuf and set payload */
10851 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10853 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10854 rte_pktmbuf_tailroom(ut_params->ibuf));
10856 /* Create AEAD operation */
10857 retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
10861 /* Create AEAD xform */
10862 memcpy(key, tdata->key.data, tdata->key.len);
10863 retval = create_aead_xform(ut_params->op,
10865 RTE_CRYPTO_AEAD_OP_DECRYPT,
10866 key, tdata->key.len,
10867 tdata->aad.len, tdata->auth_tag.len,
10872 ut_params->op->sym->m_src = ut_params->ibuf;
10874 TEST_ASSERT_EQUAL(ut_params->op->sess_type,
10875 RTE_CRYPTO_OP_SESSIONLESS,
10876 "crypto op session type not sessionless");
10878 /* Process crypto operation */
10879 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10880 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10881 ut_params->op, 0, 0, 0, 0);
10883 TEST_ASSERT_NOT_NULL(process_crypto_request(
10884 ts_params->valid_devs[0], ut_params->op),
10885 "failed to process sym crypto op");
10887 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
10889 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10890 "crypto op status not success");
10892 plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
10893 ut_params->op->sym->cipher.data.offset);
10895 debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
10897 /* Validate obuf */
10898 TEST_ASSERT_BUFFERS_ARE_EQUAL(
10900 tdata->plaintext.data,
10901 tdata->plaintext.len,
10902 "Plaintext data not as expected");
10904 TEST_ASSERT_EQUAL(ut_params->op->status,
10905 RTE_CRYPTO_OP_STATUS_SUCCESS,
10906 "Authentication failed");
10911 test_AES_GCM_authenticated_decryption_sessionless_test_case_1(void)
10913 return test_authenticated_decryption_sessionless(
10918 test_AES_CCM_authenticated_encryption_test_case_128_1(void)
10920 return test_authenticated_encryption(&ccm_test_case_128_1);
10924 test_AES_CCM_authenticated_encryption_test_case_128_2(void)
10926 return test_authenticated_encryption(&ccm_test_case_128_2);
10930 test_AES_CCM_authenticated_encryption_test_case_128_3(void)
10932 return test_authenticated_encryption(&ccm_test_case_128_3);
10936 test_AES_CCM_authenticated_decryption_test_case_128_1(void)
10938 return test_authenticated_decryption(&ccm_test_case_128_1);
10942 test_AES_CCM_authenticated_decryption_test_case_128_2(void)
10944 return test_authenticated_decryption(&ccm_test_case_128_2);
10948 test_AES_CCM_authenticated_decryption_test_case_128_3(void)
10950 return test_authenticated_decryption(&ccm_test_case_128_3);
10954 test_AES_CCM_authenticated_encryption_test_case_192_1(void)
10956 return test_authenticated_encryption(&ccm_test_case_192_1);
10960 test_AES_CCM_authenticated_encryption_test_case_192_2(void)
10962 return test_authenticated_encryption(&ccm_test_case_192_2);
10966 test_AES_CCM_authenticated_encryption_test_case_192_3(void)
10968 return test_authenticated_encryption(&ccm_test_case_192_3);
10972 test_AES_CCM_authenticated_decryption_test_case_192_1(void)
10974 return test_authenticated_decryption(&ccm_test_case_192_1);
10978 test_AES_CCM_authenticated_decryption_test_case_192_2(void)
10980 return test_authenticated_decryption(&ccm_test_case_192_2);
10984 test_AES_CCM_authenticated_decryption_test_case_192_3(void)
10986 return test_authenticated_decryption(&ccm_test_case_192_3);
10990 test_AES_CCM_authenticated_encryption_test_case_256_1(void)
10992 return test_authenticated_encryption(&ccm_test_case_256_1);
10996 test_AES_CCM_authenticated_encryption_test_case_256_2(void)
10998 return test_authenticated_encryption(&ccm_test_case_256_2);
11002 test_AES_CCM_authenticated_encryption_test_case_256_3(void)
11004 return test_authenticated_encryption(&ccm_test_case_256_3);
11008 test_AES_CCM_authenticated_decryption_test_case_256_1(void)
11010 return test_authenticated_decryption(&ccm_test_case_256_1);
11014 test_AES_CCM_authenticated_decryption_test_case_256_2(void)
11016 return test_authenticated_decryption(&ccm_test_case_256_2);
11020 test_AES_CCM_authenticated_decryption_test_case_256_3(void)
11022 return test_authenticated_decryption(&ccm_test_case_256_3);
11028 struct crypto_testsuite_params *ts_params = &testsuite_params;
11029 struct rte_cryptodev_stats stats;
11031 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11032 return TEST_SKIPPED;
11034 /* Verify the capabilities */
11035 struct rte_cryptodev_sym_capability_idx cap_idx;
11036 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11037 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
11038 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11040 return TEST_SKIPPED;
11041 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11042 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
11043 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11045 return TEST_SKIPPED;
11047 if (rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
11049 return TEST_SKIPPED;
11051 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
11052 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
11053 &stats) == -ENODEV),
11054 "rte_cryptodev_stats_get invalid dev failed");
11055 TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
11056 "rte_cryptodev_stats_get invalid Param failed");
11058 /* Test expected values */
11059 test_AES_CBC_HMAC_SHA1_encrypt_digest();
11060 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
11062 "rte_cryptodev_stats_get failed");
11063 TEST_ASSERT((stats.enqueued_count == 1),
11064 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11065 TEST_ASSERT((stats.dequeued_count == 1),
11066 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11067 TEST_ASSERT((stats.enqueue_err_count == 0),
11068 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11069 TEST_ASSERT((stats.dequeue_err_count == 0),
11070 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11072 /* invalid device but should ignore and not reset device stats*/
11073 rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
11074 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
11076 "rte_cryptodev_stats_get failed");
11077 TEST_ASSERT((stats.enqueued_count == 1),
11078 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11080 /* check that a valid reset clears stats */
11081 rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
11082 TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
11084 "rte_cryptodev_stats_get failed");
11085 TEST_ASSERT((stats.enqueued_count == 0),
11086 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11087 TEST_ASSERT((stats.dequeued_count == 0),
11088 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11090 return TEST_SUCCESS;
11093 static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
11094 struct crypto_unittest_params *ut_params,
11095 enum rte_crypto_auth_operation op,
11096 const struct HMAC_MD5_vector *test_case)
11100 memcpy(key, test_case->key.data, test_case->key.len);
11102 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11103 ut_params->auth_xform.next = NULL;
11104 ut_params->auth_xform.auth.op = op;
11106 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC;
11108 ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN;
11109 ut_params->auth_xform.auth.key.length = test_case->key.len;
11110 ut_params->auth_xform.auth.key.data = key;
11112 ut_params->sess = rte_cryptodev_sym_session_create(
11113 ts_params->session_mpool);
11115 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11116 ut_params->sess, &ut_params->auth_xform,
11117 ts_params->session_priv_mpool);
11119 if (ut_params->sess == NULL)
11120 return TEST_FAILED;
11122 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11124 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11125 rte_pktmbuf_tailroom(ut_params->ibuf));
11130 static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
11131 const struct HMAC_MD5_vector *test_case,
11132 uint8_t **plaintext)
11134 uint16_t plaintext_pad_len;
11136 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
11138 plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
11141 *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11142 plaintext_pad_len);
11143 memcpy(*plaintext, test_case->plaintext.data,
11144 test_case->plaintext.len);
11146 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
11147 ut_params->ibuf, MD5_DIGEST_LEN);
11148 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
11149 "no room to append digest");
11150 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
11151 ut_params->ibuf, plaintext_pad_len);
11153 if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
11154 rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data,
11155 test_case->auth_tag.len);
11158 sym_op->auth.data.offset = 0;
11159 sym_op->auth.data.length = test_case->plaintext.len;
11161 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11162 ut_params->op->sym->m_src = ut_params->ibuf;
11168 test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
11170 uint16_t plaintext_pad_len;
11171 uint8_t *plaintext, *auth_tag;
11173 struct crypto_testsuite_params *ts_params = &testsuite_params;
11174 struct crypto_unittest_params *ut_params = &unittest_params;
11175 struct rte_cryptodev_info dev_info;
11177 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11178 uint64_t feat_flags = dev_info.feature_flags;
11180 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11181 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11182 printf("Device doesn't support RAW data-path APIs.\n");
11183 return TEST_SKIPPED;
11186 /* Verify the capabilities */
11187 struct rte_cryptodev_sym_capability_idx cap_idx;
11188 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11189 cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
11190 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11192 return TEST_SKIPPED;
11194 if (MD5_HMAC_create_session(ts_params, ut_params,
11195 RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
11196 return TEST_FAILED;
11198 /* Generate Crypto op data structure */
11199 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11200 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11201 TEST_ASSERT_NOT_NULL(ut_params->op,
11202 "Failed to allocate symmetric crypto operation struct");
11204 plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
11207 if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
11208 return TEST_FAILED;
11210 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11211 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11213 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11214 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11215 ut_params->op, 0, 1, 0, 0);
11217 TEST_ASSERT_NOT_NULL(
11218 process_crypto_request(ts_params->valid_devs[0],
11220 "failed to process sym crypto op");
11222 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11223 "crypto op processing failed");
11225 if (ut_params->op->sym->m_dst) {
11226 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
11227 uint8_t *, plaintext_pad_len);
11229 auth_tag = plaintext + plaintext_pad_len;
11232 TEST_ASSERT_BUFFERS_ARE_EQUAL(
11234 test_case->auth_tag.data,
11235 test_case->auth_tag.len,
11236 "HMAC_MD5 generated tag not as expected");
11238 return TEST_SUCCESS;
11242 test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
11244 uint8_t *plaintext;
11246 struct crypto_testsuite_params *ts_params = &testsuite_params;
11247 struct crypto_unittest_params *ut_params = &unittest_params;
11248 struct rte_cryptodev_info dev_info;
11250 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11251 uint64_t feat_flags = dev_info.feature_flags;
11253 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11254 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11255 printf("Device doesn't support RAW data-path APIs.\n");
11256 return TEST_SKIPPED;
11259 /* Verify the capabilities */
11260 struct rte_cryptodev_sym_capability_idx cap_idx;
11261 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11262 cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
11263 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11265 return TEST_SKIPPED;
11267 if (MD5_HMAC_create_session(ts_params, ut_params,
11268 RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
11269 return TEST_FAILED;
11272 /* Generate Crypto op data structure */
11273 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11274 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11275 TEST_ASSERT_NOT_NULL(ut_params->op,
11276 "Failed to allocate symmetric crypto operation struct");
11278 if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
11279 return TEST_FAILED;
11281 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11282 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11284 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11285 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11286 ut_params->op, 0, 1, 0, 0);
11288 TEST_ASSERT_NOT_NULL(
11289 process_crypto_request(ts_params->valid_devs[0],
11291 "failed to process sym crypto op");
11293 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11294 "HMAC_MD5 crypto op processing failed");
11296 return TEST_SUCCESS;
11300 test_MD5_HMAC_generate_case_1(void)
11302 return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1);
11306 test_MD5_HMAC_verify_case_1(void)
11308 return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1);
11312 test_MD5_HMAC_generate_case_2(void)
11314 return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2);
11318 test_MD5_HMAC_verify_case_2(void)
11320 return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2);
11324 test_multi_session(void)
11326 struct crypto_testsuite_params *ts_params = &testsuite_params;
11327 struct crypto_unittest_params *ut_params = &unittest_params;
11329 struct rte_cryptodev_info dev_info;
11330 struct rte_cryptodev_sym_session **sessions;
11334 /* Verify the capabilities */
11335 struct rte_cryptodev_sym_capability_idx cap_idx;
11336 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11337 cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
11338 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11340 return TEST_SKIPPED;
11341 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11342 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
11343 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11345 return TEST_SKIPPED;
11347 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
11348 aes_cbc_key, hmac_sha512_key);
11351 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11353 sessions = rte_malloc(NULL,
11354 sizeof(struct rte_cryptodev_sym_session *) *
11355 (MAX_NB_SESSIONS + 1), 0);
11357 /* Create multiple crypto sessions*/
11358 for (i = 0; i < MAX_NB_SESSIONS; i++) {
11360 sessions[i] = rte_cryptodev_sym_session_create(
11361 ts_params->session_mpool);
11363 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11364 sessions[i], &ut_params->auth_xform,
11365 ts_params->session_priv_mpool);
11366 TEST_ASSERT_NOT_NULL(sessions[i],
11367 "Session creation failed at session number %u",
11370 /* Attempt to send a request on each session */
11371 TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform(
11375 catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
11376 catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
11378 "Failed to perform decrypt on request number %u.", i);
11379 /* free crypto operation structure */
11381 rte_crypto_op_free(ut_params->op);
11384 * free mbuf - both obuf and ibuf are usually the same,
11385 * so check if they point at the same address is necessary,
11386 * to avoid freeing the mbuf twice.
11388 if (ut_params->obuf) {
11389 rte_pktmbuf_free(ut_params->obuf);
11390 if (ut_params->ibuf == ut_params->obuf)
11391 ut_params->ibuf = 0;
11392 ut_params->obuf = 0;
11394 if (ut_params->ibuf) {
11395 rte_pktmbuf_free(ut_params->ibuf);
11396 ut_params->ibuf = 0;
11400 sessions[i] = NULL;
11401 /* Next session create should fail */
11402 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11403 sessions[i], &ut_params->auth_xform,
11404 ts_params->session_priv_mpool);
11405 TEST_ASSERT_NULL(sessions[i],
11406 "Session creation succeeded unexpectedly!");
11408 for (i = 0; i < MAX_NB_SESSIONS; i++) {
11409 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
11411 rte_cryptodev_sym_session_free(sessions[i]);
11414 rte_free(sessions);
11416 return TEST_SUCCESS;
11419 struct multi_session_params {
11420 struct crypto_unittest_params ut_params;
11421 uint8_t *cipher_key;
11423 const uint8_t *cipher;
11424 const uint8_t *digest;
11428 #define MB_SESSION_NUMBER 3
11431 test_multi_session_random_usage(void)
11433 struct crypto_testsuite_params *ts_params = &testsuite_params;
11434 struct rte_cryptodev_info dev_info;
11435 struct rte_cryptodev_sym_session **sessions;
11437 struct multi_session_params ut_paramz[] = {
11440 .cipher_key = ms_aes_cbc_key0,
11441 .hmac_key = ms_hmac_key0,
11442 .cipher = ms_aes_cbc_cipher0,
11443 .digest = ms_hmac_digest0,
11444 .iv = ms_aes_cbc_iv0
11447 .cipher_key = ms_aes_cbc_key1,
11448 .hmac_key = ms_hmac_key1,
11449 .cipher = ms_aes_cbc_cipher1,
11450 .digest = ms_hmac_digest1,
11451 .iv = ms_aes_cbc_iv1
11454 .cipher_key = ms_aes_cbc_key2,
11455 .hmac_key = ms_hmac_key2,
11456 .cipher = ms_aes_cbc_cipher2,
11457 .digest = ms_hmac_digest2,
11458 .iv = ms_aes_cbc_iv2
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_SHA512_HMAC;
11467 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11469 return TEST_SKIPPED;
11470 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11471 cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
11472 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11474 return TEST_SKIPPED;
11476 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11478 sessions = rte_malloc(NULL,
11479 (sizeof(struct rte_cryptodev_sym_session *)
11480 * MAX_NB_SESSIONS) + 1, 0);
11482 for (i = 0; i < MB_SESSION_NUMBER; i++) {
11483 sessions[i] = rte_cryptodev_sym_session_create(
11484 ts_params->session_mpool);
11486 rte_memcpy(&ut_paramz[i].ut_params, &unittest_params,
11487 sizeof(struct crypto_unittest_params));
11489 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
11490 &ut_paramz[i].ut_params,
11491 ut_paramz[i].cipher_key, ut_paramz[i].hmac_key);
11493 /* Create multiple crypto sessions*/
11494 rte_cryptodev_sym_session_init(
11495 ts_params->valid_devs[0],
11497 &ut_paramz[i].ut_params.auth_xform,
11498 ts_params->session_priv_mpool);
11500 TEST_ASSERT_NOT_NULL(sessions[i],
11501 "Session creation failed at session number %u",
11507 for (i = 0; i < 40000; i++) {
11509 j = rand() % MB_SESSION_NUMBER;
11511 TEST_ASSERT_SUCCESS(
11512 test_AES_CBC_HMAC_SHA512_decrypt_perform(
11514 &ut_paramz[j].ut_params,
11515 ts_params, ut_paramz[j].cipher,
11516 ut_paramz[j].digest,
11518 "Failed to perform decrypt on request number %u.", i);
11520 if (ut_paramz[j].ut_params.op)
11521 rte_crypto_op_free(ut_paramz[j].ut_params.op);
11524 * free mbuf - both obuf and ibuf are usually the same,
11525 * so check if they point at the same address is necessary,
11526 * to avoid freeing the mbuf twice.
11528 if (ut_paramz[j].ut_params.obuf) {
11529 rte_pktmbuf_free(ut_paramz[j].ut_params.obuf);
11530 if (ut_paramz[j].ut_params.ibuf
11531 == ut_paramz[j].ut_params.obuf)
11532 ut_paramz[j].ut_params.ibuf = 0;
11533 ut_paramz[j].ut_params.obuf = 0;
11535 if (ut_paramz[j].ut_params.ibuf) {
11536 rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf);
11537 ut_paramz[j].ut_params.ibuf = 0;
11541 for (i = 0; i < MB_SESSION_NUMBER; i++) {
11542 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
11544 rte_cryptodev_sym_session_free(sessions[i]);
11547 rte_free(sessions);
11549 return TEST_SUCCESS;
11552 uint8_t orig_data[] = {0xab, 0xab, 0xab, 0xab,
11553 0xab, 0xab, 0xab, 0xab,
11554 0xab, 0xab, 0xab, 0xab,
11555 0xab, 0xab, 0xab, 0xab};
11558 test_null_invalid_operation(void)
11560 struct crypto_testsuite_params *ts_params = &testsuite_params;
11561 struct crypto_unittest_params *ut_params = &unittest_params;
11564 /* This test is for NULL PMD only */
11565 if (gbl_driver_id != rte_cryptodev_driver_id_get(
11566 RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
11567 return TEST_SKIPPED;
11569 /* Setup Cipher Parameters */
11570 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11571 ut_params->cipher_xform.next = NULL;
11573 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
11574 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
11576 ut_params->sess = rte_cryptodev_sym_session_create(
11577 ts_params->session_mpool);
11579 /* Create Crypto session*/
11580 ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11581 ut_params->sess, &ut_params->cipher_xform,
11582 ts_params->session_priv_mpool);
11583 TEST_ASSERT(ret < 0,
11584 "Session creation succeeded unexpectedly");
11587 /* Setup HMAC Parameters */
11588 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11589 ut_params->auth_xform.next = NULL;
11591 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
11592 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
11594 ut_params->sess = rte_cryptodev_sym_session_create(
11595 ts_params->session_mpool);
11597 /* Create Crypto session*/
11598 ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11599 ut_params->sess, &ut_params->auth_xform,
11600 ts_params->session_priv_mpool);
11601 TEST_ASSERT(ret < 0,
11602 "Session creation succeeded unexpectedly");
11604 return TEST_SUCCESS;
11608 #define NULL_BURST_LENGTH (32)
11611 test_null_burst_operation(void)
11613 struct crypto_testsuite_params *ts_params = &testsuite_params;
11614 struct crypto_unittest_params *ut_params = &unittest_params;
11616 unsigned i, burst_len = NULL_BURST_LENGTH;
11618 struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
11619 struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
11621 /* This test is for NULL PMD only */
11622 if (gbl_driver_id != rte_cryptodev_driver_id_get(
11623 RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
11624 return TEST_SKIPPED;
11626 /* Setup Cipher Parameters */
11627 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11628 ut_params->cipher_xform.next = &ut_params->auth_xform;
11630 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
11631 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
11633 /* Setup HMAC Parameters */
11634 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11635 ut_params->auth_xform.next = NULL;
11637 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
11638 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
11640 ut_params->sess = rte_cryptodev_sym_session_create(
11641 ts_params->session_mpool);
11643 /* Create Crypto session*/
11644 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11645 ut_params->sess, &ut_params->cipher_xform,
11646 ts_params->session_priv_mpool);
11647 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
11649 TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
11650 RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
11651 burst_len, "failed to generate burst of crypto ops");
11653 /* Generate an operation for each mbuf in burst */
11654 for (i = 0; i < burst_len; i++) {
11655 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11657 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
11659 unsigned *data = (unsigned *)rte_pktmbuf_append(m,
11663 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
11665 burst[i]->sym->m_src = m;
11668 /* Process crypto operation */
11669 TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
11670 0, burst, burst_len),
11672 "Error enqueuing burst");
11674 TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
11675 0, burst_dequeued, burst_len),
11677 "Error dequeuing burst");
11680 for (i = 0; i < burst_len; i++) {
11682 *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
11683 *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
11685 "data not as expected");
11687 rte_pktmbuf_free(burst[i]->sym->m_src);
11688 rte_crypto_op_free(burst[i]);
11691 return TEST_SUCCESS;
11695 test_enq_callback(uint16_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops,
11696 uint16_t nb_ops, void *user_param)
11698 RTE_SET_USED(dev_id);
11699 RTE_SET_USED(qp_id);
11701 RTE_SET_USED(user_param);
11703 printf("crypto enqueue callback called\n");
11708 test_deq_callback(uint16_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops,
11709 uint16_t nb_ops, void *user_param)
11711 RTE_SET_USED(dev_id);
11712 RTE_SET_USED(qp_id);
11714 RTE_SET_USED(user_param);
11716 printf("crypto dequeue callback called\n");
11721 * Thread using enqueue/dequeue callback with RCU.
11724 test_enqdeq_callback_thread(void *arg)
11727 /* DP thread calls rte_cryptodev_enqueue_burst()/
11728 * rte_cryptodev_dequeue_burst() and invokes callback.
11730 test_null_burst_operation();
11735 test_enq_callback_setup(void)
11737 struct crypto_testsuite_params *ts_params = &testsuite_params;
11738 struct rte_cryptodev_info dev_info;
11739 struct rte_cryptodev_qp_conf qp_conf = {
11740 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
11743 struct rte_cryptodev_cb *cb;
11744 uint16_t qp_id = 0;
11746 /* Stop the device in case it's started so it can be configured */
11747 rte_cryptodev_stop(ts_params->valid_devs[0]);
11749 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11751 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
11753 "Failed to configure cryptodev %u",
11754 ts_params->valid_devs[0]);
11756 qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
11757 qp_conf.mp_session = ts_params->session_mpool;
11758 qp_conf.mp_session_private = ts_params->session_priv_mpool;
11760 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
11761 ts_params->valid_devs[0], qp_id, &qp_conf,
11762 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
11764 "rte_cryptodev_queue_pair_setup: num_inflights "
11765 "%u on qp %u on cryptodev %u",
11766 qp_conf.nb_descriptors, qp_id,
11767 ts_params->valid_devs[0]);
11769 /* Test with invalid crypto device */
11770 cb = rte_cryptodev_add_enq_callback(RTE_CRYPTO_MAX_DEVS,
11771 qp_id, test_enq_callback, NULL);
11772 TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11773 "cryptodev %u did not fail",
11774 qp_id, RTE_CRYPTO_MAX_DEVS);
11776 /* Test with invalid queue pair */
11777 cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
11778 dev_info.max_nb_queue_pairs + 1,
11779 test_enq_callback, NULL);
11780 TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11781 "cryptodev %u did not fail",
11782 dev_info.max_nb_queue_pairs + 1,
11783 ts_params->valid_devs[0]);
11785 /* Test with NULL callback */
11786 cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
11787 qp_id, NULL, NULL);
11788 TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11789 "cryptodev %u did not fail",
11790 qp_id, ts_params->valid_devs[0]);
11792 /* Test with valid configuration */
11793 cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
11794 qp_id, test_enq_callback, NULL);
11795 TEST_ASSERT_NOT_NULL(cb, "Failed test to add callback on "
11796 "qp %u on cryptodev %u",
11797 qp_id, ts_params->valid_devs[0]);
11799 rte_cryptodev_start(ts_params->valid_devs[0]);
11801 /* Launch a thread */
11802 rte_eal_remote_launch(test_enqdeq_callback_thread, NULL,
11803 rte_get_next_lcore(-1, 1, 0));
11805 /* Wait until reader exited. */
11806 rte_eal_mp_wait_lcore();
11808 /* Test with invalid crypto device */
11809 TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
11810 RTE_CRYPTO_MAX_DEVS, qp_id, cb),
11811 "Expected call to fail as crypto device is invalid");
11813 /* Test with invalid queue pair */
11814 TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
11815 ts_params->valid_devs[0],
11816 dev_info.max_nb_queue_pairs + 1, cb),
11817 "Expected call to fail as queue pair is invalid");
11819 /* Test with NULL callback */
11820 TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
11821 ts_params->valid_devs[0], qp_id, NULL),
11822 "Expected call to fail as callback is NULL");
11824 /* Test with valid configuration */
11825 TEST_ASSERT_SUCCESS(rte_cryptodev_remove_enq_callback(
11826 ts_params->valid_devs[0], qp_id, cb),
11827 "Failed test to remove callback on "
11828 "qp %u on cryptodev %u",
11829 qp_id, ts_params->valid_devs[0]);
11831 return TEST_SUCCESS;
11835 test_deq_callback_setup(void)
11837 struct crypto_testsuite_params *ts_params = &testsuite_params;
11838 struct rte_cryptodev_info dev_info;
11839 struct rte_cryptodev_qp_conf qp_conf = {
11840 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
11843 struct rte_cryptodev_cb *cb;
11844 uint16_t qp_id = 0;
11846 /* Stop the device in case it's started so it can be configured */
11847 rte_cryptodev_stop(ts_params->valid_devs[0]);
11849 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11851 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
11853 "Failed to configure cryptodev %u",
11854 ts_params->valid_devs[0]);
11856 qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
11857 qp_conf.mp_session = ts_params->session_mpool;
11858 qp_conf.mp_session_private = ts_params->session_priv_mpool;
11860 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
11861 ts_params->valid_devs[0], qp_id, &qp_conf,
11862 rte_cryptodev_socket_id(ts_params->valid_devs[0])),
11864 "rte_cryptodev_queue_pair_setup: num_inflights "
11865 "%u on qp %u on cryptodev %u",
11866 qp_conf.nb_descriptors, qp_id,
11867 ts_params->valid_devs[0]);
11869 /* Test with invalid crypto device */
11870 cb = rte_cryptodev_add_deq_callback(RTE_CRYPTO_MAX_DEVS,
11871 qp_id, test_deq_callback, NULL);
11872 TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11873 "cryptodev %u did not fail",
11874 qp_id, RTE_CRYPTO_MAX_DEVS);
11876 /* Test with invalid queue pair */
11877 cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
11878 dev_info.max_nb_queue_pairs + 1,
11879 test_deq_callback, NULL);
11880 TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11881 "cryptodev %u did not fail",
11882 dev_info.max_nb_queue_pairs + 1,
11883 ts_params->valid_devs[0]);
11885 /* Test with NULL callback */
11886 cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
11887 qp_id, NULL, NULL);
11888 TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11889 "cryptodev %u did not fail",
11890 qp_id, ts_params->valid_devs[0]);
11892 /* Test with valid configuration */
11893 cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
11894 qp_id, test_deq_callback, NULL);
11895 TEST_ASSERT_NOT_NULL(cb, "Failed test to add callback on "
11896 "qp %u on cryptodev %u",
11897 qp_id, ts_params->valid_devs[0]);
11899 rte_cryptodev_start(ts_params->valid_devs[0]);
11901 /* Launch a thread */
11902 rte_eal_remote_launch(test_enqdeq_callback_thread, NULL,
11903 rte_get_next_lcore(-1, 1, 0));
11905 /* Wait until reader exited. */
11906 rte_eal_mp_wait_lcore();
11908 /* Test with invalid crypto device */
11909 TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
11910 RTE_CRYPTO_MAX_DEVS, qp_id, cb),
11911 "Expected call to fail as crypto device is invalid");
11913 /* Test with invalid queue pair */
11914 TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
11915 ts_params->valid_devs[0],
11916 dev_info.max_nb_queue_pairs + 1, cb),
11917 "Expected call to fail as queue pair is invalid");
11919 /* Test with NULL callback */
11920 TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
11921 ts_params->valid_devs[0], qp_id, NULL),
11922 "Expected call to fail as callback is NULL");
11924 /* Test with valid configuration */
11925 TEST_ASSERT_SUCCESS(rte_cryptodev_remove_deq_callback(
11926 ts_params->valid_devs[0], qp_id, cb),
11927 "Failed test to remove callback on "
11928 "qp %u on cryptodev %u",
11929 qp_id, ts_params->valid_devs[0]);
11931 return TEST_SUCCESS;
11935 generate_gmac_large_plaintext(uint8_t *data)
11939 for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32)
11940 memcpy(&data[i], &data[0], 32);
11944 create_gmac_operation(enum rte_crypto_auth_operation op,
11945 const struct gmac_test_data *tdata)
11947 struct crypto_testsuite_params *ts_params = &testsuite_params;
11948 struct crypto_unittest_params *ut_params = &unittest_params;
11949 struct rte_crypto_sym_op *sym_op;
11951 uint32_t plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
11953 /* Generate Crypto op data structure */
11954 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11955 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11956 TEST_ASSERT_NOT_NULL(ut_params->op,
11957 "Failed to allocate symmetric crypto operation struct");
11959 sym_op = ut_params->op->sym;
11961 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
11962 ut_params->ibuf, tdata->gmac_tag.len);
11963 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
11964 "no room to append digest");
11966 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
11967 ut_params->ibuf, plaintext_pad_len);
11969 if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
11970 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
11971 tdata->gmac_tag.len);
11972 debug_hexdump(stdout, "digest:",
11973 sym_op->auth.digest.data,
11974 tdata->gmac_tag.len);
11977 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
11978 uint8_t *, IV_OFFSET);
11980 rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
11982 debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
11984 sym_op->cipher.data.length = 0;
11985 sym_op->cipher.data.offset = 0;
11987 sym_op->auth.data.offset = 0;
11988 sym_op->auth.data.length = tdata->plaintext.len;
11994 create_gmac_operation_sgl(enum rte_crypto_auth_operation op,
11995 const struct gmac_test_data *tdata,
11996 void *digest_mem, uint64_t digest_phys)
11998 struct crypto_testsuite_params *ts_params = &testsuite_params;
11999 struct crypto_unittest_params *ut_params = &unittest_params;
12000 struct rte_crypto_sym_op *sym_op;
12002 /* Generate Crypto op data structure */
12003 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12004 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12005 TEST_ASSERT_NOT_NULL(ut_params->op,
12006 "Failed to allocate symmetric crypto operation struct");
12008 sym_op = ut_params->op->sym;
12010 sym_op->auth.digest.data = digest_mem;
12011 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
12012 "no room to append digest");
12014 sym_op->auth.digest.phys_addr = digest_phys;
12016 if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
12017 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
12018 tdata->gmac_tag.len);
12019 debug_hexdump(stdout, "digest:",
12020 sym_op->auth.digest.data,
12021 tdata->gmac_tag.len);
12024 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
12025 uint8_t *, IV_OFFSET);
12027 rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
12029 debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
12031 sym_op->cipher.data.length = 0;
12032 sym_op->cipher.data.offset = 0;
12034 sym_op->auth.data.offset = 0;
12035 sym_op->auth.data.length = tdata->plaintext.len;
12040 static int create_gmac_session(uint8_t dev_id,
12041 const struct gmac_test_data *tdata,
12042 enum rte_crypto_auth_operation auth_op)
12044 uint8_t auth_key[tdata->key.len];
12046 struct crypto_testsuite_params *ts_params = &testsuite_params;
12047 struct crypto_unittest_params *ut_params = &unittest_params;
12049 memcpy(auth_key, tdata->key.data, tdata->key.len);
12051 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12052 ut_params->auth_xform.next = NULL;
12054 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
12055 ut_params->auth_xform.auth.op = auth_op;
12056 ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
12057 ut_params->auth_xform.auth.key.length = tdata->key.len;
12058 ut_params->auth_xform.auth.key.data = auth_key;
12059 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
12060 ut_params->auth_xform.auth.iv.length = tdata->iv.len;
12063 ut_params->sess = rte_cryptodev_sym_session_create(
12064 ts_params->session_mpool);
12066 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
12067 &ut_params->auth_xform,
12068 ts_params->session_priv_mpool);
12070 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12076 test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
12078 struct crypto_testsuite_params *ts_params = &testsuite_params;
12079 struct crypto_unittest_params *ut_params = &unittest_params;
12080 struct rte_cryptodev_info dev_info;
12082 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12083 uint64_t feat_flags = dev_info.feature_flags;
12085 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12086 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12087 printf("Device doesn't support RAW data-path APIs.\n");
12088 return TEST_SKIPPED;
12093 uint8_t *auth_tag, *plaintext;
12094 uint16_t plaintext_pad_len;
12096 TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
12097 "No GMAC length in the source data");
12099 /* Verify the capabilities */
12100 struct rte_cryptodev_sym_capability_idx cap_idx;
12101 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12102 cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
12103 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12105 return TEST_SKIPPED;
12107 retval = create_gmac_session(ts_params->valid_devs[0],
12108 tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
12113 if (tdata->plaintext.len > MBUF_SIZE)
12114 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
12116 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12117 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12118 "Failed to allocate input buffer in mempool");
12120 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12121 rte_pktmbuf_tailroom(ut_params->ibuf));
12123 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
12125 * Runtime generate the large plain text instead of use hard code
12126 * plain text vector. It is done to avoid create huge source file
12127 * with the test vector.
12129 if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
12130 generate_gmac_large_plaintext(tdata->plaintext.data);
12132 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12133 plaintext_pad_len);
12134 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12136 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
12137 debug_hexdump(stdout, "plaintext:", plaintext,
12138 tdata->plaintext.len);
12140 retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
12146 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12148 ut_params->op->sym->m_src = ut_params->ibuf;
12150 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12151 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12153 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12154 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12155 ut_params->op, 0, 1, 0, 0);
12157 TEST_ASSERT_NOT_NULL(
12158 process_crypto_request(ts_params->valid_devs[0],
12159 ut_params->op), "failed to process sym crypto op");
12161 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12162 "crypto op processing failed");
12164 if (ut_params->op->sym->m_dst) {
12165 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
12166 uint8_t *, plaintext_pad_len);
12168 auth_tag = plaintext + plaintext_pad_len;
12171 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
12173 TEST_ASSERT_BUFFERS_ARE_EQUAL(
12175 tdata->gmac_tag.data,
12176 tdata->gmac_tag.len,
12177 "GMAC Generated auth tag not as expected");
12183 test_AES_GMAC_authentication_test_case_1(void)
12185 return test_AES_GMAC_authentication(&gmac_test_case_1);
12189 test_AES_GMAC_authentication_test_case_2(void)
12191 return test_AES_GMAC_authentication(&gmac_test_case_2);
12195 test_AES_GMAC_authentication_test_case_3(void)
12197 return test_AES_GMAC_authentication(&gmac_test_case_3);
12201 test_AES_GMAC_authentication_test_case_4(void)
12203 return test_AES_GMAC_authentication(&gmac_test_case_4);
12207 test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
12209 struct crypto_testsuite_params *ts_params = &testsuite_params;
12210 struct crypto_unittest_params *ut_params = &unittest_params;
12212 uint32_t plaintext_pad_len;
12213 uint8_t *plaintext;
12214 struct rte_cryptodev_info dev_info;
12216 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12217 uint64_t feat_flags = dev_info.feature_flags;
12219 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12220 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12221 printf("Device doesn't support RAW data-path APIs.\n");
12222 return TEST_SKIPPED;
12225 TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
12226 "No GMAC length in the source data");
12228 /* Verify the capabilities */
12229 struct rte_cryptodev_sym_capability_idx cap_idx;
12230 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12231 cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
12232 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12234 return TEST_SKIPPED;
12236 retval = create_gmac_session(ts_params->valid_devs[0],
12237 tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
12242 if (tdata->plaintext.len > MBUF_SIZE)
12243 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
12245 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12246 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12247 "Failed to allocate input buffer in mempool");
12249 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12250 rte_pktmbuf_tailroom(ut_params->ibuf));
12252 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
12255 * Runtime generate the large plain text instead of use hard code
12256 * plain text vector. It is done to avoid create huge source file
12257 * with the test vector.
12259 if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
12260 generate_gmac_large_plaintext(tdata->plaintext.data);
12262 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12263 plaintext_pad_len);
12264 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12266 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
12267 debug_hexdump(stdout, "plaintext:", plaintext,
12268 tdata->plaintext.len);
12270 retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
12276 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12278 ut_params->op->sym->m_src = ut_params->ibuf;
12280 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12281 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12283 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12284 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12285 ut_params->op, 0, 1, 0, 0);
12287 TEST_ASSERT_NOT_NULL(
12288 process_crypto_request(ts_params->valid_devs[0],
12289 ut_params->op), "failed to process sym crypto op");
12291 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12292 "crypto op processing failed");
12299 test_AES_GMAC_authentication_verify_test_case_1(void)
12301 return test_AES_GMAC_authentication_verify(&gmac_test_case_1);
12305 test_AES_GMAC_authentication_verify_test_case_2(void)
12307 return test_AES_GMAC_authentication_verify(&gmac_test_case_2);
12311 test_AES_GMAC_authentication_verify_test_case_3(void)
12313 return test_AES_GMAC_authentication_verify(&gmac_test_case_3);
12317 test_AES_GMAC_authentication_verify_test_case_4(void)
12319 return test_AES_GMAC_authentication_verify(&gmac_test_case_4);
12323 test_AES_GMAC_authentication_SGL(const struct gmac_test_data *tdata,
12326 struct crypto_testsuite_params *ts_params = &testsuite_params;
12327 struct crypto_unittest_params *ut_params = &unittest_params;
12328 struct rte_cryptodev_info dev_info;
12329 uint64_t feature_flags;
12330 unsigned int trn_data = 0;
12331 void *digest_mem = NULL;
12333 unsigned int to_trn = 0;
12334 struct rte_mbuf *buf = NULL;
12335 uint8_t *auth_tag, *plaintext;
12338 TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
12339 "No GMAC length in the source data");
12341 /* Verify the capabilities */
12342 struct rte_cryptodev_sym_capability_idx cap_idx;
12343 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12344 cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
12345 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12347 return TEST_SKIPPED;
12349 /* Check for any input SGL support */
12350 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12351 feature_flags = dev_info.feature_flags;
12353 if ((!(feature_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) ||
12354 (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT)) ||
12355 (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)))
12356 return TEST_SKIPPED;
12358 if (fragsz > tdata->plaintext.len)
12359 fragsz = tdata->plaintext.len;
12361 uint16_t plaintext_len = fragsz;
12363 retval = create_gmac_session(ts_params->valid_devs[0],
12364 tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
12369 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12370 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12371 "Failed to allocate input buffer in mempool");
12373 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12374 rte_pktmbuf_tailroom(ut_params->ibuf));
12376 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12378 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12380 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
12382 trn_data += plaintext_len;
12384 buf = ut_params->ibuf;
12387 * Loop until no more fragments
12390 while (trn_data < tdata->plaintext.len) {
12392 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
12393 (tdata->plaintext.len - trn_data) : fragsz;
12395 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12398 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
12399 rte_pktmbuf_tailroom(buf));
12401 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
12404 memcpy(plaintext, tdata->plaintext.data + trn_data,
12406 trn_data += to_trn;
12407 if (trn_data == tdata->plaintext.len)
12408 digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
12409 tdata->gmac_tag.len);
12411 ut_params->ibuf->nb_segs = segs;
12414 * Place digest at the end of the last buffer
12416 uint64_t digest_phys = rte_pktmbuf_iova(buf) + to_trn;
12419 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12420 + tdata->gmac_tag.len);
12421 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
12422 tdata->plaintext.len);
12425 retval = create_gmac_operation_sgl(RTE_CRYPTO_AUTH_OP_GENERATE,
12426 tdata, digest_mem, digest_phys);
12431 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12433 ut_params->op->sym->m_src = ut_params->ibuf;
12435 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12436 return TEST_SKIPPED;
12438 TEST_ASSERT_NOT_NULL(
12439 process_crypto_request(ts_params->valid_devs[0],
12440 ut_params->op), "failed to process sym crypto op");
12442 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12443 "crypto op processing failed");
12445 auth_tag = digest_mem;
12446 debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
12447 TEST_ASSERT_BUFFERS_ARE_EQUAL(
12449 tdata->gmac_tag.data,
12450 tdata->gmac_tag.len,
12451 "GMAC Generated auth tag not as expected");
12456 /* Segment size not multiple of block size (16B) */
12458 test_AES_GMAC_authentication_SGL_40B(void)
12460 return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 40);
12464 test_AES_GMAC_authentication_SGL_80B(void)
12466 return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 80);
12470 test_AES_GMAC_authentication_SGL_2048B(void)
12472 return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2048);
12475 /* Segment size not multiple of block size (16B) */
12477 test_AES_GMAC_authentication_SGL_2047B(void)
12479 return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2047);
12482 struct test_crypto_vector {
12483 enum rte_crypto_cipher_algorithm crypto_algo;
12484 unsigned int cipher_offset;
12485 unsigned int cipher_len;
12498 const uint8_t *data;
12503 const uint8_t *data;
12507 enum rte_crypto_auth_algorithm auth_algo;
12508 unsigned int auth_offset;
12516 const uint8_t *data;
12526 static const struct test_crypto_vector
12527 hmac_sha1_test_crypto_vector = {
12528 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
12530 .data = plaintext_hash,
12535 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
12536 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
12537 0xDE, 0xF4, 0xDE, 0xAD
12543 0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
12544 0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
12545 0x3F, 0x91, 0x64, 0x59
12551 static const struct test_crypto_vector
12552 aes128_gmac_test_vector = {
12553 .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
12555 .data = plaintext_hash,
12560 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
12561 0x08, 0x09, 0x0A, 0x0B
12567 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
12568 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
12574 0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56,
12575 0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A
12581 static const struct test_crypto_vector
12582 aes128cbc_hmac_sha1_test_vector = {
12583 .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
12584 .cipher_offset = 0,
12588 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
12589 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
12595 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
12596 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
12601 .data = plaintext_hash,
12605 .data = ciphertext512_aes128cbc,
12608 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
12612 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
12613 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
12614 0xDE, 0xF4, 0xDE, 0xAD
12620 0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
12621 0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
12622 0x18, 0x8C, 0x1D, 0x32
12628 static const struct test_crypto_vector
12629 aes128cbc_hmac_sha1_aad_test_vector = {
12630 .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
12631 .cipher_offset = 8,
12635 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
12636 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
12642 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
12643 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
12648 .data = plaintext_hash,
12652 .data = ciphertext512_aes128cbc_aad,
12655 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
12659 0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
12660 0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
12661 0xDE, 0xF4, 0xDE, 0xAD
12667 0x6D, 0xF3, 0x50, 0x79, 0x7A, 0x2A, 0xAC, 0x7F,
12668 0xA6, 0xF0, 0xC6, 0x38, 0x1F, 0xA4, 0xDD, 0x9B,
12669 0x62, 0x0F, 0xFB, 0x10
12676 data_corruption(uint8_t *data)
12682 tag_corruption(uint8_t *data, unsigned int tag_offset)
12684 data[tag_offset] += 1;
12688 create_auth_session(struct crypto_unittest_params *ut_params,
12690 const struct test_crypto_vector *reference,
12691 enum rte_crypto_auth_operation auth_op)
12693 struct crypto_testsuite_params *ts_params = &testsuite_params;
12694 uint8_t auth_key[reference->auth_key.len + 1];
12696 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
12698 /* Setup Authentication Parameters */
12699 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12700 ut_params->auth_xform.auth.op = auth_op;
12701 ut_params->auth_xform.next = NULL;
12702 ut_params->auth_xform.auth.algo = reference->auth_algo;
12703 ut_params->auth_xform.auth.key.length = reference->auth_key.len;
12704 ut_params->auth_xform.auth.key.data = auth_key;
12705 ut_params->auth_xform.auth.digest_length = reference->digest.len;
12707 /* Create Crypto session*/
12708 ut_params->sess = rte_cryptodev_sym_session_create(
12709 ts_params->session_mpool);
12711 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
12712 &ut_params->auth_xform,
12713 ts_params->session_priv_mpool);
12715 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12721 create_auth_cipher_session(struct crypto_unittest_params *ut_params,
12723 const struct test_crypto_vector *reference,
12724 enum rte_crypto_auth_operation auth_op,
12725 enum rte_crypto_cipher_operation cipher_op)
12727 struct crypto_testsuite_params *ts_params = &testsuite_params;
12728 uint8_t cipher_key[reference->cipher_key.len + 1];
12729 uint8_t auth_key[reference->auth_key.len + 1];
12731 memcpy(cipher_key, reference->cipher_key.data,
12732 reference->cipher_key.len);
12733 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
12735 /* Setup Authentication Parameters */
12736 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12737 ut_params->auth_xform.auth.op = auth_op;
12738 ut_params->auth_xform.auth.algo = reference->auth_algo;
12739 ut_params->auth_xform.auth.key.length = reference->auth_key.len;
12740 ut_params->auth_xform.auth.key.data = auth_key;
12741 ut_params->auth_xform.auth.digest_length = reference->digest.len;
12743 if (reference->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) {
12744 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
12745 ut_params->auth_xform.auth.iv.length = reference->iv.len;
12747 ut_params->auth_xform.next = &ut_params->cipher_xform;
12749 /* Setup Cipher Parameters */
12750 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12751 ut_params->cipher_xform.next = NULL;
12752 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
12753 ut_params->cipher_xform.cipher.op = cipher_op;
12754 ut_params->cipher_xform.cipher.key.data = cipher_key;
12755 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
12756 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
12757 ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
12760 /* Create Crypto session*/
12761 ut_params->sess = rte_cryptodev_sym_session_create(
12762 ts_params->session_mpool);
12764 rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
12765 &ut_params->auth_xform,
12766 ts_params->session_priv_mpool);
12768 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12774 create_auth_operation(struct crypto_testsuite_params *ts_params,
12775 struct crypto_unittest_params *ut_params,
12776 const struct test_crypto_vector *reference,
12777 unsigned int auth_generate)
12779 /* Generate Crypto op data structure */
12780 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12781 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12782 TEST_ASSERT_NOT_NULL(ut_params->op,
12783 "Failed to allocate pktmbuf offload");
12785 /* Set crypto operation data parameters */
12786 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12788 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
12790 /* set crypto operation source mbuf */
12791 sym_op->m_src = ut_params->ibuf;
12794 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
12795 ut_params->ibuf, reference->digest.len);
12797 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
12798 "no room to append auth tag");
12800 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
12801 ut_params->ibuf, reference->plaintext.len);
12804 memset(sym_op->auth.digest.data, 0, reference->digest.len);
12806 memcpy(sym_op->auth.digest.data,
12807 reference->digest.data,
12808 reference->digest.len);
12810 debug_hexdump(stdout, "digest:",
12811 sym_op->auth.digest.data,
12812 reference->digest.len);
12814 sym_op->auth.data.length = reference->plaintext.len;
12815 sym_op->auth.data.offset = 0;
12821 create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
12822 struct crypto_unittest_params *ut_params,
12823 const struct test_crypto_vector *reference,
12824 unsigned int auth_generate)
12826 /* Generate Crypto op data structure */
12827 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12828 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12829 TEST_ASSERT_NOT_NULL(ut_params->op,
12830 "Failed to allocate pktmbuf offload");
12832 /* Set crypto operation data parameters */
12833 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12835 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
12837 /* set crypto operation source mbuf */
12838 sym_op->m_src = ut_params->ibuf;
12841 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
12842 ut_params->ibuf, reference->digest.len);
12844 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
12845 "no room to append auth tag");
12847 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
12848 ut_params->ibuf, reference->ciphertext.len);
12851 memset(sym_op->auth.digest.data, 0, reference->digest.len);
12853 memcpy(sym_op->auth.digest.data,
12854 reference->digest.data,
12855 reference->digest.len);
12857 debug_hexdump(stdout, "digest:",
12858 sym_op->auth.digest.data,
12859 reference->digest.len);
12861 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
12862 reference->iv.data, reference->iv.len);
12864 sym_op->cipher.data.length = 0;
12865 sym_op->cipher.data.offset = 0;
12867 sym_op->auth.data.length = reference->plaintext.len;
12868 sym_op->auth.data.offset = 0;
12874 create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
12875 struct crypto_unittest_params *ut_params,
12876 const struct test_crypto_vector *reference,
12877 unsigned int auth_generate)
12879 /* Generate Crypto op data structure */
12880 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12881 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12882 TEST_ASSERT_NOT_NULL(ut_params->op,
12883 "Failed to allocate pktmbuf offload");
12885 /* Set crypto operation data parameters */
12886 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12888 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
12890 /* set crypto operation source mbuf */
12891 sym_op->m_src = ut_params->ibuf;
12894 sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
12895 ut_params->ibuf, reference->digest.len);
12897 TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
12898 "no room to append auth tag");
12900 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
12901 ut_params->ibuf, reference->ciphertext.len);
12904 memset(sym_op->auth.digest.data, 0, reference->digest.len);
12906 memcpy(sym_op->auth.digest.data,
12907 reference->digest.data,
12908 reference->digest.len);
12910 debug_hexdump(stdout, "digest:",
12911 sym_op->auth.digest.data,
12912 reference->digest.len);
12914 rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
12915 reference->iv.data, reference->iv.len);
12917 sym_op->cipher.data.length = reference->cipher_len;
12918 sym_op->cipher.data.offset = reference->cipher_offset;
12920 sym_op->auth.data.length = reference->plaintext.len;
12921 sym_op->auth.data.offset = reference->auth_offset;
12927 create_auth_verify_operation(struct crypto_testsuite_params *ts_params,
12928 struct crypto_unittest_params *ut_params,
12929 const struct test_crypto_vector *reference)
12931 return create_auth_operation(ts_params, ut_params, reference, 0);
12935 create_auth_verify_GMAC_operation(
12936 struct crypto_testsuite_params *ts_params,
12937 struct crypto_unittest_params *ut_params,
12938 const struct test_crypto_vector *reference)
12940 return create_auth_GMAC_operation(ts_params, ut_params, reference, 0);
12944 create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params,
12945 struct crypto_unittest_params *ut_params,
12946 const struct test_crypto_vector *reference)
12948 return create_cipher_auth_operation(ts_params, ut_params, reference, 0);
12952 test_authentication_verify_fail_when_data_corruption(
12953 struct crypto_testsuite_params *ts_params,
12954 struct crypto_unittest_params *ut_params,
12955 const struct test_crypto_vector *reference,
12956 unsigned int data_corrupted)
12960 uint8_t *plaintext;
12961 struct rte_cryptodev_info dev_info;
12963 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12964 uint64_t feat_flags = dev_info.feature_flags;
12966 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12967 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12968 printf("Device doesn't support RAW data-path APIs.\n");
12969 return TEST_SKIPPED;
12972 /* Verify the capabilities */
12973 struct rte_cryptodev_sym_capability_idx cap_idx;
12974 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12975 cap_idx.algo.auth = reference->auth_algo;
12976 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12978 return TEST_SKIPPED;
12981 /* Create session */
12982 retval = create_auth_session(ut_params,
12983 ts_params->valid_devs[0],
12985 RTE_CRYPTO_AUTH_OP_VERIFY);
12989 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12990 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12991 "Failed to allocate input buffer in mempool");
12993 /* clear mbuf payload */
12994 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12995 rte_pktmbuf_tailroom(ut_params->ibuf));
12997 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12998 reference->plaintext.len);
12999 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
13000 memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
13002 debug_hexdump(stdout, "plaintext:", plaintext,
13003 reference->plaintext.len);
13005 /* Create operation */
13006 retval = create_auth_verify_operation(ts_params, ut_params, reference);
13011 if (data_corrupted)
13012 data_corruption(plaintext);
13014 tag_corruption(plaintext, reference->plaintext.len);
13016 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
13017 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13019 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
13020 RTE_CRYPTO_OP_STATUS_SUCCESS,
13021 "authentication not failed");
13022 } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13023 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13024 ut_params->op, 0, 1, 0, 0);
13026 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13029 if (ut_params->op == NULL)
13031 else if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS)
13038 test_authentication_verify_GMAC_fail_when_corruption(
13039 struct crypto_testsuite_params *ts_params,
13040 struct crypto_unittest_params *ut_params,
13041 const struct test_crypto_vector *reference,
13042 unsigned int data_corrupted)
13045 uint8_t *plaintext;
13046 struct rte_cryptodev_info dev_info;
13048 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13049 uint64_t feat_flags = dev_info.feature_flags;
13051 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13052 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13053 printf("Device doesn't support RAW data-path APIs.\n");
13054 return TEST_SKIPPED;
13057 /* Verify the capabilities */
13058 struct rte_cryptodev_sym_capability_idx cap_idx;
13059 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13060 cap_idx.algo.auth = reference->auth_algo;
13061 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13063 return TEST_SKIPPED;
13065 /* Create session */
13066 retval = create_auth_cipher_session(ut_params,
13067 ts_params->valid_devs[0],
13069 RTE_CRYPTO_AUTH_OP_VERIFY,
13070 RTE_CRYPTO_CIPHER_OP_DECRYPT);
13074 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13075 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13076 "Failed to allocate input buffer in mempool");
13078 /* clear mbuf payload */
13079 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13080 rte_pktmbuf_tailroom(ut_params->ibuf));
13082 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13083 reference->plaintext.len);
13084 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
13085 memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
13087 debug_hexdump(stdout, "plaintext:", plaintext,
13088 reference->plaintext.len);
13090 /* Create operation */
13091 retval = create_auth_verify_GMAC_operation(ts_params,
13098 if (data_corrupted)
13099 data_corruption(plaintext);
13101 tag_corruption(plaintext, reference->aad.len);
13103 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
13104 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13106 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
13107 RTE_CRYPTO_OP_STATUS_SUCCESS,
13108 "authentication not failed");
13109 } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13110 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13111 ut_params->op, 0, 1, 0, 0);
13113 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13115 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
13122 test_authenticated_decryption_fail_when_corruption(
13123 struct crypto_testsuite_params *ts_params,
13124 struct crypto_unittest_params *ut_params,
13125 const struct test_crypto_vector *reference,
13126 unsigned int data_corrupted)
13130 uint8_t *ciphertext;
13131 struct rte_cryptodev_info dev_info;
13133 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13134 uint64_t feat_flags = dev_info.feature_flags;
13136 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13137 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13138 printf("Device doesn't support RAW data-path APIs.\n");
13139 return TEST_SKIPPED;
13142 /* Verify the capabilities */
13143 struct rte_cryptodev_sym_capability_idx cap_idx;
13144 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13145 cap_idx.algo.auth = reference->auth_algo;
13146 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13148 return TEST_SKIPPED;
13149 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13150 cap_idx.algo.cipher = reference->crypto_algo;
13151 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13153 return TEST_SKIPPED;
13155 /* Create session */
13156 retval = create_auth_cipher_session(ut_params,
13157 ts_params->valid_devs[0],
13159 RTE_CRYPTO_AUTH_OP_VERIFY,
13160 RTE_CRYPTO_CIPHER_OP_DECRYPT);
13164 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13165 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13166 "Failed to allocate input buffer in mempool");
13168 /* clear mbuf payload */
13169 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13170 rte_pktmbuf_tailroom(ut_params->ibuf));
13172 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13173 reference->ciphertext.len);
13174 TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
13175 memcpy(ciphertext, reference->ciphertext.data,
13176 reference->ciphertext.len);
13178 /* Create operation */
13179 retval = create_cipher_auth_verify_operation(ts_params,
13186 if (data_corrupted)
13187 data_corruption(ciphertext);
13189 tag_corruption(ciphertext, reference->ciphertext.len);
13191 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
13192 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13194 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
13195 RTE_CRYPTO_OP_STATUS_SUCCESS,
13196 "authentication not failed");
13197 } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13198 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13199 ut_params->op, 1, 1, 0, 0);
13201 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13203 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
13210 test_authenticated_encrypt_with_esn(
13211 struct crypto_testsuite_params *ts_params,
13212 struct crypto_unittest_params *ut_params,
13213 const struct test_crypto_vector *reference)
13217 uint8_t *authciphertext, *plaintext, *auth_tag;
13218 uint16_t plaintext_pad_len;
13219 uint8_t cipher_key[reference->cipher_key.len + 1];
13220 uint8_t auth_key[reference->auth_key.len + 1];
13221 struct rte_cryptodev_info dev_info;
13223 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13224 uint64_t feat_flags = dev_info.feature_flags;
13226 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13227 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13228 printf("Device doesn't support RAW data-path APIs.\n");
13229 return TEST_SKIPPED;
13232 /* Verify the capabilities */
13233 struct rte_cryptodev_sym_capability_idx cap_idx;
13234 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13235 cap_idx.algo.auth = reference->auth_algo;
13236 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13238 return TEST_SKIPPED;
13239 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13240 cap_idx.algo.cipher = reference->crypto_algo;
13241 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13243 return TEST_SKIPPED;
13245 /* Create session */
13246 memcpy(cipher_key, reference->cipher_key.data,
13247 reference->cipher_key.len);
13248 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
13250 /* Setup Cipher Parameters */
13251 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13252 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
13253 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
13254 ut_params->cipher_xform.cipher.key.data = cipher_key;
13255 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
13256 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
13257 ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
13259 ut_params->cipher_xform.next = &ut_params->auth_xform;
13261 /* Setup Authentication Parameters */
13262 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13263 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
13264 ut_params->auth_xform.auth.algo = reference->auth_algo;
13265 ut_params->auth_xform.auth.key.length = reference->auth_key.len;
13266 ut_params->auth_xform.auth.key.data = auth_key;
13267 ut_params->auth_xform.auth.digest_length = reference->digest.len;
13268 ut_params->auth_xform.next = NULL;
13270 /* Create Crypto session*/
13271 ut_params->sess = rte_cryptodev_sym_session_create(
13272 ts_params->session_mpool);
13274 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
13276 &ut_params->cipher_xform,
13277 ts_params->session_priv_mpool);
13279 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
13281 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13282 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13283 "Failed to allocate input buffer in mempool");
13285 /* clear mbuf payload */
13286 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13287 rte_pktmbuf_tailroom(ut_params->ibuf));
13289 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13290 reference->plaintext.len);
13291 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
13292 memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
13294 /* Create operation */
13295 retval = create_cipher_auth_operation(ts_params,
13302 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13303 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13305 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13306 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13307 ut_params->op, 1, 1, 0, 0);
13309 ut_params->op = process_crypto_request(
13310 ts_params->valid_devs[0], ut_params->op);
13312 TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
13314 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
13315 "crypto op processing failed");
13317 plaintext_pad_len = RTE_ALIGN_CEIL(reference->plaintext.len, 16);
13319 authciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
13320 ut_params->op->sym->auth.data.offset);
13321 auth_tag = authciphertext + plaintext_pad_len;
13322 debug_hexdump(stdout, "ciphertext:", authciphertext,
13323 reference->ciphertext.len);
13324 debug_hexdump(stdout, "auth tag:", auth_tag, reference->digest.len);
13326 /* Validate obuf */
13327 TEST_ASSERT_BUFFERS_ARE_EQUAL(
13329 reference->ciphertext.data,
13330 reference->ciphertext.len,
13331 "Ciphertext data not as expected");
13333 TEST_ASSERT_BUFFERS_ARE_EQUAL(
13335 reference->digest.data,
13336 reference->digest.len,
13337 "Generated digest not as expected");
13339 return TEST_SUCCESS;
13344 test_authenticated_decrypt_with_esn(
13345 struct crypto_testsuite_params *ts_params,
13346 struct crypto_unittest_params *ut_params,
13347 const struct test_crypto_vector *reference)
13351 uint8_t *ciphertext;
13352 uint8_t cipher_key[reference->cipher_key.len + 1];
13353 uint8_t auth_key[reference->auth_key.len + 1];
13354 struct rte_cryptodev_info dev_info;
13356 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13357 uint64_t feat_flags = dev_info.feature_flags;
13359 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13360 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13361 printf("Device doesn't support RAW data-path APIs.\n");
13362 return TEST_SKIPPED;
13365 /* Verify the capabilities */
13366 struct rte_cryptodev_sym_capability_idx cap_idx;
13367 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13368 cap_idx.algo.auth = reference->auth_algo;
13369 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13371 return TEST_SKIPPED;
13372 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13373 cap_idx.algo.cipher = reference->crypto_algo;
13374 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13376 return TEST_SKIPPED;
13378 /* Create session */
13379 memcpy(cipher_key, reference->cipher_key.data,
13380 reference->cipher_key.len);
13381 memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
13383 /* Setup Authentication Parameters */
13384 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13385 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
13386 ut_params->auth_xform.auth.algo = reference->auth_algo;
13387 ut_params->auth_xform.auth.key.length = reference->auth_key.len;
13388 ut_params->auth_xform.auth.key.data = auth_key;
13389 ut_params->auth_xform.auth.digest_length = reference->digest.len;
13390 ut_params->auth_xform.next = &ut_params->cipher_xform;
13392 /* Setup Cipher Parameters */
13393 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13394 ut_params->cipher_xform.next = NULL;
13395 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
13396 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
13397 ut_params->cipher_xform.cipher.key.data = cipher_key;
13398 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
13399 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
13400 ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
13402 /* Create Crypto session*/
13403 ut_params->sess = rte_cryptodev_sym_session_create(
13404 ts_params->session_mpool);
13406 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
13408 &ut_params->auth_xform,
13409 ts_params->session_priv_mpool);
13411 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
13413 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13414 TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13415 "Failed to allocate input buffer in mempool");
13417 /* clear mbuf payload */
13418 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13419 rte_pktmbuf_tailroom(ut_params->ibuf));
13421 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13422 reference->ciphertext.len);
13423 TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
13424 memcpy(ciphertext, reference->ciphertext.data,
13425 reference->ciphertext.len);
13427 /* Create operation */
13428 retval = create_cipher_auth_verify_operation(ts_params,
13435 if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13436 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13438 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13439 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13440 ut_params->op, 1, 1, 0, 0);
13442 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13445 TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
13446 TEST_ASSERT_EQUAL(ut_params->op->status,
13447 RTE_CRYPTO_OP_STATUS_SUCCESS,
13448 "crypto op processing passed");
13450 ut_params->obuf = ut_params->op->sym->m_src;
13451 TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
13457 create_aead_operation_SGL(enum rte_crypto_aead_operation op,
13458 const struct aead_test_data *tdata,
13459 void *digest_mem, uint64_t digest_phys)
13461 struct crypto_testsuite_params *ts_params = &testsuite_params;
13462 struct crypto_unittest_params *ut_params = &unittest_params;
13464 const unsigned int auth_tag_len = tdata->auth_tag.len;
13465 const unsigned int iv_len = tdata->iv.len;
13466 unsigned int aad_len = tdata->aad.len;
13467 unsigned int aad_len_pad = 0;
13469 /* Generate Crypto op data structure */
13470 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
13471 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
13472 TEST_ASSERT_NOT_NULL(ut_params->op,
13473 "Failed to allocate symmetric crypto operation struct");
13475 struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
13477 sym_op->aead.digest.data = digest_mem;
13479 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
13480 "no room to append digest");
13482 sym_op->aead.digest.phys_addr = digest_phys;
13484 if (op == RTE_CRYPTO_AEAD_OP_DECRYPT) {
13485 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
13487 debug_hexdump(stdout, "digest:",
13488 sym_op->aead.digest.data,
13492 /* Append aad data */
13493 if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
13494 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
13495 uint8_t *, IV_OFFSET);
13497 /* Copy IV 1 byte after the IV pointer, according to the API */
13498 rte_memcpy(iv_ptr + 1, tdata->iv.data, iv_len);
13500 aad_len = RTE_ALIGN_CEIL(aad_len + 18, 16);
13502 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
13503 ut_params->ibuf, aad_len);
13504 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
13505 "no room to prepend aad");
13506 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
13509 memset(sym_op->aead.aad.data, 0, aad_len);
13510 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
13511 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
13513 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
13514 debug_hexdump(stdout, "aad:",
13515 sym_op->aead.aad.data, aad_len);
13517 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
13518 uint8_t *, IV_OFFSET);
13520 rte_memcpy(iv_ptr, tdata->iv.data, iv_len);
13522 aad_len_pad = RTE_ALIGN_CEIL(aad_len, 16);
13524 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
13525 ut_params->ibuf, aad_len_pad);
13526 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
13527 "no room to prepend aad");
13528 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
13531 memset(sym_op->aead.aad.data, 0, aad_len);
13532 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
13534 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
13535 debug_hexdump(stdout, "aad:",
13536 sym_op->aead.aad.data, aad_len);
13539 sym_op->aead.data.length = tdata->plaintext.len;
13540 sym_op->aead.data.offset = aad_len_pad;
13545 #define SGL_MAX_NO 16
13548 test_authenticated_encryption_SGL(const struct aead_test_data *tdata,
13549 const int oop, uint32_t fragsz, uint32_t fragsz_oop)
13551 struct crypto_testsuite_params *ts_params = &testsuite_params;
13552 struct crypto_unittest_params *ut_params = &unittest_params;
13553 struct rte_mbuf *buf, *buf_oop = NULL, *buf_last_oop = NULL;
13556 int to_trn_tbl[SGL_MAX_NO];
13558 unsigned int trn_data = 0;
13559 uint8_t *plaintext, *ciphertext, *auth_tag;
13560 struct rte_cryptodev_info dev_info;
13562 /* Verify the capabilities */
13563 struct rte_cryptodev_sym_capability_idx cap_idx;
13564 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
13565 cap_idx.algo.aead = tdata->algo;
13566 if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13568 return TEST_SKIPPED;
13570 /* OOP not supported with CPU crypto */
13571 if (oop && gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13572 return TEST_SKIPPED;
13574 /* Detailed check for the particular SGL support flag */
13575 rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13577 unsigned int sgl_in = fragsz < tdata->plaintext.len;
13578 if (sgl_in && (!(dev_info.feature_flags &
13579 RTE_CRYPTODEV_FF_IN_PLACE_SGL)))
13580 return TEST_SKIPPED;
13582 uint64_t feat_flags = dev_info.feature_flags;
13584 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13585 (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13586 printf("Device doesn't support RAW data-path APIs.\n");
13587 return TEST_SKIPPED;
13590 unsigned int sgl_in = fragsz < tdata->plaintext.len;
13591 unsigned int sgl_out = (fragsz_oop ? fragsz_oop : fragsz) <
13592 tdata->plaintext.len;
13593 /* Raw data path API does not support OOP */
13594 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13595 return TEST_SKIPPED;
13596 if (sgl_in && !sgl_out) {
13597 if (!(dev_info.feature_flags &
13598 RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT))
13599 return TEST_SKIPPED;
13600 } else if (!sgl_in && sgl_out) {
13601 if (!(dev_info.feature_flags &
13602 RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT))
13603 return TEST_SKIPPED;
13604 } else if (sgl_in && sgl_out) {
13605 if (!(dev_info.feature_flags &
13606 RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT))
13607 return TEST_SKIPPED;
13611 if (fragsz > tdata->plaintext.len)
13612 fragsz = tdata->plaintext.len;
13614 uint16_t plaintext_len = fragsz;
13615 uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
13617 if (fragsz_oop > tdata->plaintext.len)
13618 frag_size_oop = tdata->plaintext.len;
13621 void *digest_mem = NULL;
13623 uint32_t prepend_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
13625 if (tdata->plaintext.len % fragsz != 0) {
13626 if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO)
13629 if (tdata->plaintext.len / fragsz > SGL_MAX_NO)
13634 * For out-op-place we need to alloc another mbuf
13637 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13638 rte_pktmbuf_append(ut_params->obuf,
13639 frag_size_oop + prepend_len);
13640 buf_oop = ut_params->obuf;
13643 /* Create AEAD session */
13644 retval = create_aead_session(ts_params->valid_devs[0],
13646 RTE_CRYPTO_AEAD_OP_ENCRYPT,
13647 tdata->key.data, tdata->key.len,
13648 tdata->aad.len, tdata->auth_tag.len,
13653 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13655 /* clear mbuf payload */
13656 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13657 rte_pktmbuf_tailroom(ut_params->ibuf));
13659 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13662 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
13664 trn_data += plaintext_len;
13666 buf = ut_params->ibuf;
13669 * Loop until no more fragments
13672 while (trn_data < tdata->plaintext.len) {
13674 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
13675 (tdata->plaintext.len - trn_data) : fragsz;
13677 to_trn_tbl[ecx++] = to_trn;
13679 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13682 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
13683 rte_pktmbuf_tailroom(buf));
13686 if (oop && !fragsz_oop) {
13687 buf_last_oop = buf_oop->next =
13688 rte_pktmbuf_alloc(ts_params->mbuf_pool);
13689 buf_oop = buf_oop->next;
13690 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
13691 0, rte_pktmbuf_tailroom(buf_oop));
13692 rte_pktmbuf_append(buf_oop, to_trn);
13695 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
13698 memcpy(plaintext, tdata->plaintext.data + trn_data,
13700 trn_data += to_trn;
13701 if (trn_data == tdata->plaintext.len) {
13704 digest_mem = rte_pktmbuf_append(buf_oop,
13705 tdata->auth_tag.len);
13707 digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
13708 tdata->auth_tag.len);
13712 uint64_t digest_phys = 0;
13714 ut_params->ibuf->nb_segs = segs;
13717 if (fragsz_oop && oop) {
13721 if (frag_size_oop == tdata->plaintext.len) {
13722 digest_mem = rte_pktmbuf_append(ut_params->obuf,
13723 tdata->auth_tag.len);
13725 digest_phys = rte_pktmbuf_iova_offset(
13727 tdata->plaintext.len + prepend_len);
13730 trn_data = frag_size_oop;
13731 while (trn_data < tdata->plaintext.len) {
13734 (tdata->plaintext.len - trn_data <
13736 (tdata->plaintext.len - trn_data) :
13739 to_trn_tbl[ecx++] = to_trn;
13741 buf_last_oop = buf_oop->next =
13742 rte_pktmbuf_alloc(ts_params->mbuf_pool);
13743 buf_oop = buf_oop->next;
13744 memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
13745 0, rte_pktmbuf_tailroom(buf_oop));
13746 rte_pktmbuf_append(buf_oop, to_trn);
13748 trn_data += to_trn;
13750 if (trn_data == tdata->plaintext.len) {
13751 digest_mem = rte_pktmbuf_append(buf_oop,
13752 tdata->auth_tag.len);
13756 ut_params->obuf->nb_segs = segs;
13760 * Place digest at the end of the last buffer
13763 digest_phys = rte_pktmbuf_iova(buf) + to_trn;
13764 if (oop && buf_last_oop)
13765 digest_phys = rte_pktmbuf_iova(buf_last_oop) + to_trn;
13767 if (!digest_mem && !oop) {
13768 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13769 + tdata->auth_tag.len);
13770 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
13771 tdata->plaintext.len);
13774 /* Create AEAD operation */
13775 retval = create_aead_operation_SGL(RTE_CRYPTO_AEAD_OP_ENCRYPT,
13776 tdata, digest_mem, digest_phys);
13781 rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
13783 ut_params->op->sym->m_src = ut_params->ibuf;
13785 ut_params->op->sym->m_dst = ut_params->obuf;
13787 /* Process crypto operation */
13788 if (oop == IN_PLACE &&
13789 gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13790 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
13791 else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13792 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13793 ut_params->op, 0, 0, 0, 0);
13795 TEST_ASSERT_NOT_NULL(
13796 process_crypto_request(ts_params->valid_devs[0],
13797 ut_params->op), "failed to process sym crypto op");
13799 TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
13800 "crypto op processing failed");
13803 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
13804 uint8_t *, prepend_len);
13806 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
13807 uint8_t *, prepend_len);
13811 fragsz = fragsz_oop;
13813 TEST_ASSERT_BUFFERS_ARE_EQUAL(
13815 tdata->ciphertext.data,
13817 "Ciphertext data not as expected");
13819 buf = ut_params->op->sym->m_src->next;
13821 buf = ut_params->op->sym->m_dst->next;
13823 unsigned int off = fragsz;
13827 ciphertext = rte_pktmbuf_mtod(buf,
13830 TEST_ASSERT_BUFFERS_ARE_EQUAL(
13832 tdata->ciphertext.data + off,
13834 "Ciphertext data not as expected");
13836 off += to_trn_tbl[ecx++];
13840 auth_tag = digest_mem;
13841 TEST_ASSERT_BUFFERS_ARE_EQUAL(
13843 tdata->auth_tag.data,
13844 tdata->auth_tag.len,
13845 "Generated auth tag not as expected");
13851 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void)
13853 return test_authenticated_encryption_SGL(
13854 &gcm_test_case_SGL_1, OUT_OF_PLACE, 400, 400);
13858 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B(void)
13860 return test_authenticated_encryption_SGL(
13861 &gcm_test_case_SGL_1, OUT_OF_PLACE, 1500, 2000);
13865 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void)
13867 return test_authenticated_encryption_SGL(
13868 &gcm_test_case_8, OUT_OF_PLACE, 400,
13869 gcm_test_case_8.plaintext.len);
13873 test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void)
13875 /* This test is not for OPENSSL PMD */
13876 if (gbl_driver_id == rte_cryptodev_driver_id_get(
13877 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)))
13878 return TEST_SKIPPED;
13880 return test_authenticated_encryption_SGL(
13881 &gcm_test_case_SGL_1, IN_PLACE, 1500, 0);
13885 test_authentication_verify_fail_when_data_corrupted(
13886 struct crypto_testsuite_params *ts_params,
13887 struct crypto_unittest_params *ut_params,
13888 const struct test_crypto_vector *reference)
13890 return test_authentication_verify_fail_when_data_corruption(
13891 ts_params, ut_params, reference, 1);
13895 test_authentication_verify_fail_when_tag_corrupted(
13896 struct crypto_testsuite_params *ts_params,
13897 struct crypto_unittest_params *ut_params,
13898 const struct test_crypto_vector *reference)
13900 return test_authentication_verify_fail_when_data_corruption(
13901 ts_params, ut_params, reference, 0);
13905 test_authentication_verify_GMAC_fail_when_data_corrupted(
13906 struct crypto_testsuite_params *ts_params,
13907 struct crypto_unittest_params *ut_params,
13908 const struct test_crypto_vector *reference)
13910 return test_authentication_verify_GMAC_fail_when_corruption(
13911 ts_params, ut_params, reference, 1);
13915 test_authentication_verify_GMAC_fail_when_tag_corrupted(
13916 struct crypto_testsuite_params *ts_params,
13917 struct crypto_unittest_params *ut_params,
13918 const struct test_crypto_vector *reference)
13920 return test_authentication_verify_GMAC_fail_when_corruption(
13921 ts_params, ut_params, reference, 0);
13925 test_authenticated_decryption_fail_when_data_corrupted(
13926 struct crypto_testsuite_params *ts_params,
13927 struct crypto_unittest_params *ut_params,
13928 const struct test_crypto_vector *reference)
13930 return test_authenticated_decryption_fail_when_corruption(
13931 ts_params, ut_params, reference, 1);
13935 test_authenticated_decryption_fail_when_tag_corrupted(
13936 struct crypto_testsuite_params *ts_params,
13937 struct crypto_unittest_params *ut_params,
13938 const struct test_crypto_vector *reference)
13940 return test_authenticated_decryption_fail_when_corruption(
13941 ts_params, ut_params, reference, 0);
13945 authentication_verify_HMAC_SHA1_fail_data_corrupt(void)
13947 return test_authentication_verify_fail_when_data_corrupted(
13948 &testsuite_params, &unittest_params,
13949 &hmac_sha1_test_crypto_vector);
13953 authentication_verify_HMAC_SHA1_fail_tag_corrupt(void)
13955 return test_authentication_verify_fail_when_tag_corrupted(
13956 &testsuite_params, &unittest_params,
13957 &hmac_sha1_test_crypto_vector);
13961 authentication_verify_AES128_GMAC_fail_data_corrupt(void)
13963 return test_authentication_verify_GMAC_fail_when_data_corrupted(
13964 &testsuite_params, &unittest_params,
13965 &aes128_gmac_test_vector);
13969 authentication_verify_AES128_GMAC_fail_tag_corrupt(void)
13971 return test_authentication_verify_GMAC_fail_when_tag_corrupted(
13972 &testsuite_params, &unittest_params,
13973 &aes128_gmac_test_vector);
13977 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void)
13979 return test_authenticated_decryption_fail_when_data_corrupted(
13982 &aes128cbc_hmac_sha1_test_vector);
13986 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void)
13988 return test_authenticated_decryption_fail_when_tag_corrupted(
13991 &aes128cbc_hmac_sha1_test_vector);
13995 auth_encrypt_AES128CBC_HMAC_SHA1_esn_check(void)
13997 return test_authenticated_encrypt_with_esn(
14000 &aes128cbc_hmac_sha1_aad_test_vector);
14004 auth_decrypt_AES128CBC_HMAC_SHA1_esn_check(void)
14006 return test_authenticated_decrypt_with_esn(
14009 &aes128cbc_hmac_sha1_aad_test_vector);
14013 test_chacha20_poly1305_encrypt_test_case_rfc8439(void)
14015 return test_authenticated_encryption(&chacha20_poly1305_case_rfc8439);
14019 test_chacha20_poly1305_decrypt_test_case_rfc8439(void)
14021 return test_authenticated_decryption(&chacha20_poly1305_case_rfc8439);
14025 test_chacha20_poly1305_encrypt_SGL_out_of_place(void)
14027 return test_authenticated_encryption_SGL(
14028 &chacha20_poly1305_case_2, OUT_OF_PLACE, 32,
14029 chacha20_poly1305_case_2.plaintext.len);
14032 #ifdef RTE_CRYPTO_SCHEDULER
14034 /* global AESNI worker IDs for the scheduler test */
14035 uint8_t aesni_ids[2];
14038 scheduler_testsuite_setup(void)
14041 int32_t nb_devs, ret;
14042 char vdev_args[VDEV_ARGS_SIZE] = {""};
14043 char temp_str[VDEV_ARGS_SIZE] = {"mode=multi-core,"
14044 "ordering=enable,name=cryptodev_test_scheduler,corelist="};
14045 uint16_t worker_core_count = 0;
14046 uint16_t socket_id = 0;
14048 if (gbl_driver_id == rte_cryptodev_driver_id_get(
14049 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD))) {
14051 /* Identify the Worker Cores
14052 * Use 2 worker cores for the device args
14054 RTE_LCORE_FOREACH_WORKER(i) {
14055 if (worker_core_count > 1)
14057 snprintf(vdev_args, sizeof(vdev_args),
14058 "%s%d", temp_str, i);
14059 strcpy(temp_str, vdev_args);
14060 strlcat(temp_str, ";", sizeof(temp_str));
14061 worker_core_count++;
14062 socket_id = rte_lcore_to_socket_id(i);
14064 if (worker_core_count != 2) {
14065 RTE_LOG(ERR, USER1,
14066 "Cryptodev scheduler test require at least "
14067 "two worker cores to run. "
14068 "Please use the correct coremask.\n");
14069 return TEST_FAILED;
14071 strcpy(temp_str, vdev_args);
14072 snprintf(vdev_args, sizeof(vdev_args), "%s,socket_id=%d",
14073 temp_str, socket_id);
14074 RTE_LOG(DEBUG, USER1, "vdev_args: %s\n", vdev_args);
14075 nb_devs = rte_cryptodev_device_count_by_driver(
14076 rte_cryptodev_driver_id_get(
14077 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)));
14079 ret = rte_vdev_init(
14080 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),
14082 TEST_ASSERT(ret == 0,
14083 "Failed to create instance %u of pmd : %s",
14084 i, RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
14087 return testsuite_setup();
14091 test_scheduler_attach_worker_op(void)
14093 struct crypto_testsuite_params *ts_params = &testsuite_params;
14094 uint8_t sched_id = ts_params->valid_devs[0];
14095 uint32_t i, nb_devs_attached = 0;
14097 char vdev_name[32];
14098 unsigned int count = rte_cryptodev_count();
14100 /* create 2 AESNI_MB vdevs on top of existing devices */
14101 for (i = count; i < count + 2; i++) {
14102 snprintf(vdev_name, sizeof(vdev_name), "%s_%u",
14103 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD),
14105 ret = rte_vdev_init(vdev_name, NULL);
14107 TEST_ASSERT(ret == 0,
14108 "Failed to create instance %u of"
14110 i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
14113 RTE_LOG(ERR, USER1,
14114 "Failed to create 2 AESNI MB PMDs.\n");
14115 return TEST_SKIPPED;
14119 /* attach 2 AESNI_MB cdevs */
14120 for (i = count; i < count + 2; i++) {
14121 struct rte_cryptodev_info info;
14122 unsigned int session_size;
14124 rte_cryptodev_info_get(i, &info);
14125 if (info.driver_id != rte_cryptodev_driver_id_get(
14126 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)))
14129 session_size = rte_cryptodev_sym_get_private_session_size(i);
14131 * Create the session mempool again, since now there are new devices
14132 * to use the mempool.
14134 if (ts_params->session_mpool) {
14135 rte_mempool_free(ts_params->session_mpool);
14136 ts_params->session_mpool = NULL;
14138 if (ts_params->session_priv_mpool) {
14139 rte_mempool_free(ts_params->session_priv_mpool);
14140 ts_params->session_priv_mpool = NULL;
14143 if (info.sym.max_nb_sessions != 0 &&
14144 info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
14145 RTE_LOG(ERR, USER1,
14146 "Device does not support "
14147 "at least %u sessions\n",
14149 return TEST_FAILED;
14152 * Create mempool with maximum number of sessions,
14153 * to include the session headers
14155 if (ts_params->session_mpool == NULL) {
14156 ts_params->session_mpool =
14157 rte_cryptodev_sym_session_pool_create(
14159 MAX_NB_SESSIONS, 0, 0, 0,
14161 TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
14162 "session mempool allocation failed");
14166 * Create mempool with maximum number of sessions,
14167 * to include device specific session private data
14169 if (ts_params->session_priv_mpool == NULL) {
14170 ts_params->session_priv_mpool = rte_mempool_create(
14171 "test_sess_mp_priv",
14174 0, 0, NULL, NULL, NULL,
14175 NULL, SOCKET_ID_ANY,
14178 TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
14179 "session mempool allocation failed");
14182 ts_params->qp_conf.mp_session = ts_params->session_mpool;
14183 ts_params->qp_conf.mp_session_private =
14184 ts_params->session_priv_mpool;
14186 ret = rte_cryptodev_scheduler_worker_attach(sched_id,
14189 TEST_ASSERT(ret == 0,
14190 "Failed to attach device %u of pmd : %s", i,
14191 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
14193 aesni_ids[nb_devs_attached] = (uint8_t)i;
14195 nb_devs_attached++;
14202 test_scheduler_detach_worker_op(void)
14204 struct crypto_testsuite_params *ts_params = &testsuite_params;
14205 uint8_t sched_id = ts_params->valid_devs[0];
14209 for (i = 0; i < 2; i++) {
14210 ret = rte_cryptodev_scheduler_worker_detach(sched_id,
14212 TEST_ASSERT(ret == 0,
14213 "Failed to detach device %u", aesni_ids[i]);
14220 test_scheduler_mode_op(enum rte_cryptodev_scheduler_mode scheduler_mode)
14222 struct crypto_testsuite_params *ts_params = &testsuite_params;
14223 uint8_t sched_id = ts_params->valid_devs[0];
14225 return rte_cryptodev_scheduler_mode_set(sched_id,
14230 test_scheduler_mode_roundrobin_op(void)
14232 TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) ==
14233 0, "Failed to set roundrobin mode");
14239 test_scheduler_mode_multicore_op(void)
14241 TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) ==
14242 0, "Failed to set multicore mode");
14248 test_scheduler_mode_failover_op(void)
14250 TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) ==
14251 0, "Failed to set failover mode");
14257 test_scheduler_mode_pkt_size_distr_op(void)
14259 TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) ==
14260 0, "Failed to set pktsize mode");
14266 scheduler_multicore_testsuite_setup(void)
14268 if (test_scheduler_attach_worker_op() < 0)
14269 return TEST_SKIPPED;
14270 if (test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) < 0)
14271 return TEST_SKIPPED;
14276 scheduler_roundrobin_testsuite_setup(void)
14278 if (test_scheduler_attach_worker_op() < 0)
14279 return TEST_SKIPPED;
14280 if (test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) < 0)
14281 return TEST_SKIPPED;
14286 scheduler_failover_testsuite_setup(void)
14288 if (test_scheduler_attach_worker_op() < 0)
14289 return TEST_SKIPPED;
14290 if (test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) < 0)
14291 return TEST_SKIPPED;
14296 scheduler_pkt_size_distr_testsuite_setup(void)
14298 if (test_scheduler_attach_worker_op() < 0)
14299 return TEST_SKIPPED;
14300 if (test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) < 0)
14301 return TEST_SKIPPED;
14306 scheduler_mode_testsuite_teardown(void)
14308 test_scheduler_detach_worker_op();
14311 #endif /* RTE_CRYPTO_SCHEDULER */
14313 static struct unit_test_suite end_testsuite = {
14314 .suite_name = NULL,
14317 .unit_test_suites = NULL
14320 #ifdef RTE_LIB_SECURITY
14321 static struct unit_test_suite ipsec_proto_testsuite = {
14322 .suite_name = "IPsec Proto Unit Test Suite",
14323 .setup = ipsec_proto_testsuite_setup,
14324 .unit_test_cases = {
14325 TEST_CASE_NAMED_WITH_DATA(
14326 "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 128)",
14327 ut_setup_security, ut_teardown,
14328 test_ipsec_proto_known_vec, &pkt_aes_128_gcm),
14329 TEST_CASE_NAMED_WITH_DATA(
14330 "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 192)",
14331 ut_setup_security, ut_teardown,
14332 test_ipsec_proto_known_vec, &pkt_aes_192_gcm),
14333 TEST_CASE_NAMED_WITH_DATA(
14334 "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 256)",
14335 ut_setup_security, ut_teardown,
14336 test_ipsec_proto_known_vec, &pkt_aes_256_gcm),
14337 TEST_CASE_NAMED_WITH_DATA(
14338 "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 128)",
14339 ut_setup_security, ut_teardown,
14340 test_ipsec_proto_known_vec_inb, &pkt_aes_128_gcm),
14341 TEST_CASE_NAMED_WITH_DATA(
14342 "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 192)",
14343 ut_setup_security, ut_teardown,
14344 test_ipsec_proto_known_vec_inb, &pkt_aes_192_gcm),
14345 TEST_CASE_NAMED_WITH_DATA(
14346 "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 256)",
14347 ut_setup_security, ut_teardown,
14348 test_ipsec_proto_known_vec_inb, &pkt_aes_256_gcm),
14349 TEST_CASE_NAMED_ST(
14350 "Combined test alg list",
14351 ut_setup_security, ut_teardown,
14352 test_ipsec_proto_display_list),
14353 TEST_CASE_NAMED_ST(
14355 ut_setup_security, ut_teardown,
14356 test_ipsec_proto_iv_gen),
14357 TEST_CASE_NAMED_ST(
14358 "UDP encapsulation",
14359 ut_setup_security, ut_teardown,
14360 test_ipsec_proto_udp_encap),
14361 TEST_CASE_NAMED_ST(
14362 "UDP encapsulation ports verification test",
14363 ut_setup_security, ut_teardown,
14364 test_ipsec_proto_udp_ports_verify),
14365 TEST_CASE_NAMED_ST(
14366 "SA expiry packets soft",
14367 ut_setup_security, ut_teardown,
14368 test_ipsec_proto_sa_exp_pkts_soft),
14369 TEST_CASE_NAMED_ST(
14370 "SA expiry packets hard",
14371 ut_setup_security, ut_teardown,
14372 test_ipsec_proto_sa_exp_pkts_hard),
14373 TEST_CASE_NAMED_ST(
14374 "Negative test: ICV corruption",
14375 ut_setup_security, ut_teardown,
14376 test_ipsec_proto_err_icv_corrupt),
14377 TEST_CASE_NAMED_ST(
14378 "Tunnel dst addr verification",
14379 ut_setup_security, ut_teardown,
14380 test_ipsec_proto_tunnel_dst_addr_verify),
14381 TEST_CASE_NAMED_ST(
14382 "Tunnel src and dst addr verification",
14383 ut_setup_security, ut_teardown,
14384 test_ipsec_proto_tunnel_src_dst_addr_verify),
14385 TEST_CASE_NAMED_ST(
14386 "Inner IP checksum",
14387 ut_setup_security, ut_teardown,
14388 test_ipsec_proto_inner_ip_csum),
14389 TEST_CASE_NAMED_ST(
14390 "Inner L4 checksum",
14391 ut_setup_security, ut_teardown,
14392 test_ipsec_proto_inner_l4_csum),
14393 TEST_CASES_END() /**< NULL terminate unit test array */
14397 static struct unit_test_suite pdcp_proto_testsuite = {
14398 .suite_name = "PDCP Proto Unit Test Suite",
14399 .setup = pdcp_proto_testsuite_setup,
14400 .unit_test_cases = {
14401 TEST_CASE_ST(ut_setup_security, ut_teardown,
14402 test_PDCP_PROTO_all),
14403 TEST_CASES_END() /**< NULL terminate unit test array */
14407 #define ADD_UPLINK_TESTCASE(data) \
14408 TEST_CASE_NAMED_WITH_DATA(data.test_descr_uplink, ut_setup_security, \
14409 ut_teardown, test_docsis_proto_uplink, (const void *) &data), \
14411 #define ADD_DOWNLINK_TESTCASE(data) \
14412 TEST_CASE_NAMED_WITH_DATA(data.test_descr_downlink, ut_setup_security, \
14413 ut_teardown, test_docsis_proto_downlink, (const void *) &data), \
14415 static struct unit_test_suite docsis_proto_testsuite = {
14416 .suite_name = "DOCSIS Proto Unit Test Suite",
14417 .setup = docsis_proto_testsuite_setup,
14418 .unit_test_cases = {
14420 ADD_UPLINK_TESTCASE(docsis_test_case_1)
14421 ADD_UPLINK_TESTCASE(docsis_test_case_2)
14422 ADD_UPLINK_TESTCASE(docsis_test_case_3)
14423 ADD_UPLINK_TESTCASE(docsis_test_case_4)
14424 ADD_UPLINK_TESTCASE(docsis_test_case_5)
14425 ADD_UPLINK_TESTCASE(docsis_test_case_6)
14426 ADD_UPLINK_TESTCASE(docsis_test_case_7)
14427 ADD_UPLINK_TESTCASE(docsis_test_case_8)
14428 ADD_UPLINK_TESTCASE(docsis_test_case_9)
14429 ADD_UPLINK_TESTCASE(docsis_test_case_10)
14430 ADD_UPLINK_TESTCASE(docsis_test_case_11)
14431 ADD_UPLINK_TESTCASE(docsis_test_case_12)
14432 ADD_UPLINK_TESTCASE(docsis_test_case_13)
14433 ADD_UPLINK_TESTCASE(docsis_test_case_14)
14434 ADD_UPLINK_TESTCASE(docsis_test_case_15)
14435 ADD_UPLINK_TESTCASE(docsis_test_case_16)
14436 ADD_UPLINK_TESTCASE(docsis_test_case_17)
14437 ADD_UPLINK_TESTCASE(docsis_test_case_18)
14438 ADD_UPLINK_TESTCASE(docsis_test_case_19)
14439 ADD_UPLINK_TESTCASE(docsis_test_case_20)
14440 ADD_UPLINK_TESTCASE(docsis_test_case_21)
14441 ADD_UPLINK_TESTCASE(docsis_test_case_22)
14442 ADD_UPLINK_TESTCASE(docsis_test_case_23)
14443 ADD_UPLINK_TESTCASE(docsis_test_case_24)
14444 ADD_UPLINK_TESTCASE(docsis_test_case_25)
14445 ADD_UPLINK_TESTCASE(docsis_test_case_26)
14447 ADD_DOWNLINK_TESTCASE(docsis_test_case_1)
14448 ADD_DOWNLINK_TESTCASE(docsis_test_case_2)
14449 ADD_DOWNLINK_TESTCASE(docsis_test_case_3)
14450 ADD_DOWNLINK_TESTCASE(docsis_test_case_4)
14451 ADD_DOWNLINK_TESTCASE(docsis_test_case_5)
14452 ADD_DOWNLINK_TESTCASE(docsis_test_case_6)
14453 ADD_DOWNLINK_TESTCASE(docsis_test_case_7)
14454 ADD_DOWNLINK_TESTCASE(docsis_test_case_8)
14455 ADD_DOWNLINK_TESTCASE(docsis_test_case_9)
14456 ADD_DOWNLINK_TESTCASE(docsis_test_case_10)
14457 ADD_DOWNLINK_TESTCASE(docsis_test_case_11)
14458 ADD_DOWNLINK_TESTCASE(docsis_test_case_12)
14459 ADD_DOWNLINK_TESTCASE(docsis_test_case_13)
14460 ADD_DOWNLINK_TESTCASE(docsis_test_case_14)
14461 ADD_DOWNLINK_TESTCASE(docsis_test_case_15)
14462 ADD_DOWNLINK_TESTCASE(docsis_test_case_16)
14463 ADD_DOWNLINK_TESTCASE(docsis_test_case_17)
14464 ADD_DOWNLINK_TESTCASE(docsis_test_case_18)
14465 ADD_DOWNLINK_TESTCASE(docsis_test_case_19)
14466 ADD_DOWNLINK_TESTCASE(docsis_test_case_20)
14467 ADD_DOWNLINK_TESTCASE(docsis_test_case_21)
14468 ADD_DOWNLINK_TESTCASE(docsis_test_case_22)
14469 ADD_DOWNLINK_TESTCASE(docsis_test_case_23)
14470 ADD_DOWNLINK_TESTCASE(docsis_test_case_24)
14471 ADD_DOWNLINK_TESTCASE(docsis_test_case_25)
14472 ADD_DOWNLINK_TESTCASE(docsis_test_case_26)
14473 TEST_CASES_END() /**< NULL terminate unit test array */
14478 static struct unit_test_suite cryptodev_gen_testsuite = {
14479 .suite_name = "Crypto General Unit Test Suite",
14480 .setup = crypto_gen_testsuite_setup,
14481 .unit_test_cases = {
14482 TEST_CASE_ST(ut_setup, ut_teardown,
14483 test_device_configure_invalid_dev_id),
14484 TEST_CASE_ST(ut_setup, ut_teardown,
14485 test_queue_pair_descriptor_setup),
14486 TEST_CASE_ST(ut_setup, ut_teardown,
14487 test_device_configure_invalid_queue_pair_ids),
14488 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
14489 TEST_CASE_ST(ut_setup, ut_teardown, test_enq_callback_setup),
14490 TEST_CASE_ST(ut_setup, ut_teardown, test_deq_callback_setup),
14491 TEST_CASES_END() /**< NULL terminate unit test array */
14495 static struct unit_test_suite cryptodev_negative_hmac_sha1_testsuite = {
14496 .suite_name = "Negative HMAC SHA1 Unit Test Suite",
14497 .setup = negative_hmac_sha1_testsuite_setup,
14498 .unit_test_cases = {
14499 /** Negative tests */
14500 TEST_CASE_ST(ut_setup, ut_teardown,
14501 authentication_verify_HMAC_SHA1_fail_data_corrupt),
14502 TEST_CASE_ST(ut_setup, ut_teardown,
14503 authentication_verify_HMAC_SHA1_fail_tag_corrupt),
14504 TEST_CASE_ST(ut_setup, ut_teardown,
14505 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
14506 TEST_CASE_ST(ut_setup, ut_teardown,
14507 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
14509 TEST_CASES_END() /**< NULL terminate unit test array */
14513 static struct unit_test_suite cryptodev_multi_session_testsuite = {
14514 .suite_name = "Multi Session Unit Test Suite",
14515 .setup = multi_session_testsuite_setup,
14516 .unit_test_cases = {
14517 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
14518 TEST_CASE_ST(ut_setup, ut_teardown,
14519 test_multi_session_random_usage),
14521 TEST_CASES_END() /**< NULL terminate unit test array */
14525 static struct unit_test_suite cryptodev_null_testsuite = {
14526 .suite_name = "NULL Test Suite",
14527 .setup = null_testsuite_setup,
14528 .unit_test_cases = {
14529 TEST_CASE_ST(ut_setup, ut_teardown,
14530 test_null_invalid_operation),
14531 TEST_CASE_ST(ut_setup, ut_teardown, test_null_burst_operation),
14536 static struct unit_test_suite cryptodev_aes_ccm_auth_testsuite = {
14537 .suite_name = "AES CCM Authenticated Test Suite",
14538 .setup = aes_ccm_auth_testsuite_setup,
14539 .unit_test_cases = {
14540 /** AES CCM Authenticated Encryption 128 bits key*/
14541 TEST_CASE_ST(ut_setup, ut_teardown,
14542 test_AES_CCM_authenticated_encryption_test_case_128_1),
14543 TEST_CASE_ST(ut_setup, ut_teardown,
14544 test_AES_CCM_authenticated_encryption_test_case_128_2),
14545 TEST_CASE_ST(ut_setup, ut_teardown,
14546 test_AES_CCM_authenticated_encryption_test_case_128_3),
14548 /** AES CCM Authenticated Decryption 128 bits key*/
14549 TEST_CASE_ST(ut_setup, ut_teardown,
14550 test_AES_CCM_authenticated_decryption_test_case_128_1),
14551 TEST_CASE_ST(ut_setup, ut_teardown,
14552 test_AES_CCM_authenticated_decryption_test_case_128_2),
14553 TEST_CASE_ST(ut_setup, ut_teardown,
14554 test_AES_CCM_authenticated_decryption_test_case_128_3),
14556 /** AES CCM Authenticated Encryption 192 bits key */
14557 TEST_CASE_ST(ut_setup, ut_teardown,
14558 test_AES_CCM_authenticated_encryption_test_case_192_1),
14559 TEST_CASE_ST(ut_setup, ut_teardown,
14560 test_AES_CCM_authenticated_encryption_test_case_192_2),
14561 TEST_CASE_ST(ut_setup, ut_teardown,
14562 test_AES_CCM_authenticated_encryption_test_case_192_3),
14564 /** AES CCM Authenticated Decryption 192 bits key*/
14565 TEST_CASE_ST(ut_setup, ut_teardown,
14566 test_AES_CCM_authenticated_decryption_test_case_192_1),
14567 TEST_CASE_ST(ut_setup, ut_teardown,
14568 test_AES_CCM_authenticated_decryption_test_case_192_2),
14569 TEST_CASE_ST(ut_setup, ut_teardown,
14570 test_AES_CCM_authenticated_decryption_test_case_192_3),
14572 /** AES CCM Authenticated Encryption 256 bits key */
14573 TEST_CASE_ST(ut_setup, ut_teardown,
14574 test_AES_CCM_authenticated_encryption_test_case_256_1),
14575 TEST_CASE_ST(ut_setup, ut_teardown,
14576 test_AES_CCM_authenticated_encryption_test_case_256_2),
14577 TEST_CASE_ST(ut_setup, ut_teardown,
14578 test_AES_CCM_authenticated_encryption_test_case_256_3),
14580 /** AES CCM Authenticated Decryption 256 bits key*/
14581 TEST_CASE_ST(ut_setup, ut_teardown,
14582 test_AES_CCM_authenticated_decryption_test_case_256_1),
14583 TEST_CASE_ST(ut_setup, ut_teardown,
14584 test_AES_CCM_authenticated_decryption_test_case_256_2),
14585 TEST_CASE_ST(ut_setup, ut_teardown,
14586 test_AES_CCM_authenticated_decryption_test_case_256_3),
14591 static struct unit_test_suite cryptodev_aes_gcm_auth_testsuite = {
14592 .suite_name = "AES GCM Authenticated Test Suite",
14593 .setup = aes_gcm_auth_testsuite_setup,
14594 .unit_test_cases = {
14595 /** AES GCM Authenticated Encryption */
14596 TEST_CASE_ST(ut_setup, ut_teardown,
14597 test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
14598 TEST_CASE_ST(ut_setup, ut_teardown,
14599 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
14600 TEST_CASE_ST(ut_setup, ut_teardown,
14601 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
14602 TEST_CASE_ST(ut_setup, ut_teardown,
14603 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
14604 TEST_CASE_ST(ut_setup, ut_teardown,
14605 test_AES_GCM_authenticated_encryption_test_case_1),
14606 TEST_CASE_ST(ut_setup, ut_teardown,
14607 test_AES_GCM_authenticated_encryption_test_case_2),
14608 TEST_CASE_ST(ut_setup, ut_teardown,
14609 test_AES_GCM_authenticated_encryption_test_case_3),
14610 TEST_CASE_ST(ut_setup, ut_teardown,
14611 test_AES_GCM_authenticated_encryption_test_case_4),
14612 TEST_CASE_ST(ut_setup, ut_teardown,
14613 test_AES_GCM_authenticated_encryption_test_case_5),
14614 TEST_CASE_ST(ut_setup, ut_teardown,
14615 test_AES_GCM_authenticated_encryption_test_case_6),
14616 TEST_CASE_ST(ut_setup, ut_teardown,
14617 test_AES_GCM_authenticated_encryption_test_case_7),
14618 TEST_CASE_ST(ut_setup, ut_teardown,
14619 test_AES_GCM_authenticated_encryption_test_case_8),
14620 TEST_CASE_ST(ut_setup, ut_teardown,
14621 test_AES_GCM_J0_authenticated_encryption_test_case_1),
14623 /** AES GCM Authenticated Decryption */
14624 TEST_CASE_ST(ut_setup, ut_teardown,
14625 test_AES_GCM_authenticated_decryption_test_case_1),
14626 TEST_CASE_ST(ut_setup, ut_teardown,
14627 test_AES_GCM_authenticated_decryption_test_case_2),
14628 TEST_CASE_ST(ut_setup, ut_teardown,
14629 test_AES_GCM_authenticated_decryption_test_case_3),
14630 TEST_CASE_ST(ut_setup, ut_teardown,
14631 test_AES_GCM_authenticated_decryption_test_case_4),
14632 TEST_CASE_ST(ut_setup, ut_teardown,
14633 test_AES_GCM_authenticated_decryption_test_case_5),
14634 TEST_CASE_ST(ut_setup, ut_teardown,
14635 test_AES_GCM_authenticated_decryption_test_case_6),
14636 TEST_CASE_ST(ut_setup, ut_teardown,
14637 test_AES_GCM_authenticated_decryption_test_case_7),
14638 TEST_CASE_ST(ut_setup, ut_teardown,
14639 test_AES_GCM_authenticated_decryption_test_case_8),
14640 TEST_CASE_ST(ut_setup, ut_teardown,
14641 test_AES_GCM_J0_authenticated_decryption_test_case_1),
14643 /** AES GCM Authenticated Encryption 192 bits key */
14644 TEST_CASE_ST(ut_setup, ut_teardown,
14645 test_AES_GCM_auth_encryption_test_case_192_1),
14646 TEST_CASE_ST(ut_setup, ut_teardown,
14647 test_AES_GCM_auth_encryption_test_case_192_2),
14648 TEST_CASE_ST(ut_setup, ut_teardown,
14649 test_AES_GCM_auth_encryption_test_case_192_3),
14650 TEST_CASE_ST(ut_setup, ut_teardown,
14651 test_AES_GCM_auth_encryption_test_case_192_4),
14652 TEST_CASE_ST(ut_setup, ut_teardown,
14653 test_AES_GCM_auth_encryption_test_case_192_5),
14654 TEST_CASE_ST(ut_setup, ut_teardown,
14655 test_AES_GCM_auth_encryption_test_case_192_6),
14656 TEST_CASE_ST(ut_setup, ut_teardown,
14657 test_AES_GCM_auth_encryption_test_case_192_7),
14659 /** AES GCM Authenticated Decryption 192 bits key */
14660 TEST_CASE_ST(ut_setup, ut_teardown,
14661 test_AES_GCM_auth_decryption_test_case_192_1),
14662 TEST_CASE_ST(ut_setup, ut_teardown,
14663 test_AES_GCM_auth_decryption_test_case_192_2),
14664 TEST_CASE_ST(ut_setup, ut_teardown,
14665 test_AES_GCM_auth_decryption_test_case_192_3),
14666 TEST_CASE_ST(ut_setup, ut_teardown,
14667 test_AES_GCM_auth_decryption_test_case_192_4),
14668 TEST_CASE_ST(ut_setup, ut_teardown,
14669 test_AES_GCM_auth_decryption_test_case_192_5),
14670 TEST_CASE_ST(ut_setup, ut_teardown,
14671 test_AES_GCM_auth_decryption_test_case_192_6),
14672 TEST_CASE_ST(ut_setup, ut_teardown,
14673 test_AES_GCM_auth_decryption_test_case_192_7),
14675 /** AES GCM Authenticated Encryption 256 bits key */
14676 TEST_CASE_ST(ut_setup, ut_teardown,
14677 test_AES_GCM_auth_encryption_test_case_256_1),
14678 TEST_CASE_ST(ut_setup, ut_teardown,
14679 test_AES_GCM_auth_encryption_test_case_256_2),
14680 TEST_CASE_ST(ut_setup, ut_teardown,
14681 test_AES_GCM_auth_encryption_test_case_256_3),
14682 TEST_CASE_ST(ut_setup, ut_teardown,
14683 test_AES_GCM_auth_encryption_test_case_256_4),
14684 TEST_CASE_ST(ut_setup, ut_teardown,
14685 test_AES_GCM_auth_encryption_test_case_256_5),
14686 TEST_CASE_ST(ut_setup, ut_teardown,
14687 test_AES_GCM_auth_encryption_test_case_256_6),
14688 TEST_CASE_ST(ut_setup, ut_teardown,
14689 test_AES_GCM_auth_encryption_test_case_256_7),
14691 /** AES GCM Authenticated Decryption 256 bits key */
14692 TEST_CASE_ST(ut_setup, ut_teardown,
14693 test_AES_GCM_auth_decryption_test_case_256_1),
14694 TEST_CASE_ST(ut_setup, ut_teardown,
14695 test_AES_GCM_auth_decryption_test_case_256_2),
14696 TEST_CASE_ST(ut_setup, ut_teardown,
14697 test_AES_GCM_auth_decryption_test_case_256_3),
14698 TEST_CASE_ST(ut_setup, ut_teardown,
14699 test_AES_GCM_auth_decryption_test_case_256_4),
14700 TEST_CASE_ST(ut_setup, ut_teardown,
14701 test_AES_GCM_auth_decryption_test_case_256_5),
14702 TEST_CASE_ST(ut_setup, ut_teardown,
14703 test_AES_GCM_auth_decryption_test_case_256_6),
14704 TEST_CASE_ST(ut_setup, ut_teardown,
14705 test_AES_GCM_auth_decryption_test_case_256_7),
14707 /** AES GCM Authenticated Encryption big aad size */
14708 TEST_CASE_ST(ut_setup, ut_teardown,
14709 test_AES_GCM_auth_encryption_test_case_aad_1),
14710 TEST_CASE_ST(ut_setup, ut_teardown,
14711 test_AES_GCM_auth_encryption_test_case_aad_2),
14713 /** AES GCM Authenticated Decryption big aad size */
14714 TEST_CASE_ST(ut_setup, ut_teardown,
14715 test_AES_GCM_auth_decryption_test_case_aad_1),
14716 TEST_CASE_ST(ut_setup, ut_teardown,
14717 test_AES_GCM_auth_decryption_test_case_aad_2),
14719 /** Out of place tests */
14720 TEST_CASE_ST(ut_setup, ut_teardown,
14721 test_AES_GCM_authenticated_encryption_oop_test_case_1),
14722 TEST_CASE_ST(ut_setup, ut_teardown,
14723 test_AES_GCM_authenticated_decryption_oop_test_case_1),
14725 /** Session-less tests */
14726 TEST_CASE_ST(ut_setup, ut_teardown,
14727 test_AES_GCM_authenticated_encryption_sessionless_test_case_1),
14728 TEST_CASE_ST(ut_setup, ut_teardown,
14729 test_AES_GCM_authenticated_decryption_sessionless_test_case_1),
14735 static struct unit_test_suite cryptodev_aes_gmac_auth_testsuite = {
14736 .suite_name = "AES GMAC Authentication Test Suite",
14737 .setup = aes_gmac_auth_testsuite_setup,
14738 .unit_test_cases = {
14739 TEST_CASE_ST(ut_setup, ut_teardown,
14740 test_AES_GMAC_authentication_test_case_1),
14741 TEST_CASE_ST(ut_setup, ut_teardown,
14742 test_AES_GMAC_authentication_verify_test_case_1),
14743 TEST_CASE_ST(ut_setup, ut_teardown,
14744 test_AES_GMAC_authentication_test_case_2),
14745 TEST_CASE_ST(ut_setup, ut_teardown,
14746 test_AES_GMAC_authentication_verify_test_case_2),
14747 TEST_CASE_ST(ut_setup, ut_teardown,
14748 test_AES_GMAC_authentication_test_case_3),
14749 TEST_CASE_ST(ut_setup, ut_teardown,
14750 test_AES_GMAC_authentication_verify_test_case_3),
14751 TEST_CASE_ST(ut_setup, ut_teardown,
14752 test_AES_GMAC_authentication_test_case_4),
14753 TEST_CASE_ST(ut_setup, ut_teardown,
14754 test_AES_GMAC_authentication_verify_test_case_4),
14755 TEST_CASE_ST(ut_setup, ut_teardown,
14756 test_AES_GMAC_authentication_SGL_40B),
14757 TEST_CASE_ST(ut_setup, ut_teardown,
14758 test_AES_GMAC_authentication_SGL_80B),
14759 TEST_CASE_ST(ut_setup, ut_teardown,
14760 test_AES_GMAC_authentication_SGL_2048B),
14761 TEST_CASE_ST(ut_setup, ut_teardown,
14762 test_AES_GMAC_authentication_SGL_2047B),
14768 static struct unit_test_suite cryptodev_chacha20_poly1305_testsuite = {
14769 .suite_name = "Chacha20-Poly1305 Test Suite",
14770 .setup = chacha20_poly1305_testsuite_setup,
14771 .unit_test_cases = {
14772 TEST_CASE_ST(ut_setup, ut_teardown,
14773 test_chacha20_poly1305_encrypt_test_case_rfc8439),
14774 TEST_CASE_ST(ut_setup, ut_teardown,
14775 test_chacha20_poly1305_decrypt_test_case_rfc8439),
14776 TEST_CASE_ST(ut_setup, ut_teardown,
14777 test_chacha20_poly1305_encrypt_SGL_out_of_place),
14782 static struct unit_test_suite cryptodev_snow3g_testsuite = {
14783 .suite_name = "SNOW 3G Test Suite",
14784 .setup = snow3g_testsuite_setup,
14785 .unit_test_cases = {
14786 /** SNOW 3G encrypt only (UEA2) */
14787 TEST_CASE_ST(ut_setup, ut_teardown,
14788 test_snow3g_encryption_test_case_1),
14789 TEST_CASE_ST(ut_setup, ut_teardown,
14790 test_snow3g_encryption_test_case_2),
14791 TEST_CASE_ST(ut_setup, ut_teardown,
14792 test_snow3g_encryption_test_case_3),
14793 TEST_CASE_ST(ut_setup, ut_teardown,
14794 test_snow3g_encryption_test_case_4),
14795 TEST_CASE_ST(ut_setup, ut_teardown,
14796 test_snow3g_encryption_test_case_5),
14798 TEST_CASE_ST(ut_setup, ut_teardown,
14799 test_snow3g_encryption_test_case_1_oop),
14800 TEST_CASE_ST(ut_setup, ut_teardown,
14801 test_snow3g_encryption_test_case_1_oop_sgl),
14802 TEST_CASE_ST(ut_setup, ut_teardown,
14803 test_snow3g_encryption_test_case_1_offset_oop),
14804 TEST_CASE_ST(ut_setup, ut_teardown,
14805 test_snow3g_decryption_test_case_1_oop),
14807 /** SNOW 3G generate auth, then encrypt (UEA2) */
14808 TEST_CASE_ST(ut_setup, ut_teardown,
14809 test_snow3g_auth_cipher_test_case_1),
14810 TEST_CASE_ST(ut_setup, ut_teardown,
14811 test_snow3g_auth_cipher_test_case_2),
14812 TEST_CASE_ST(ut_setup, ut_teardown,
14813 test_snow3g_auth_cipher_test_case_2_oop),
14814 TEST_CASE_ST(ut_setup, ut_teardown,
14815 test_snow3g_auth_cipher_part_digest_enc),
14816 TEST_CASE_ST(ut_setup, ut_teardown,
14817 test_snow3g_auth_cipher_part_digest_enc_oop),
14818 TEST_CASE_ST(ut_setup, ut_teardown,
14819 test_snow3g_auth_cipher_test_case_3_sgl),
14820 TEST_CASE_ST(ut_setup, ut_teardown,
14821 test_snow3g_auth_cipher_test_case_3_oop_sgl),
14822 TEST_CASE_ST(ut_setup, ut_teardown,
14823 test_snow3g_auth_cipher_part_digest_enc_sgl),
14824 TEST_CASE_ST(ut_setup, ut_teardown,
14825 test_snow3g_auth_cipher_part_digest_enc_oop_sgl),
14827 /** SNOW 3G decrypt (UEA2), then verify auth */
14828 TEST_CASE_ST(ut_setup, ut_teardown,
14829 test_snow3g_auth_cipher_verify_test_case_1),
14830 TEST_CASE_ST(ut_setup, ut_teardown,
14831 test_snow3g_auth_cipher_verify_test_case_2),
14832 TEST_CASE_ST(ut_setup, ut_teardown,
14833 test_snow3g_auth_cipher_verify_test_case_2_oop),
14834 TEST_CASE_ST(ut_setup, ut_teardown,
14835 test_snow3g_auth_cipher_verify_part_digest_enc),
14836 TEST_CASE_ST(ut_setup, ut_teardown,
14837 test_snow3g_auth_cipher_verify_part_digest_enc_oop),
14838 TEST_CASE_ST(ut_setup, ut_teardown,
14839 test_snow3g_auth_cipher_verify_test_case_3_sgl),
14840 TEST_CASE_ST(ut_setup, ut_teardown,
14841 test_snow3g_auth_cipher_verify_test_case_3_oop_sgl),
14842 TEST_CASE_ST(ut_setup, ut_teardown,
14843 test_snow3g_auth_cipher_verify_part_digest_enc_sgl),
14844 TEST_CASE_ST(ut_setup, ut_teardown,
14845 test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl),
14847 /** SNOW 3G decrypt only (UEA2) */
14848 TEST_CASE_ST(ut_setup, ut_teardown,
14849 test_snow3g_decryption_test_case_1),
14850 TEST_CASE_ST(ut_setup, ut_teardown,
14851 test_snow3g_decryption_test_case_2),
14852 TEST_CASE_ST(ut_setup, ut_teardown,
14853 test_snow3g_decryption_test_case_3),
14854 TEST_CASE_ST(ut_setup, ut_teardown,
14855 test_snow3g_decryption_test_case_4),
14856 TEST_CASE_ST(ut_setup, ut_teardown,
14857 test_snow3g_decryption_test_case_5),
14858 TEST_CASE_ST(ut_setup, ut_teardown,
14859 test_snow3g_decryption_with_digest_test_case_1),
14860 TEST_CASE_ST(ut_setup, ut_teardown,
14861 test_snow3g_hash_generate_test_case_1),
14862 TEST_CASE_ST(ut_setup, ut_teardown,
14863 test_snow3g_hash_generate_test_case_2),
14864 TEST_CASE_ST(ut_setup, ut_teardown,
14865 test_snow3g_hash_generate_test_case_3),
14867 /* Tests with buffers which length is not byte-aligned */
14868 TEST_CASE_ST(ut_setup, ut_teardown,
14869 test_snow3g_hash_generate_test_case_4),
14870 TEST_CASE_ST(ut_setup, ut_teardown,
14871 test_snow3g_hash_generate_test_case_5),
14872 TEST_CASE_ST(ut_setup, ut_teardown,
14873 test_snow3g_hash_generate_test_case_6),
14874 TEST_CASE_ST(ut_setup, ut_teardown,
14875 test_snow3g_hash_verify_test_case_1),
14876 TEST_CASE_ST(ut_setup, ut_teardown,
14877 test_snow3g_hash_verify_test_case_2),
14878 TEST_CASE_ST(ut_setup, ut_teardown,
14879 test_snow3g_hash_verify_test_case_3),
14881 /* Tests with buffers which length is not byte-aligned */
14882 TEST_CASE_ST(ut_setup, ut_teardown,
14883 test_snow3g_hash_verify_test_case_4),
14884 TEST_CASE_ST(ut_setup, ut_teardown,
14885 test_snow3g_hash_verify_test_case_5),
14886 TEST_CASE_ST(ut_setup, ut_teardown,
14887 test_snow3g_hash_verify_test_case_6),
14888 TEST_CASE_ST(ut_setup, ut_teardown,
14889 test_snow3g_cipher_auth_test_case_1),
14890 TEST_CASE_ST(ut_setup, ut_teardown,
14891 test_snow3g_auth_cipher_with_digest_test_case_1),
14896 static struct unit_test_suite cryptodev_zuc_testsuite = {
14897 .suite_name = "ZUC Test Suite",
14898 .setup = zuc_testsuite_setup,
14899 .unit_test_cases = {
14900 /** ZUC encrypt only (EEA3) */
14901 TEST_CASE_ST(ut_setup, ut_teardown,
14902 test_zuc_encryption_test_case_1),
14903 TEST_CASE_ST(ut_setup, ut_teardown,
14904 test_zuc_encryption_test_case_2),
14905 TEST_CASE_ST(ut_setup, ut_teardown,
14906 test_zuc_encryption_test_case_3),
14907 TEST_CASE_ST(ut_setup, ut_teardown,
14908 test_zuc_encryption_test_case_4),
14909 TEST_CASE_ST(ut_setup, ut_teardown,
14910 test_zuc_encryption_test_case_5),
14911 TEST_CASE_ST(ut_setup, ut_teardown,
14912 test_zuc_encryption_test_case_6_sgl),
14914 /** ZUC authenticate (EIA3) */
14915 TEST_CASE_ST(ut_setup, ut_teardown,
14916 test_zuc_hash_generate_test_case_1),
14917 TEST_CASE_ST(ut_setup, ut_teardown,
14918 test_zuc_hash_generate_test_case_2),
14919 TEST_CASE_ST(ut_setup, ut_teardown,
14920 test_zuc_hash_generate_test_case_3),
14921 TEST_CASE_ST(ut_setup, ut_teardown,
14922 test_zuc_hash_generate_test_case_4),
14923 TEST_CASE_ST(ut_setup, ut_teardown,
14924 test_zuc_hash_generate_test_case_5),
14925 TEST_CASE_ST(ut_setup, ut_teardown,
14926 test_zuc_hash_generate_test_case_6),
14927 TEST_CASE_ST(ut_setup, ut_teardown,
14928 test_zuc_hash_generate_test_case_7),
14929 TEST_CASE_ST(ut_setup, ut_teardown,
14930 test_zuc_hash_generate_test_case_8),
14931 TEST_CASE_ST(ut_setup, ut_teardown,
14932 test_zuc_hash_generate_test_case_9),
14933 TEST_CASE_ST(ut_setup, ut_teardown,
14934 test_zuc_hash_generate_test_case_10),
14935 TEST_CASE_ST(ut_setup, ut_teardown,
14936 test_zuc_hash_generate_test_case_11),
14939 /** ZUC alg-chain (EEA3/EIA3) */
14940 TEST_CASE_ST(ut_setup, ut_teardown,
14941 test_zuc_cipher_auth_test_case_1),
14942 TEST_CASE_ST(ut_setup, ut_teardown,
14943 test_zuc_cipher_auth_test_case_2),
14945 /** ZUC generate auth, then encrypt (EEA3) */
14946 TEST_CASE_ST(ut_setup, ut_teardown,
14947 test_zuc_auth_cipher_test_case_1),
14948 TEST_CASE_ST(ut_setup, ut_teardown,
14949 test_zuc_auth_cipher_test_case_1_oop),
14950 TEST_CASE_ST(ut_setup, ut_teardown,
14951 test_zuc_auth_cipher_test_case_1_sgl),
14952 TEST_CASE_ST(ut_setup, ut_teardown,
14953 test_zuc_auth_cipher_test_case_1_oop_sgl),
14955 /** ZUC decrypt (EEA3), then verify auth */
14956 TEST_CASE_ST(ut_setup, ut_teardown,
14957 test_zuc_auth_cipher_verify_test_case_1),
14958 TEST_CASE_ST(ut_setup, ut_teardown,
14959 test_zuc_auth_cipher_verify_test_case_1_oop),
14960 TEST_CASE_ST(ut_setup, ut_teardown,
14961 test_zuc_auth_cipher_verify_test_case_1_sgl),
14962 TEST_CASE_ST(ut_setup, ut_teardown,
14963 test_zuc_auth_cipher_verify_test_case_1_oop_sgl),
14965 /** ZUC-256 encrypt only **/
14966 TEST_CASE_ST(ut_setup, ut_teardown,
14967 test_zuc256_encryption_test_case_1),
14968 TEST_CASE_ST(ut_setup, ut_teardown,
14969 test_zuc256_encryption_test_case_2),
14971 /** ZUC-256 authentication only **/
14972 TEST_CASE_ST(ut_setup, ut_teardown,
14973 test_zuc256_authentication_test_case_1),
14974 TEST_CASE_ST(ut_setup, ut_teardown,
14975 test_zuc256_authentication_test_case_2),
14981 static struct unit_test_suite cryptodev_hmac_md5_auth_testsuite = {
14982 .suite_name = "HMAC_MD5 Authentication Test Suite",
14983 .setup = hmac_md5_auth_testsuite_setup,
14984 .unit_test_cases = {
14985 TEST_CASE_ST(ut_setup, ut_teardown,
14986 test_MD5_HMAC_generate_case_1),
14987 TEST_CASE_ST(ut_setup, ut_teardown,
14988 test_MD5_HMAC_verify_case_1),
14989 TEST_CASE_ST(ut_setup, ut_teardown,
14990 test_MD5_HMAC_generate_case_2),
14991 TEST_CASE_ST(ut_setup, ut_teardown,
14992 test_MD5_HMAC_verify_case_2),
14997 static struct unit_test_suite cryptodev_kasumi_testsuite = {
14998 .suite_name = "Kasumi Test Suite",
14999 .setup = kasumi_testsuite_setup,
15000 .unit_test_cases = {
15001 /** KASUMI hash only (UIA1) */
15002 TEST_CASE_ST(ut_setup, ut_teardown,
15003 test_kasumi_hash_generate_test_case_1),
15004 TEST_CASE_ST(ut_setup, ut_teardown,
15005 test_kasumi_hash_generate_test_case_2),
15006 TEST_CASE_ST(ut_setup, ut_teardown,
15007 test_kasumi_hash_generate_test_case_3),
15008 TEST_CASE_ST(ut_setup, ut_teardown,
15009 test_kasumi_hash_generate_test_case_4),
15010 TEST_CASE_ST(ut_setup, ut_teardown,
15011 test_kasumi_hash_generate_test_case_5),
15012 TEST_CASE_ST(ut_setup, ut_teardown,
15013 test_kasumi_hash_generate_test_case_6),
15015 TEST_CASE_ST(ut_setup, ut_teardown,
15016 test_kasumi_hash_verify_test_case_1),
15017 TEST_CASE_ST(ut_setup, ut_teardown,
15018 test_kasumi_hash_verify_test_case_2),
15019 TEST_CASE_ST(ut_setup, ut_teardown,
15020 test_kasumi_hash_verify_test_case_3),
15021 TEST_CASE_ST(ut_setup, ut_teardown,
15022 test_kasumi_hash_verify_test_case_4),
15023 TEST_CASE_ST(ut_setup, ut_teardown,
15024 test_kasumi_hash_verify_test_case_5),
15026 /** KASUMI encrypt only (UEA1) */
15027 TEST_CASE_ST(ut_setup, ut_teardown,
15028 test_kasumi_encryption_test_case_1),
15029 TEST_CASE_ST(ut_setup, ut_teardown,
15030 test_kasumi_encryption_test_case_1_sgl),
15031 TEST_CASE_ST(ut_setup, ut_teardown,
15032 test_kasumi_encryption_test_case_1_oop),
15033 TEST_CASE_ST(ut_setup, ut_teardown,
15034 test_kasumi_encryption_test_case_1_oop_sgl),
15035 TEST_CASE_ST(ut_setup, ut_teardown,
15036 test_kasumi_encryption_test_case_2),
15037 TEST_CASE_ST(ut_setup, ut_teardown,
15038 test_kasumi_encryption_test_case_3),
15039 TEST_CASE_ST(ut_setup, ut_teardown,
15040 test_kasumi_encryption_test_case_4),
15041 TEST_CASE_ST(ut_setup, ut_teardown,
15042 test_kasumi_encryption_test_case_5),
15044 /** KASUMI decrypt only (UEA1) */
15045 TEST_CASE_ST(ut_setup, ut_teardown,
15046 test_kasumi_decryption_test_case_1),
15047 TEST_CASE_ST(ut_setup, ut_teardown,
15048 test_kasumi_decryption_test_case_2),
15049 TEST_CASE_ST(ut_setup, ut_teardown,
15050 test_kasumi_decryption_test_case_3),
15051 TEST_CASE_ST(ut_setup, ut_teardown,
15052 test_kasumi_decryption_test_case_4),
15053 TEST_CASE_ST(ut_setup, ut_teardown,
15054 test_kasumi_decryption_test_case_5),
15055 TEST_CASE_ST(ut_setup, ut_teardown,
15056 test_kasumi_decryption_test_case_1_oop),
15057 TEST_CASE_ST(ut_setup, ut_teardown,
15058 test_kasumi_cipher_auth_test_case_1),
15060 /** KASUMI generate auth, then encrypt (F8) */
15061 TEST_CASE_ST(ut_setup, ut_teardown,
15062 test_kasumi_auth_cipher_test_case_1),
15063 TEST_CASE_ST(ut_setup, ut_teardown,
15064 test_kasumi_auth_cipher_test_case_2),
15065 TEST_CASE_ST(ut_setup, ut_teardown,
15066 test_kasumi_auth_cipher_test_case_2_oop),
15067 TEST_CASE_ST(ut_setup, ut_teardown,
15068 test_kasumi_auth_cipher_test_case_2_sgl),
15069 TEST_CASE_ST(ut_setup, ut_teardown,
15070 test_kasumi_auth_cipher_test_case_2_oop_sgl),
15072 /** KASUMI decrypt (F8), then verify auth */
15073 TEST_CASE_ST(ut_setup, ut_teardown,
15074 test_kasumi_auth_cipher_verify_test_case_1),
15075 TEST_CASE_ST(ut_setup, ut_teardown,
15076 test_kasumi_auth_cipher_verify_test_case_2),
15077 TEST_CASE_ST(ut_setup, ut_teardown,
15078 test_kasumi_auth_cipher_verify_test_case_2_oop),
15079 TEST_CASE_ST(ut_setup, ut_teardown,
15080 test_kasumi_auth_cipher_verify_test_case_2_sgl),
15081 TEST_CASE_ST(ut_setup, ut_teardown,
15082 test_kasumi_auth_cipher_verify_test_case_2_oop_sgl),
15088 static struct unit_test_suite cryptodev_esn_testsuite = {
15089 .suite_name = "ESN Test Suite",
15090 .setup = esn_testsuite_setup,
15091 .unit_test_cases = {
15092 TEST_CASE_ST(ut_setup, ut_teardown,
15093 auth_encrypt_AES128CBC_HMAC_SHA1_esn_check),
15094 TEST_CASE_ST(ut_setup, ut_teardown,
15095 auth_decrypt_AES128CBC_HMAC_SHA1_esn_check),
15100 static struct unit_test_suite cryptodev_negative_aes_gcm_testsuite = {
15101 .suite_name = "Negative AES GCM Test Suite",
15102 .setup = negative_aes_gcm_testsuite_setup,
15103 .unit_test_cases = {
15104 TEST_CASE_ST(ut_setup, ut_teardown,
15105 test_AES_GCM_auth_encryption_fail_iv_corrupt),
15106 TEST_CASE_ST(ut_setup, ut_teardown,
15107 test_AES_GCM_auth_encryption_fail_in_data_corrupt),
15108 TEST_CASE_ST(ut_setup, ut_teardown,
15109 test_AES_GCM_auth_encryption_fail_out_data_corrupt),
15110 TEST_CASE_ST(ut_setup, ut_teardown,
15111 test_AES_GCM_auth_encryption_fail_aad_len_corrupt),
15112 TEST_CASE_ST(ut_setup, ut_teardown,
15113 test_AES_GCM_auth_encryption_fail_aad_corrupt),
15114 TEST_CASE_ST(ut_setup, ut_teardown,
15115 test_AES_GCM_auth_encryption_fail_tag_corrupt),
15116 TEST_CASE_ST(ut_setup, ut_teardown,
15117 test_AES_GCM_auth_decryption_fail_iv_corrupt),
15118 TEST_CASE_ST(ut_setup, ut_teardown,
15119 test_AES_GCM_auth_decryption_fail_in_data_corrupt),
15120 TEST_CASE_ST(ut_setup, ut_teardown,
15121 test_AES_GCM_auth_decryption_fail_out_data_corrupt),
15122 TEST_CASE_ST(ut_setup, ut_teardown,
15123 test_AES_GCM_auth_decryption_fail_aad_len_corrupt),
15124 TEST_CASE_ST(ut_setup, ut_teardown,
15125 test_AES_GCM_auth_decryption_fail_aad_corrupt),
15126 TEST_CASE_ST(ut_setup, ut_teardown,
15127 test_AES_GCM_auth_decryption_fail_tag_corrupt),
15133 static struct unit_test_suite cryptodev_negative_aes_gmac_testsuite = {
15134 .suite_name = "Negative AES GMAC Test Suite",
15135 .setup = negative_aes_gmac_testsuite_setup,
15136 .unit_test_cases = {
15137 TEST_CASE_ST(ut_setup, ut_teardown,
15138 authentication_verify_AES128_GMAC_fail_data_corrupt),
15139 TEST_CASE_ST(ut_setup, ut_teardown,
15140 authentication_verify_AES128_GMAC_fail_tag_corrupt),
15146 static struct unit_test_suite cryptodev_mixed_cipher_hash_testsuite = {
15147 .suite_name = "Mixed CIPHER + HASH algorithms Test Suite",
15148 .setup = mixed_cipher_hash_testsuite_setup,
15149 .unit_test_cases = {
15150 /** AUTH AES CMAC + CIPHER AES CTR */
15151 TEST_CASE_ST(ut_setup, ut_teardown,
15152 test_aes_cmac_aes_ctr_digest_enc_test_case_1),
15153 TEST_CASE_ST(ut_setup, ut_teardown,
15154 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
15155 TEST_CASE_ST(ut_setup, ut_teardown,
15156 test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
15157 TEST_CASE_ST(ut_setup, ut_teardown,
15158 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
15159 TEST_CASE_ST(ut_setup, ut_teardown,
15160 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1),
15161 TEST_CASE_ST(ut_setup, ut_teardown,
15162 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
15163 TEST_CASE_ST(ut_setup, ut_teardown,
15164 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
15165 TEST_CASE_ST(ut_setup, ut_teardown,
15166 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
15168 /** AUTH ZUC + CIPHER SNOW3G */
15169 TEST_CASE_ST(ut_setup, ut_teardown,
15170 test_auth_zuc_cipher_snow_test_case_1),
15171 TEST_CASE_ST(ut_setup, ut_teardown,
15172 test_verify_auth_zuc_cipher_snow_test_case_1),
15173 /** AUTH AES CMAC + CIPHER SNOW3G */
15174 TEST_CASE_ST(ut_setup, ut_teardown,
15175 test_auth_aes_cmac_cipher_snow_test_case_1),
15176 TEST_CASE_ST(ut_setup, ut_teardown,
15177 test_verify_auth_aes_cmac_cipher_snow_test_case_1),
15178 /** AUTH ZUC + CIPHER AES CTR */
15179 TEST_CASE_ST(ut_setup, ut_teardown,
15180 test_auth_zuc_cipher_aes_ctr_test_case_1),
15181 TEST_CASE_ST(ut_setup, ut_teardown,
15182 test_verify_auth_zuc_cipher_aes_ctr_test_case_1),
15183 /** AUTH SNOW3G + CIPHER AES CTR */
15184 TEST_CASE_ST(ut_setup, ut_teardown,
15185 test_auth_snow_cipher_aes_ctr_test_case_1),
15186 TEST_CASE_ST(ut_setup, ut_teardown,
15187 test_verify_auth_snow_cipher_aes_ctr_test_case_1),
15188 /** AUTH SNOW3G + CIPHER ZUC */
15189 TEST_CASE_ST(ut_setup, ut_teardown,
15190 test_auth_snow_cipher_zuc_test_case_1),
15191 TEST_CASE_ST(ut_setup, ut_teardown,
15192 test_verify_auth_snow_cipher_zuc_test_case_1),
15193 /** AUTH AES CMAC + CIPHER ZUC */
15194 TEST_CASE_ST(ut_setup, ut_teardown,
15195 test_auth_aes_cmac_cipher_zuc_test_case_1),
15196 TEST_CASE_ST(ut_setup, ut_teardown,
15197 test_verify_auth_aes_cmac_cipher_zuc_test_case_1),
15199 /** AUTH NULL + CIPHER SNOW3G */
15200 TEST_CASE_ST(ut_setup, ut_teardown,
15201 test_auth_null_cipher_snow_test_case_1),
15202 TEST_CASE_ST(ut_setup, ut_teardown,
15203 test_verify_auth_null_cipher_snow_test_case_1),
15204 /** AUTH NULL + CIPHER ZUC */
15205 TEST_CASE_ST(ut_setup, ut_teardown,
15206 test_auth_null_cipher_zuc_test_case_1),
15207 TEST_CASE_ST(ut_setup, ut_teardown,
15208 test_verify_auth_null_cipher_zuc_test_case_1),
15209 /** AUTH SNOW3G + CIPHER NULL */
15210 TEST_CASE_ST(ut_setup, ut_teardown,
15211 test_auth_snow_cipher_null_test_case_1),
15212 TEST_CASE_ST(ut_setup, ut_teardown,
15213 test_verify_auth_snow_cipher_null_test_case_1),
15214 /** AUTH ZUC + CIPHER NULL */
15215 TEST_CASE_ST(ut_setup, ut_teardown,
15216 test_auth_zuc_cipher_null_test_case_1),
15217 TEST_CASE_ST(ut_setup, ut_teardown,
15218 test_verify_auth_zuc_cipher_null_test_case_1),
15219 /** AUTH NULL + CIPHER AES CTR */
15220 TEST_CASE_ST(ut_setup, ut_teardown,
15221 test_auth_null_cipher_aes_ctr_test_case_1),
15222 TEST_CASE_ST(ut_setup, ut_teardown,
15223 test_verify_auth_null_cipher_aes_ctr_test_case_1),
15224 /** AUTH AES CMAC + CIPHER NULL */
15225 TEST_CASE_ST(ut_setup, ut_teardown,
15226 test_auth_aes_cmac_cipher_null_test_case_1),
15227 TEST_CASE_ST(ut_setup, ut_teardown,
15228 test_verify_auth_aes_cmac_cipher_null_test_case_1),
15234 run_cryptodev_testsuite(const char *pmd_name)
15236 uint8_t ret, j, i = 0, blk_start_idx = 0;
15237 const enum blockcipher_test_type blk_suites[] = {
15238 BLKCIPHER_AES_CHAIN_TYPE,
15239 BLKCIPHER_AES_CIPHERONLY_TYPE,
15240 BLKCIPHER_AES_DOCSIS_TYPE,
15241 BLKCIPHER_3DES_CHAIN_TYPE,
15242 BLKCIPHER_3DES_CIPHERONLY_TYPE,
15243 BLKCIPHER_DES_CIPHERONLY_TYPE,
15244 BLKCIPHER_DES_DOCSIS_TYPE,
15245 BLKCIPHER_AUTHONLY_TYPE};
15246 struct unit_test_suite *static_suites[] = {
15247 &cryptodev_multi_session_testsuite,
15248 &cryptodev_null_testsuite,
15249 &cryptodev_aes_ccm_auth_testsuite,
15250 &cryptodev_aes_gcm_auth_testsuite,
15251 &cryptodev_aes_gmac_auth_testsuite,
15252 &cryptodev_snow3g_testsuite,
15253 &cryptodev_chacha20_poly1305_testsuite,
15254 &cryptodev_zuc_testsuite,
15255 &cryptodev_hmac_md5_auth_testsuite,
15256 &cryptodev_kasumi_testsuite,
15257 &cryptodev_esn_testsuite,
15258 &cryptodev_negative_aes_gcm_testsuite,
15259 &cryptodev_negative_aes_gmac_testsuite,
15260 &cryptodev_mixed_cipher_hash_testsuite,
15261 &cryptodev_negative_hmac_sha1_testsuite,
15262 &cryptodev_gen_testsuite,
15263 #ifdef RTE_LIB_SECURITY
15264 &ipsec_proto_testsuite,
15265 &pdcp_proto_testsuite,
15266 &docsis_proto_testsuite,
15270 static struct unit_test_suite ts = {
15271 .suite_name = "Cryptodev Unit Test Suite",
15272 .setup = testsuite_setup,
15273 .teardown = testsuite_teardown,
15274 .unit_test_cases = {TEST_CASES_END()}
15277 gbl_driver_id = rte_cryptodev_driver_id_get(pmd_name);
15279 if (gbl_driver_id == -1) {
15280 RTE_LOG(ERR, USER1, "%s PMD must be loaded.\n", pmd_name);
15281 return TEST_SKIPPED;
15284 ts.unit_test_suites = malloc(sizeof(struct unit_test_suite *) *
15285 (RTE_DIM(blk_suites) + RTE_DIM(static_suites)));
15287 ADD_BLOCKCIPHER_TESTSUITE(i, ts, blk_suites, RTE_DIM(blk_suites));
15288 ADD_STATIC_TESTSUITE(i, ts, static_suites, RTE_DIM(static_suites));
15289 ret = unit_test_suite_runner(&ts);
15291 FREE_BLOCKCIPHER_TESTSUITE(blk_start_idx, ts, RTE_DIM(blk_suites));
15292 free(ts.unit_test_suites);
15297 require_feature_flag(const char *pmd_name, uint64_t flag, const char *flag_name)
15299 struct rte_cryptodev_info dev_info;
15300 uint8_t i, nb_devs;
15303 driver_id = rte_cryptodev_driver_id_get(pmd_name);
15304 if (driver_id == -1) {
15305 RTE_LOG(WARNING, USER1, "%s PMD must be loaded.\n", pmd_name);
15306 return TEST_SKIPPED;
15309 nb_devs = rte_cryptodev_count();
15311 RTE_LOG(WARNING, USER1, "No crypto devices found?\n");
15312 return TEST_SKIPPED;
15315 for (i = 0; i < nb_devs; i++) {
15316 rte_cryptodev_info_get(i, &dev_info);
15317 if (dev_info.driver_id == driver_id) {
15318 if (!(dev_info.feature_flags & flag)) {
15319 RTE_LOG(INFO, USER1, "%s not supported\n",
15321 return TEST_SKIPPED;
15323 return 0; /* found */
15327 RTE_LOG(INFO, USER1, "%s not supported\n", flag_name);
15328 return TEST_SKIPPED;
15332 test_cryptodev_qat(void)
15334 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
15338 test_cryptodev_virtio(void)
15340 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD));
15344 test_cryptodev_aesni_mb(void)
15346 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
15350 test_cryptodev_cpu_aesni_mb(void)
15353 enum rte_security_session_action_type at = gbl_action_type;
15354 gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
15355 rc = run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
15356 gbl_action_type = at;
15361 test_cryptodev_chacha_poly_mb(void)
15364 enum rte_security_session_action_type at = gbl_action_type;
15365 rc = run_cryptodev_testsuite(
15366 RTE_STR(CRYPTODEV_NAME_CHACHA20_POLY1305_PMD));
15367 gbl_action_type = at;
15372 test_cryptodev_openssl(void)
15374 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
15378 test_cryptodev_aesni_gcm(void)
15380 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
15384 test_cryptodev_cpu_aesni_gcm(void)
15387 enum rte_security_session_action_type at = gbl_action_type;
15388 gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
15389 rc = run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
15390 gbl_action_type = at;
15395 test_cryptodev_mlx5(void)
15397 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_MLX5_PMD));
15401 test_cryptodev_null(void)
15403 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_NULL_PMD));
15407 test_cryptodev_sw_snow3g(void)
15409 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
15413 test_cryptodev_sw_kasumi(void)
15415 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
15419 test_cryptodev_sw_zuc(void)
15421 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
15425 test_cryptodev_armv8(void)
15427 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
15431 test_cryptodev_mrvl(void)
15433 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
15436 #ifdef RTE_CRYPTO_SCHEDULER
15439 test_cryptodev_scheduler(void)
15441 uint8_t ret, sched_i, j, i = 0, blk_start_idx = 0;
15442 const enum blockcipher_test_type blk_suites[] = {
15443 BLKCIPHER_AES_CHAIN_TYPE,
15444 BLKCIPHER_AES_CIPHERONLY_TYPE,
15445 BLKCIPHER_AUTHONLY_TYPE
15447 static struct unit_test_suite scheduler_multicore = {
15448 .suite_name = "Scheduler Multicore Unit Test Suite",
15449 .setup = scheduler_multicore_testsuite_setup,
15450 .teardown = scheduler_mode_testsuite_teardown,
15451 .unit_test_cases = {TEST_CASES_END()}
15453 static struct unit_test_suite scheduler_round_robin = {
15454 .suite_name = "Scheduler Round Robin Unit Test Suite",
15455 .setup = scheduler_roundrobin_testsuite_setup,
15456 .teardown = scheduler_mode_testsuite_teardown,
15457 .unit_test_cases = {TEST_CASES_END()}
15459 static struct unit_test_suite scheduler_failover = {
15460 .suite_name = "Scheduler Failover Unit Test Suite",
15461 .setup = scheduler_failover_testsuite_setup,
15462 .teardown = scheduler_mode_testsuite_teardown,
15463 .unit_test_cases = {TEST_CASES_END()}
15465 static struct unit_test_suite scheduler_pkt_size_distr = {
15466 .suite_name = "Scheduler Pkt Size Distr Unit Test Suite",
15467 .setup = scheduler_pkt_size_distr_testsuite_setup,
15468 .teardown = scheduler_mode_testsuite_teardown,
15469 .unit_test_cases = {TEST_CASES_END()}
15471 struct unit_test_suite *sched_mode_suites[] = {
15472 &scheduler_multicore,
15473 &scheduler_round_robin,
15474 &scheduler_failover,
15475 &scheduler_pkt_size_distr
15477 static struct unit_test_suite scheduler_config = {
15478 .suite_name = "Crypto Device Scheduler Config Unit Test Suite",
15479 .unit_test_cases = {
15480 TEST_CASE(test_scheduler_attach_worker_op),
15481 TEST_CASE(test_scheduler_mode_multicore_op),
15482 TEST_CASE(test_scheduler_mode_roundrobin_op),
15483 TEST_CASE(test_scheduler_mode_failover_op),
15484 TEST_CASE(test_scheduler_mode_pkt_size_distr_op),
15485 TEST_CASE(test_scheduler_detach_worker_op),
15487 TEST_CASES_END() /**< NULL terminate array */
15490 struct unit_test_suite *static_suites[] = {
15494 static struct unit_test_suite ts = {
15495 .suite_name = "Scheduler Unit Test Suite",
15496 .setup = scheduler_testsuite_setup,
15497 .teardown = testsuite_teardown,
15498 .unit_test_cases = {TEST_CASES_END()}
15501 gbl_driver_id = rte_cryptodev_driver_id_get(
15502 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
15504 if (gbl_driver_id == -1) {
15505 RTE_LOG(ERR, USER1, "SCHEDULER PMD must be loaded.\n");
15506 return TEST_SKIPPED;
15509 if (rte_cryptodev_driver_id_get(
15510 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) == -1) {
15511 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded.\n");
15512 return TEST_SKIPPED;
15515 for (sched_i = 0; sched_i < RTE_DIM(sched_mode_suites); sched_i++) {
15517 sched_mode_suites[sched_i]->unit_test_suites = malloc(sizeof
15518 (struct unit_test_suite *) *
15519 (RTE_DIM(blk_suites) + 1));
15520 ADD_BLOCKCIPHER_TESTSUITE(blk_i, (*sched_mode_suites[sched_i]),
15521 blk_suites, RTE_DIM(blk_suites));
15522 sched_mode_suites[sched_i]->unit_test_suites[blk_i] = &end_testsuite;
15525 ts.unit_test_suites = malloc(sizeof(struct unit_test_suite *) *
15526 (RTE_DIM(static_suites) + RTE_DIM(sched_mode_suites)));
15527 ADD_STATIC_TESTSUITE(i, ts, sched_mode_suites,
15528 RTE_DIM(sched_mode_suites));
15529 ADD_STATIC_TESTSUITE(i, ts, static_suites, RTE_DIM(static_suites));
15530 ret = unit_test_suite_runner(&ts);
15532 for (sched_i = 0; sched_i < RTE_DIM(sched_mode_suites); sched_i++) {
15533 FREE_BLOCKCIPHER_TESTSUITE(blk_start_idx,
15534 (*sched_mode_suites[sched_i]),
15535 RTE_DIM(blk_suites));
15536 free(sched_mode_suites[sched_i]->unit_test_suites);
15538 free(ts.unit_test_suites);
15542 REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler);
15547 test_cryptodev_dpaa2_sec(void)
15549 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
15553 test_cryptodev_dpaa_sec(void)
15555 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD));
15559 test_cryptodev_ccp(void)
15561 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CCP_PMD));
15565 test_cryptodev_octeontx(void)
15567 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD));
15571 test_cryptodev_octeontx2(void)
15573 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OCTEONTX2_PMD));
15577 test_cryptodev_caam_jr(void)
15579 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD));
15583 test_cryptodev_nitrox(void)
15585 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_NITROX_PMD));
15589 test_cryptodev_bcmfs(void)
15591 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_BCMFS_PMD));
15595 test_cryptodev_qat_raw_api(void)
15597 static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD);
15600 ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
15605 global_api_test_type = CRYPTODEV_RAW_API_TEST;
15606 ret = run_cryptodev_testsuite(pmd_name);
15607 global_api_test_type = CRYPTODEV_API_TEST;
15613 test_cryptodev_cn9k(void)
15615 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CN9K_PMD));
15619 test_cryptodev_cn10k(void)
15621 return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CN10K_PMD));
15625 test_cryptodev_dpaa2_sec_raw_api(void)
15627 static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD);
15630 ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
15635 global_api_test_type = CRYPTODEV_RAW_API_TEST;
15636 ret = run_cryptodev_testsuite(pmd_name);
15637 global_api_test_type = CRYPTODEV_API_TEST;
15643 test_cryptodev_dpaa_sec_raw_api(void)
15645 static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD);
15648 ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
15653 global_api_test_type = CRYPTODEV_RAW_API_TEST;
15654 ret = run_cryptodev_testsuite(pmd_name);
15655 global_api_test_type = CRYPTODEV_API_TEST;
15660 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_raw_api_autotest,
15661 test_cryptodev_dpaa2_sec_raw_api);
15662 REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_raw_api_autotest,
15663 test_cryptodev_dpaa_sec_raw_api);
15664 REGISTER_TEST_COMMAND(cryptodev_qat_raw_api_autotest,
15665 test_cryptodev_qat_raw_api);
15666 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
15667 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
15668 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_mb_autotest,
15669 test_cryptodev_cpu_aesni_mb);
15670 REGISTER_TEST_COMMAND(cryptodev_chacha_poly_mb_autotest,
15671 test_cryptodev_chacha_poly_mb);
15672 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl);
15673 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm);
15674 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_gcm_autotest,
15675 test_cryptodev_cpu_aesni_gcm);
15676 REGISTER_TEST_COMMAND(cryptodev_mlx5_autotest, test_cryptodev_mlx5);
15677 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null);
15678 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
15679 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);
15680 REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc);
15681 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_autotest, test_cryptodev_armv8);
15682 REGISTER_TEST_COMMAND(cryptodev_sw_mvsam_autotest, test_cryptodev_mrvl);
15683 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_autotest, test_cryptodev_dpaa2_sec);
15684 REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_autotest, test_cryptodev_dpaa_sec);
15685 REGISTER_TEST_COMMAND(cryptodev_ccp_autotest, test_cryptodev_ccp);
15686 REGISTER_TEST_COMMAND(cryptodev_virtio_autotest, test_cryptodev_virtio);
15687 REGISTER_TEST_COMMAND(cryptodev_octeontx_autotest, test_cryptodev_octeontx);
15688 REGISTER_TEST_COMMAND(cryptodev_octeontx2_autotest, test_cryptodev_octeontx2);
15689 REGISTER_TEST_COMMAND(cryptodev_caam_jr_autotest, test_cryptodev_caam_jr);
15690 REGISTER_TEST_COMMAND(cryptodev_nitrox_autotest, test_cryptodev_nitrox);
15691 REGISTER_TEST_COMMAND(cryptodev_bcmfs_autotest, test_cryptodev_bcmfs);
15692 REGISTER_TEST_COMMAND(cryptodev_cn9k_autotest, test_cryptodev_cn9k);
15693 REGISTER_TEST_COMMAND(cryptodev_cn10k_autotest, test_cryptodev_cn10k);